'''simple docstring'''




from dataclasses import dataclass, field
from typing import Tuple

from ..utils import cached_property, is_tf_available, logging, requires_backends
from .benchmark_args_utils import BenchmarkArguments


if is_tf_available():
						import tensorflow as tf


_lowercase		:				Optional[int]	       =		logging.get_logger(__name__)





@dataclass
class 					__magic_name__		(					_UpperCAmelCase):
			UpperCamelCase__       = [
			    '''no_inference''',
			    '''no_cuda''',
			    '''no_tpu''',
			    '''no_speed''',
			    '''no_memory''',
			    '''no_env_print''',
			    '''no_multi_process''',
			]







			def __init__(			self       :						Optional[Any]       ,    **lowercase_       :						Tuple					):
										for deprecated_arg in self.deprecated_args:
																	if deprecated_arg in kwargs:
																								lowercase_      :    Dict       		= deprecated_arg[3:]
																								lowercase_      :    Dict       		= not kwargs.pop(lowercase_					)
																								logger.warning(
																								    f'''{deprecated_arg} is depreciated. Please use --no-{positive_arg} or'''
																								    f''' {positive_arg}={kwargs[positive_arg]}'''					)
										lowercase_      :    Optional[Any]       		= kwargs.pop("""tpu_name"""       ,    self.tpu_name					)
										lowercase_      :    Optional[int]       		= kwargs.pop("""device_idx"""       ,    self.device_idx					)
										lowercase_      :    List[Any]       		= kwargs.pop("""eager_mode"""       ,    self.eager_mode					)
										lowercase_      :    Dict       		= kwargs.pop("""use_xla"""       ,    self.use_xla					)
										super().__init__(**lowercase_					)

			UpperCamelCase__       = field(
			    default=_UpperCAmelCase,  metadata={'''help''': '''Name of TPU'''},  )
			UpperCamelCase__       = field(
			    default=0,  metadata={'''help''': '''CPU / GPU device index. Defaults to 0.'''},  )
			UpperCamelCase__       = field(default=_UpperCAmelCase,  metadata={'''help''': '''Benchmark models in eager model.'''})
			UpperCamelCase__       = field(
			    default=_UpperCAmelCase,  metadata={
			        '''help''': '''Benchmark models using XLA JIT compilation. Note that `eager_model` has to be set to `False`.'''
			    },  )







			@cached_property
			def 			SCREAMING_SNAKE_CASE_  (			self       :						Optional[int]					):
										requires_backends(self       ,    ["""tf"""]					)
										lowercase_      :    Tuple       		= None
										if self.tpu:
																	try:
																								if self.tpu_name:
																															lowercase_      :    Optional[int]       		= tf.distribute.cluster_resolver.TPUClusterResolver(self.tpu_name					)
																								else:
																															lowercase_      :    Union[str, Any]       		= tf.distribute.cluster_resolver.TPUClusterResolver()
																	except ValueError:
																								lowercase_      :    Optional[int]       		= None
										return tpu







			@cached_property
			def 			SCREAMING_SNAKE_CASE_  (			self       :						Optional[Any]					):
										requires_backends(self       ,    ["""tf"""]					)
										if self.is_tpu:
																	tf.config.experimental_connect_to_cluster(self._setup_tpu					)
																	tf.tpu.experimental.initialize_tpu_system(self._setup_tpu					)

																	lowercase_      :    str       		= tf.distribute.TPUStrategy(self._setup_tpu					)
										else:
																	# currently no multi gpu is allowed
																	if self.is_gpu:
																								# TODO: Currently only single GPU is supported
																								tf.config.set_visible_devices(self.gpu_list[self.device_idx]       ,    """GPU"""					)
																								lowercase_      :    Union[str, Any]       		= tf.distribute.OneDeviceStrategy(device=f'''/gpu:{self.device_idx}'''					)
																	else:
																								tf.config.set_visible_devices([]       ,    """GPU"""					)  # disable GPU
																								lowercase_      :    Dict       		= tf.distribute.OneDeviceStrategy(device=f'''/cpu:{self.device_idx}'''					)

										return strategy







			@property
			def 			SCREAMING_SNAKE_CASE_  (			self       :						int					):
										requires_backends(self       ,    ["""tf"""]					)
										return self._setup_tpu is not None







			@property
			def 			SCREAMING_SNAKE_CASE_  (			self       :						Any					):
										requires_backends(self       ,    ["""tf"""]					)
										return self._setup_strategy







			@property
			def 			SCREAMING_SNAKE_CASE_  (			self       :						Union[str, Any]					):
										requires_backends(self       ,    ["""tf"""]					)
										return tf.config.list_physical_devices("""GPU"""					)







			@property
			def 			SCREAMING_SNAKE_CASE_  (			self       :						Optional[Any]					):
										requires_backends(self       ,    ["""tf"""]					)
										if self.cuda:
																	return len(self.gpu_list					)
										return 0







			@property
			def 			SCREAMING_SNAKE_CASE_  (			self       :						Optional[Any]					):
										return self.n_gpu > 0






'''simple docstring'''




import argparse

import intel_extension_for_pytorch as ipex
import torch

from diffusers import DPMSolverMultistepScheduler, StableDiffusionPipeline


_lowercase		:				Optional[Any]	       =		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")
_lowercase		:				Dict	       =		parser.parse_args()


_lowercase		:				Dict	       =		"cpu"
_lowercase		:				str	       =		"a lovely <dicoo> in red dress and hat, in the snowly and brightly night, with many brighly buildings"

_lowercase		:				Any	       =		"path-to-your-trained-model"
_lowercase		:				str	       =		StableDiffusionPipeline.from_pretrained(model_id)
if args.dpm:
						_lowercase		:				Optional[int]	       =		DPMSolverMultistepScheduler.from_config(pipe.scheduler.config)
_lowercase		:				Any	       =		pipe.to(device)

# to channels last
_lowercase		:				Union[str, Any]	       =		pipe.unet.to(memory_format=torch.channels_last)
_lowercase		:				List[Any]	       =		pipe.vae.to(memory_format=torch.channels_last)
_lowercase		:				Union[str, Any]	       =		pipe.text_encoder.to(memory_format=torch.channels_last)
if pipe.requires_safety_checker:
						_lowercase		:				Tuple	       =		pipe.safety_checker.to(memory_format=torch.channels_last)

# optimize with ipex
_lowercase		:				int	       =		torch.randn(2, 4, 64, 64)
_lowercase		:				int	       =		torch.rand(1) * 999
_lowercase		:				Union[str, Any]	       =		torch.randn(2, 77, 768)
_lowercase		:				Optional[Any]	       =		(sample, timestep, encoder_hidden_status)
try:
						_lowercase		:				int	       =		ipex.optimize(pipe.unet.eval(), dtype=torch.bfloataa, inplace=True, sample_input=input_example)
except Exception:
						_lowercase		:				Optional[int]	       =		ipex.optimize(pipe.unet.eval(), dtype=torch.bfloataa, inplace=True)
_lowercase		:				List[Any]	       =		ipex.optimize(pipe.vae.eval(), dtype=torch.bfloataa, inplace=True)
_lowercase		:				str	       =		ipex.optimize(pipe.text_encoder.eval(), dtype=torch.bfloataa, inplace=True)
if pipe.requires_safety_checker:
						_lowercase		:				int	       =		ipex.optimize(pipe.safety_checker.eval(), dtype=torch.bfloataa, inplace=True)

# compute
_lowercase		:				int	       =		666
_lowercase		:				Any	       =		torch.Generator(device).manual_seed(seed)
_lowercase		:				int	       =		{"generator": generator}
if args.steps is not None:
						_lowercase		:				Optional[int]	       =		args.steps

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

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





