Stable Diffusion XL と OpenVINO による画像生成#

import ipywidgets as widgets 
import openvino as ov 

core = ov.Core() 

device = widgets.Dropdown( 
    options=core.available_devices + ["AUTO"], 
    value="AUTO", 
    description="Device:", 
    disabled=False, 
) 

device

compress_weights = widgets.Checkbox( 
    description="Apply weight compression", 
    value=True, 

) compress_weights

def get_quantization_config(compress_weights): 
    quantization_config = None 
    if compress_weights.value: 
        from optimum.intel import OVWeightQuantizationConfig 

        quantization_config = OVWeightQuantizationConfig(bits=8) 
    return quantization_config 

quantization_config = get_quantization_config(compress_weights)

if not model_dir.exists(): 
    text2image_pipe = OVStableDiffusionXLPipeline.from_pretrained(model_id, compile=False, device=device.value, quantization_config=quantization_config) 
    text2image_pipe.half() 
    text2image_pipe.save_pretrained(model_dir)
    text2image_pipe.compile() 
else: 
    text2image_pipe = OVStableDiffusionXLPipeline.from_pretrained(model_dir, device=device.value)

import numpy as np 

prompt = "cute cat 4k, high-res, masterpiece, best quality, soft lighting, dynamic angle" 
image = text2image_pipe( 
    prompt, 
    num_inference_steps=15, 
    height=512, 
    width=512, 
    generator=np.random.RandomState(314), 
).images[0] 
image.save("cat.png") 
image

import gradio as gr 

if text2image_pipe is None: 
    text2image_pipe = OVStableDiffusionXLPipeline.from_pretrained(model_dir, device=device.value) 

prompt = "cute cat 4k, high-res, masterpiece, best quality, soft lighting, dynamic angle" 

def generate_from_text(text, seed, num_steps): 
    result = text2image_pipe( 
        text, 
        num_inference_steps=num_steps, 
        generator=np.random.RandomState(seed), 
        height=512, 
        width=512, 
    ).images[0] 
    return result 

with gr.Blocks() as demo: 
    with gr.Column(): 
        positive_input = gr.Textbox(label="Text prompt") 
        with gr.Row(): 
            seed_input = gr.Number(precision=0, label="Seed", value=42, minimum=0) 
            steps_input = gr.Slider(label="Steps", value=10) 
            btn = gr.Button() 
        out = gr.Image(label="Result", type="pil", width=512) 
        btn.click(generate_from_text, [positive_input, seed_input, steps_input], out) 
        gr.Examples( 
            [ 
                [prompt, 999, 20], 
                [ 
                    "underwater world coral reef, colorful jellyfish, 35mm, cinematic lighting, shallow depth of field, ultra quality, masterpiece, realistic", 
                    89, 
                    20, 
                ], 
                [ 
                    "a photo realistic happy white poodle dog ​​playing in the grass, extremely detailed, high res, 8k, masterpiece, dynamic angle", 
                    1569, 
                    15, 
                ], 
                [ 
                    "Astronaut on Mars watching sunset, best quality, cinematic effects,", 
                    65245, 
                    12, 
                ], 
                [ 
                    "Black and white street photography of a rainy night in New York, reflections on wet pavement", 
                    48199,
                    10, 
                ], 
            ], 
            [positive_input, seed_input, steps_input], 
        ) 

# リモートで起動する場合は、server_name と server_port を指定します 
# demo.launch(server_name='your server name', server_port='server port in int') 
# 詳細については、ドキュメントをご覧ください: https://gradio.app/docs/ 
# デモを共有するための公開リンクを作成したい場合は、share=True を追加してください 
demo.launch()

demo.close() 
text2image_pipe = None 
gc.collect();

import gradio as gr 
from diffusers.utils import load_image 
import numpy as np 

load_image("https://huggingface.co/datasets/optimum/documentation-images/resolve/main/intel/openvino/sd_xl/castle_friedrich.png").resize((512, 512)).save( 
    "castle_friedrich.png" 
) 

if image2image_pipe is None: 
    image2image_pipe = OVStableDiffusionXLImg2ImgPipeline.from_pretrained(model_dir) 

def generate_from_image(text, image, seed, num_steps): 
    result = image2image_pipe( 
        text, 
        image=image, 
        num_inference_steps=num_steps, 
        generator=np.random.RandomState(seed), 
    ).images[0] 
    return result 

with gr.Blocks() as demo: 
    with gr.Column(): 
        positive_input = gr.Textbox(label="Text prompt") 
        with gr.Row(): 
            seed_input = gr.Number(precision=0, label="Seed", value=42, minimum=0) 
            steps_input = gr.Slider(label="Steps", value=10) 
            btn = gr.Button() 
        with gr.Row(): 
            i2i_input = gr.Image(label="Input image", type="pil") 
            out = gr.Image(label="Result", type="pil", width=512) 
        btn.click( 
            generate_from_image, 
            [positive_input, i2i_input, seed_input, steps_input], 
            out, 
        ) 
        gr.Examples( 
            [ 
                ["amazing landscape from legends", "castle_friedrich.png", 971, 60], 
                [ 
                    "Masterpiece of watercolor painting in Van Gogh style", 
                    "cat.png", 
                    37890, 
                    40, 
                ], 
            ], 
            [positive_input, i2i_input, seed_input, steps_input], 
        ) 

# リモートで起動する場合は、server_name と server_port を指定 
# demo.launch(server_name='your server name', server_port='server port in int') 
# 詳細については、ドキュメントをご覧ください: https://gradio.app/docs/ 
# デモを共有するための公開リンクを作成したい場合は、share=True を追加 
demo.launch()

demo.close() 
del image2image_pipe 
gc.collect()

device

import numpy as np 
import gc 

model_dir = Path("openvino-sd-xl-base-1.0") 
base = OVStableDiffusionXLPipeline.from_pretrained(model_dir, device=device.value) 
prompt = "cute cat 4k, high-res, masterpiece, best quality, soft lighting, dynamic angle" 
latents = base( 
    prompt, 
    num_inference_steps=15, 
    height=512, 
    width=512, 
    generator=np.random.RandomState(314), 
    output_type="latent", 
).images[0] 

del base 
gc.collect()

refiner = OVStableDiffusionXLImg2ImgPipeline.from_pretrained(refiner_model_dir, device=device.value)

image = refiner( 
    prompt=prompt, 
    image=np.transpose(latents[None, :], (0, 2, 3, 1)), 
    num_inference_steps=15, 
    generator=np.random.RandomState(314), 
).images[0] 
image.save("cat_refined.png") 

image