File size: 2,244 Bytes
fa4d13f
9aa593c
 
 
 
 
 
 
 
656c5a0
a80935d
9aa593c
 
 
 
 
 
a80935d
 
9aa593c
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
import gradio as gr
import jax
import numpy as np
import jax.numpy as jnp
from flax.jax_utils import replicate
from flax.training.common_utils import shard
from diffusers.utils import load_image
from PIL import Image
from diffusers import FlaxStableDiffusionControlNetPipeline, FlaxControlNetModel


def image_grid(imgs, rows, cols):
    w, h = imgs[0].size
    grid = Image.new("RGB", size=(cols * w, rows * h))
    for i, img in enumerate(imgs):
        grid.paste(img, box=(i % cols * w, i // cols * h))
    return grid


def create_key(seed=0):
    return jax.random.PRNGKey(seed)


rng = create_key(0)


def canny_filter(image):

    ## TODO: Implement canny filter here
    return canny_image

def infer(prompts, negative_prompts, image):
    
    
    # load control net and stable diffusion v1-5
    controlnet, controlnet_params = FlaxControlNetModel.from_pretrained(
        "jax-diffusers-event/canny-coyo1m", from_pt=True, dtype=jnp.float32
    )
    pipe, params = FlaxStableDiffusionControlNetPipeline.from_pretrained(
        "runwayml/stable-diffusion-v1-5", controlnet=controlnet, from_pt=True, dtype=jnp.float32
    )
    params["controlnet"] = controlnet_params
    
    num_samples = jax.device_count()
    rng = jax.random.split(rng, jax.device_count())
    canny_image = canny_filter(image)
    
    prompt_ids = pipe.prepare_text_inputs([prompts] * num_samples)
    negative_prompt_ids = pipe.prepare_text_inputs([negative_prompts] * num_samples)
    processed_image = pipe.prepare_image_inputs([canny_image] * num_samples)
    
    p_params = replicate(params)
    prompt_ids = shard(prompt_ids)
    negative_prompt_ids = shard(negative_prompt_ids)
    processed_image = shard(processed_image)
    
    output = pipe(
        prompt_ids=prompt_ids,
        image=processed_image,
        params=p_params,
        prng_seed=rng,
        num_inference_steps=50,
        neg_prompt_ids=negative_prompt_ids,
        jit=True,
    ).images
    
    output_images = pipe.numpy_to_pil(np.asarray(output.reshape((num_samples,) + output.shape[-3:])))
    output_images = image_grid(output_images, num_samples // 4, 4)
    return output_images

gr.Interface(pipeline, inputs=["text", "text", "image"], outputs="gallery").launch()