





import argparse

import intel_extension_for_pytorch as ipex
import torch

from diffusers import DPMSolverMultistepScheduler, StableDiffusionPipeline


UpperCamelCase_												=	argparse.ArgumentParser('Stable Diffusion script with intel optimization', add_help=False)
parser.add_argument('--dpm', action='store_true', help='Enable DPMSolver or not')
parser.add_argument('--steps', default=None, type=int, help='Num inference steps')
UpperCamelCase_												=	parser.parse_args()


UpperCamelCase_												=	'cpu'
UpperCamelCase_												=	'a lovely <dicoo> in red dress and hat, in the snowly and brightly night, with many brighly buildings'

UpperCamelCase_												=	'path-to-your-trained-model'
UpperCamelCase_												=	StableDiffusionPipeline.from_pretrained(model_id)
if args.dpm:
    UpperCamelCase_												=	DPMSolverMultistepScheduler.from_config(pipe.scheduler.config)
UpperCamelCase_												=	pipe.to(device)

# to channels last
UpperCamelCase_												=	pipe.unet.to(memory_format=torch.channels_last)
UpperCamelCase_												=	pipe.vae.to(memory_format=torch.channels_last)
UpperCamelCase_												=	pipe.text_encoder.to(memory_format=torch.channels_last)
if pipe.requires_safety_checker:
    UpperCamelCase_												=	pipe.safety_checker.to(memory_format=torch.channels_last)

# optimize with ipex
UpperCamelCase_												=	torch.randn(2, 4, 64, 64)
UpperCamelCase_												=	torch.rand(1) * 9_99
UpperCamelCase_												=	torch.randn(2, 77, 7_68)
UpperCamelCase_												=	(sample, timestep, encoder_hidden_status)
try:
    UpperCamelCase_												=	ipex.optimize(pipe.unet.eval(), dtype=torch.bfloataa, inplace=True, sample_input=input_example)
except Exception:
    UpperCamelCase_												=	ipex.optimize(pipe.unet.eval(), dtype=torch.bfloataa, inplace=True)
UpperCamelCase_												=	ipex.optimize(pipe.vae.eval(), dtype=torch.bfloataa, inplace=True)
UpperCamelCase_												=	ipex.optimize(pipe.text_encoder.eval(), dtype=torch.bfloataa, inplace=True)
if pipe.requires_safety_checker:
    UpperCamelCase_												=	ipex.optimize(pipe.safety_checker.eval(), dtype=torch.bfloataa, inplace=True)

# compute
UpperCamelCase_												=	6_66
UpperCamelCase_												=	torch.Generator(device).manual_seed(seed)
UpperCamelCase_												=	{'generator': generator}
if args.steps is not None:
    UpperCamelCase_												=	args.steps

with torch.cpu.amp.autocast(enabled=True, dtype=torch.bfloataa):
    UpperCamelCase_												=	pipe(prompt, **generate_kwargs).images[0]

# save image
image.save('generated.png')










from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
    is_vision_available,
)


UpperCamelCase_												=	{
    'configuration_owlvit': [
        'OWLVIT_PRETRAINED_CONFIG_ARCHIVE_MAP',
        'OwlViTConfig',
        'OwlViTOnnxConfig',
        'OwlViTTextConfig',
        'OwlViTVisionConfig',
    ],
    'processing_owlvit': ['OwlViTProcessor'],
}


try:
    if not is_vision_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    UpperCamelCase_												=	['OwlViTFeatureExtractor']
    UpperCamelCase_												=	['OwlViTImageProcessor']

try:
    if not is_torch_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    UpperCamelCase_												=	[
        'OWLVIT_PRETRAINED_MODEL_ARCHIVE_LIST',
        'OwlViTModel',
        'OwlViTPreTrainedModel',
        'OwlViTTextModel',
        'OwlViTVisionModel',
        'OwlViTForObjectDetection',
    ]

if TYPE_CHECKING:
    from .configuration_owlvit import (
        OWLVIT_PRETRAINED_CONFIG_ARCHIVE_MAP,
        OwlViTConfig,
        OwlViTOnnxConfig,
        OwlViTTextConfig,
        OwlViTVisionConfig,
    )
    from .processing_owlvit import OwlViTProcessor

    try:
        if not is_vision_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .feature_extraction_owlvit import OwlViTFeatureExtractor
        from .image_processing_owlvit import OwlViTImageProcessor

    try:
        if not is_torch_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .modeling_owlvit import (
            OWLVIT_PRETRAINED_MODEL_ARCHIVE_LIST,
            OwlViTForObjectDetection,
            OwlViTModel,
            OwlViTPreTrainedModel,
            OwlViTTextModel,
            OwlViTVisionModel,
        )

else:
    import sys

    UpperCamelCase_												=	_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)



