Stable Diffusion と 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

from optimum.intel.openvino import OVStableDiffusionPipeline 
from pathlib import Path 

DEVICE = device.value 

MODEL_ID = "prompthero/openjourney" 
MODEL_DIR = Path("diffusion_pipeline") 

if not MODEL_DIR.exists(): 
    ov_pipe = OVStableDiffusionPipeline.from_pretrained(MODEL_ID, export=True, device=DEVICE, compile=False) 
    ov_pipe.save_pretrained(MODEL_DIR) 
else: 
    ov_pipe = OVStableDiffusionPipeline.from_pretrained(MODEL_DIR, device=DEVICE, compile=False) 

ov_pipe.compile()

sample_text = ( 
    "cyberpunk cityscape like Tokyo New York with tall buildings at dusk golden hour cinematic lighting, epic composition.   " 
    "A golden daylight, hyper-realistic environment.   " 
    "Hyper and intricate detail, photo-realistic.   " 
    "Cinematic and volumetric light.   " "Epic concept art." 
    "Octane render and Unreal Engine, trending on artstation" 
) 
text_prompt = widgets.Text(value=sample_text, description="your text") 
num_steps = widgets.IntSlider(min=1, max=50, value=20, description="steps:") 
seed = widgets.IntSlider(min=0, max=10000000, description="seed: ", value=42) 
widgets.VBox([text_prompt, num_steps, seed])

print("Pipeline settings") 
print(f"Input text: {text_prompt.value}") 
print(f"Seed: {seed.value}") 
print(f"Number of steps: {num_steps.value}")

import numpy as np 

np.random.seed(seed.value) 

result = ov_pipe(text_prompt.value, num_inference_steps=num_steps.value) 

final_image = result["images"][0] 
final_image.save("result.png")

text = "\n\t".join(text_prompt.value.split(".")) 
print("Input text:") 
print("\t" + text) 
display(final_image)

import gradio as gr 

def generate_from_text(text, seed, num_steps, _=gr.Progress(track_tqdm=True)): 
    np.random.seed(seed) 
    result = ov_pipe(text, num_inference_steps=num_steps) 
    return result["images"][0] 

with gr.Blocks() as demo: 
    with gr.Tab("Text-to-Image generation"): 
        with gr.Row(): 
            with gr.Column(): 
                text_input = gr.Textbox(lines=3, label="Text") 
                seed_input = gr.Slider(0, 10000000, value=42, step=1, label="Seed") 
                steps_input = gr.Slider(1, 50, value=20, step=1, label="Steps") 
            out = gr.Image(label="Result", type="pil") 
        btn = gr.Button() 
        btn.click(generate_from_text, [text_input, seed_input, steps_input], out) 
        gr.Examples([[sample_text, 42, 20]], [text_input, seed_input, steps_input]) 
try: 
    demo.queue().launch() 
except Exception: 
    demo.queue().launch(share=True) 
# リモートで起動する場合は、server_name と server_port を指定 
# demo.launch(server_name='your server name', server_port='server port in int') 
# 詳細はドキュメントをご覧ください: https://gradio.app/docs/

demo.close() 
del ov_pipe 
np.random.seed(None)

core = ov.Core() 

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

device

from optimum.intel.openvino import OVStableDiffusionImg2ImgPipeline 
from pathlib import Path 

DEVICE = device.value 

ov_pipe_i2i = OVStableDiffusionImg2ImgPipeline.from_pretrained(MODEL_DIR, device=DEVICE, compile=False) 
ov_pipe_i2i.compile()

text_prompt_i2i = widgets.Text(value="amazing watercolor painting", description="your text") 
num_steps_i2i = widgets.IntSlider(min=1, max=50, value=10, description="steps:") 
seed_i2i = widgets.IntSlider(min=0, max=1024, description="seed: ", value=42) 
image_widget = widgets.FileUpload( 
    accept="", 
    multiple=False, 
    description="Upload image", 
) 
strength = widgets.FloatSlider(min=0, max=1, description="strength: ", value=0.5) 
widgets.VBox([text_prompt_i2i, seed_i2i, num_steps_i2i, image_widget, strength])

# `notebook_utils` モジュールを取得 
import requests 

r = requests.get( 

url="https://raw.githubusercontent.com/openvinotoolkit/openvino_notebooks/latest/utils/notebook_utils.py", 
) 

open("notebook_utils.py", "w").write(r.text) 

from notebook_utils import download_file

import io 
import PIL 

default_image_path = download_file( 
    "https://storage.openvinotoolkit.org/repositories/openvino_notebooks/data/data/image/coco.jpg", 
    filename="coco.jpg", 
) 

# アップロードされた画像をリード 
image = PIL.Image.open(io.BytesIO(image_widget.value[-1]["content"]) if image_widget.value else str(default_image_path)) 
print("Pipeline settings") 
print(f"Input text: {text_prompt_i2i.value}") 
print(f"Seed: {seed_i2i.value}") 
print(f"Number of steps: {num_steps_i2i.value}") 
print(f"Strength: {strength.value}") 
print("Input image:") display(image)

import PIL 
import numpy as np 

def scale_fit_to_window(dst_width: int, dst_height: int, image_width: int, image_height: int): 
    """ 
    Preprocessing helper function for calculating image size for resize with peserving original aspect ratio 
    and fitting image to specific window size 

    Parameters: 
        dst_width (int): destination window width 
        dst_height (int): destination window height 
        image_width (int): source image width 
        image_height (int): source image height 
    Returns: 
        result_width (int): calculated width for resize 
        result_height (int): calculated height for resize 
    """ 
    im_scale = min(dst_height / image_height, dst_width / image_width) 
    return int(im_scale * image_width), int(im_scale * image_height) 

def preprocess(image: PIL.Image.Image): 
    """ 
    Image preprocessing function.    Takes image in PIL.Image format, resizes it to keep aspect ration and fits to model input window 512x512, 
    then converts it to np.ndarray and adds padding with zeros on right or bottom side of image (depends from aspect ratio), after that 
    converts data to float32 data type and change range of values from [0, 255] to [-1, 1]. The function returns preprocessed input tensor and padding size, which can be used in postprocessing. 
    Parameters: 
        image (PIL.Image.Image): input image 
    Returns: 
        image (np.ndarray): preprocessed image tensor 
        meta (Dict): dictionary with preprocessing metadata info 
    """ 
    src_width, src_height = image.size 
    dst_width, dst_height = scale_fit_to_window(512, 512, src_width, src_height) 
    image = np.array(image.resize((dst_width, dst_height), resample=PIL.Image.Resampling.LANCZOS))[None, :] 
    pad_width = 512 - dst_width 
    pad_height = 512 - dst_height 
    pad = ((0, 0), (0, pad_height), (0, pad_width), (0, 0)) 
    image = np.pad(image, pad, mode="constant") 
    image = image.astype(np.float32) / 255.0 
    image = 2.0 * image - 1.0 
    return image, {"padding": pad, "src_width": src_width, "src_height": src_height} 

def postprocess(image: PIL.Image.Image, orig_width: int, orig_height: int): 
    """ 
    Image postprocessing function. Takes image in PIL.Image format and metrics of original image. Image is cropped and resized to restore initial size. 
    Parameters: 
        image (PIL.Image.Image): input image 
        orig_width (int): original image width 
        orig_height (int): original image height 
    Returns: 
        image (PIL.Image.Image): postprocess image 
    """ 
    src_width, src_height = image.size 
    dst_width, dst_height = scale_fit_to_window(src_width, src_height, orig_width, orig_height) 
    image = image.crop((0, 0, dst_width, dst_height)) 
    image = image.resize((orig_width, orig_height)) 
    return image

preprocessed_image, meta_data = preprocess(image) 

np.random.seed(seed_i2i.value) 

processed_image = ov_pipe_i2i(text_prompt_i2i.value, preprocessed_image, 
num_inference_steps=num_steps_i2i.value, strength=strength.value)

final_image_i2i = postprocess(processed_image["images"][0], meta_data["src_width"], meta_data["src_height"]) 
final_image_i2i.save("result_i2i.png")

text_i2i = "\n\t".join(text_prompt_i2i.value.split(".")) 
print("Input text:") 
print("\t" + text_i2i) 
display(final_image_i2i)

import gradio as gr 

def generate_from_image(img, text, seed, num_steps, strength, _=gr.Progress(track_tqdm=True)): 
    preprocessed_img, meta_data = preprocess(img) 
    np.random.seed(seed) 
    result = ov_pipe_i2i(text, preprocessed_img, num_inference_steps=num_steps, strength=strength) 
    result_img = postprocess(result["images"][0], meta_data["src_width"], meta_data["src_height"]) 
    return result_img 

with gr.Blocks() as demo: 
    with gr.Tab("Image-to-Image generation"): 
        with gr.Row(): 
            with gr.Column(): 
                i2i_input = gr.Image(label="Image", type="pil") 
                i2i_text_input = gr.Textbox(lines=3, label="Text") 
                i2i_seed_input = gr.Slider(0, 1024, value=42, step=1, label="Seed") 
                i2i_steps_input = gr.Slider(1, 50, value=10, step=1, label="Steps") 
                strength_input = gr.Slider(0, 1, value=0.5, label="Strength") 
            i2i_out = gr.Image(label="Result") 
        i2i_btn = gr.Button() 
        sample_i2i_text = "amazing watercolor painting" 
        i2i_btn.click( 
            generate_from_image, 
            [ 
                i2i_input, 
                i2i_text_input, 
                i2i_seed_input, 
                i2i_steps_input, 
                strength_input, 
            ], 
            i2i_out, 
        ) 
        gr.Examples( 
            [[str(default_image_path), sample_i2i_text, 42, 10, 0.5]], 
            [ 
                i2i_input, 
                i2i_text_input, 
                i2i_seed_input, 
                i2i_steps_input, 
                strength_input, 
            ], 
        ) 

try: 
    demo.queue().launch() 
except Exception: 
    demo.queue().launch(share=True)
# リモートで起動する場合は、server_name と server_port を指定 
# demo.launch(server_name='your server name', server_port='server port in int') 
# 詳細はドキュメントをご覧ください: https://gradio.app/docs/

demo.close()