app.py

from io import BytesIO
import torch
import numpy as np
from PIL import Image
from einops import rearrange
from torch import autocast
from contextlib import nullcontext
import requests
import functools

from ldm.models.diffusion.ddim import DDIMSampler
from ldm.models.diffusion.plms import PLMSSampler
from ldm.extras import load_model_from_config, load_training_dir
import clip

from PIL import Image

from huggingface_hub import hf_hub_download
ckpt = hf_hub_download(repo_id="lambdalabs/image-mixer", filename="image-mixer-pruned.ckpt")
config = hf_hub_download(repo_id="lambdalabs/image-mixer", filename="image-mixer-config.yaml")

device = "cuda:0"
model = load_model_from_config(config, ckpt, device=device, verbose=False)
model = model.to(device).half()

clip_model, preprocess = clip.load("ViT-L/14", device=device)

n_inputs = 5

torch.cuda.empty_cache()

@functools.lru_cache()
def get_url_im(t):
    user_agent = {'User-agent': 'gradio-app'}
    response = requests.get(t, headers=user_agent)
    return Image.open(BytesIO(response.content))

@torch.no_grad()
def get_im_c(im_path, clip_model):
    # im = Image.open(im_path).convert("RGB")
    prompts = preprocess(im_path).to(device).unsqueeze(0)
    return clip_model.encode_image(prompts).float()

@torch.no_grad()
def get_txt_c(txt, clip_model):
    text = clip.tokenize([txt,]).to(device)
    return clip_model.encode_text(text)

def get_txt_diff(txt1, txt2, clip_model):
    return get_txt_c(txt1, clip_model) - get_txt_c(txt2, clip_model)

def to_im_list(x_samples_ddim):
    x_samples_ddim = torch.clamp((x_samples_ddim + 1.0) / 2.0, min=0.0, max=1.0)
    ims = []
    for x_sample in x_samples_ddim:
        x_sample = 255. * rearrange(x_sample.cpu().numpy(), 'c h w -> h w c')
        ims.append(Image.fromarray(x_sample.astype(np.uint8)))
    return ims

@torch.no_grad()
def sample(sampler, model, c, uc, scale, start_code, h=512, w=512, precision="autocast",ddim_steps=50):
    ddim_eta=0.0
    precision_scope = autocast if precision=="autocast" else nullcontext
    with precision_scope("cuda"):
        shape = [4, h // 8, w // 8]
        samples_ddim, _ = sampler.sample(S=ddim_steps,
                                            conditioning=c,
                                            batch_size=c.shape[0],
                                            shape=shape,
                                            verbose=False,
                                            unconditional_guidance_scale=scale,
                                            unconditional_conditioning=uc,
                                            eta=ddim_eta,
                                            x_T=start_code)

        x_samples_ddim = model.decode_first_stage(samples_ddim)
    return to_im_list(x_samples_ddim)

def run(*args):

    inps = []
    for i in range(0, len(args)-4, n_inputs):
        inps.append(args[i:i+n_inputs])

    scale, n_samples, seed, steps = args[-4:]
    h = w = 640

    sampler = DDIMSampler(model)
    # sampler = PLMSSampler(model)

    torch.manual_seed(seed)
    start_code = torch.randn(n_samples, 4, h//8, w//8, device=device)
    conds = []

    for b, t, im, s in zip(*inps):
        if b == "Image":
            this_cond = s*get_im_c(im, clip_model)
        elif b == "Text/URL":
            if t.startswith("http"):
                im = get_url_im(t)
                this_cond = s*get_im_c(im, clip_model)
            else:
                this_cond = s*get_txt_c(t, clip_model)
        else:
            this_cond = torch.zeros((1, 768), device=device)
        conds.append(this_cond)
    conds = torch.cat(conds, dim=0).unsqueeze(0)
    conds = conds.tile(n_samples, 1, 1)

    ims = sample(sampler, model, conds, 0*conds, scale, start_code, ddim_steps=steps)
    # return make_row(ims)
    return ims


import gradio as gr
from functools import partial
from itertools import chain

def change_visible(txt1, im1, val):
    outputs = {}
    if val == "Image":
        outputs[im1] = gr.update(visible=True)
        outputs[txt1] = gr.update(visible=False)
    elif val == "Text/URL":
        outputs[im1] = gr.update(visible=False)
        outputs[txt1] = gr.update(visible=True)
    elif val == "Nothing":
        outputs[im1] = gr.update(visible=False)
        outputs[txt1] = gr.update(visible=False)
    return outputs


with gr.Blocks(title="Image Mixer") as demo:

    gr.Markdown("")
    gr.Markdown(
"""
# Image Mixer

_Created by [Justin Pinkney](https://www.justinpinkney.com) at [Lambda Labs](https://lambdalabs.com/)_

### __Provide one or more images to be mixed together by a fine-tuned Stable Diffusion model.__

![banner-large.jpeg](https://s3.amazonaws.com/moonup/production/uploads/1674038658679-62bd5f951e22ec84279820e8.jpeg)

""")

    btns = []
    txts = []
    ims = []
    strengths = []

    with gr.Row():
        for i in range(n_inputs):
            with gr.Column():
                btn1 = gr.Radio(
                    choices=["Image", "Text/URL", "Nothing"],
                    label=f"Input {i} type",
                    interactive=True,
                    value="Nothing",
                    )
                txt1 = gr.Textbox(label="Text or Image URL", visible=False, interactive=True)
                im1 = gr.Image(label="Image", interactive=True, visible=False, type="pil")
                strength = gr.Slider(label="Strength", minimum=0, maximum=5, step=0.05, value=1, interactive=True)

                fn = partial(change_visible, txt1, im1)
                btn1.change(fn=fn, inputs=[btn1], outputs=[txt1, im1])

                btns.append(btn1)
                txts.append(txt1)
                ims.append(im1)
                strengths.append(strength)
    with gr.Row():
        cfg_scale = gr.Slider(label="CFG scale", value=3, minimum=1, maximum=10, step=0.5)
        n_samples = gr.Slider(label="Num samples", value=2, minimum=1, maximum=2, step=1)
        seed = gr.Slider(label="Seed", value=0, minimum=0, maximum=10000, step=1)
        steps = gr.Slider(label="Steps", value=30, minimum=10, maximum=100, step=5)

    with gr.Row():
        submit = gr.Button("Generate")
    output = gr.Gallery().style(grid=[1,2], height="640px")

    inps = list(chain(btns, txts, ims, strengths))
    inps.extend([cfg_scale,n_samples,seed, steps,])
    submit.click(fn=run, inputs=inps, outputs=[output])

    gr.Markdown(
"""

## Tips

- You can provide between 1 and 5 inputs, these can either be an uploaded image a text prompt or a url to an image file.
- The order of the inputs shouldn't matter, any images will be centre cropped before use.
- Each input has an individual strength parameter which controls how big an influence it has on the output.
- Using only text prompts doesn't work well, make sure there is at least one image or URL to an image.
- The parameters on the bottom row such as cfg scale do the same as for a normal Stable Diffusion model.
- Balancing the different inputs requires tweaking of the strengths, I suggest getting the right balance for a small number of samples and with few steps until you're
happy with the result then increase the steps for better quality.
- Outputs are 640x640 by default.

## How does this work?

This model is based on the [Stable Diffusion Image Variations model](https://huggingface.co/lambdalabs/sd-image-variations-diffusers)
but it has been fined tuned to take multiple CLIP image embeddings. During training, up to 5 random crops were taken from the training images and
the CLIP image embeddings were computed, these were then concatenated and used as the conditioning for the model. At inference time we can combine the image
embeddings from multiple images to mix their concepts (and we can also use the text encoder to add text concepts too).

The model was trained on a subset of LAION Improved Aesthetics at a resolution of 640x640 and was trained using 8xA100 GPUs on [Lambda GPU Cloud](https://lambdalabs.com/service/gpu-cloud).

""")

demo.launch()