
"""simple docstring"""



import collections
import inspect
import unittest
from typing import Dict, List, Tuple

from transformers import MaskFormerSwinConfig
from transformers.testing_utils import require_torch, require_torch_multi_gpu, torch_device
from transformers.utils import is_torch_available

from ...test_backbone_common import BackboneTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
	import torch
	from torch import nn

	from transformers import MaskFormerSwinBackbone
	from transformers.models.maskformer import MaskFormerSwinModel
class        _SCREAMING_SNAKE_CASE  :






				'''simple docstring'''



				def __init__(					self	:			Optional[int]				,     UpperCAmelCase_	:			int				,     UpperCAmelCase_	:			Optional[int]=13				,     UpperCAmelCase_	:			str=32				,     UpperCAmelCase_	:			Any=2				,     UpperCAmelCase_	:			Dict=3				,     UpperCAmelCase_	:			str=16				,     UpperCAmelCase_	:			Union[str, Any]=[1, 2, 1]				,     UpperCAmelCase_	:			List[str]=[2, 2, 4]				,     UpperCAmelCase_	:			Tuple=2				,     UpperCAmelCase_	:			Tuple=2.0				,     UpperCAmelCase_	:			Optional[Any]=True				,     UpperCAmelCase_	:			Dict=0.0				,     UpperCAmelCase_	:			Tuple=0.0				,     UpperCAmelCase_	:			List[str]=0.1				,     UpperCAmelCase_	:			str="gelu"				,     UpperCAmelCase_	:			Dict=False				,     UpperCAmelCase_	:			Tuple=True				,     UpperCAmelCase_	:			str=0.02				,     UpperCAmelCase_	:			List[str]=1E-5				,     UpperCAmelCase_	:			Any=True				,     UpperCAmelCase_	:			Optional[Any]=None				,     UpperCAmelCase_	:			Optional[Any]=True				,     UpperCAmelCase_	:			Dict=10				,     UpperCAmelCase_	:			Dict=8				,     UpperCAmelCase_	:			str=["stage1", "stage2", "stage3"]				,     UpperCAmelCase_	:			List[str]=[1, 2, 3]				,     )		->  Any:







											"""simple docstring"""




											_lowerCAmelCase  	=			parent
											_lowerCAmelCase  	=			batch_size
											_lowerCAmelCase  	=			image_size
											_lowerCAmelCase  	=			patch_size
											_lowerCAmelCase  	=			num_channels
											_lowerCAmelCase  	=			embed_dim
											_lowerCAmelCase  	=			depths
											_lowerCAmelCase  	=			num_heads
											_lowerCAmelCase  	=			window_size
											_lowerCAmelCase  	=			mlp_ratio
											_lowerCAmelCase  	=			qkv_bias
											_lowerCAmelCase  	=			hidden_dropout_prob
											_lowerCAmelCase  	=			attention_probs_dropout_prob
											_lowerCAmelCase  	=			drop_path_rate
											_lowerCAmelCase  	=			hidden_act
											_lowerCAmelCase  	=			use_absolute_embeddings
											_lowerCAmelCase  	=			patch_norm
											_lowerCAmelCase  	=			layer_norm_eps
											_lowerCAmelCase  	=			initializer_range
											_lowerCAmelCase  	=			is_training
											_lowerCAmelCase  	=			scope
											_lowerCAmelCase  	=			use_labels
											_lowerCAmelCase  	=			type_sequence_label_size
											_lowerCAmelCase  	=			encoder_stride
											_lowerCAmelCase  	=			out_features
											_lowerCAmelCase  	=			out_indices


				def 				__lowerCamelCase	(					self	:			str  )		->  Union[str, Any]:







											"""simple docstring"""




											_lowerCAmelCase  	=			floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]  )

											_lowerCAmelCase  	=			None
											if self.use_labels:
																		_lowerCAmelCase  	=			ids_tensor([self.batch_size]				,     self.type_sequence_label_size  )

											_lowerCAmelCase  	=			self.get_config()

											return config, pixel_values, labels


				def 				__lowerCamelCase	(					self	:			Any  )		->  Optional[Any]:







											"""simple docstring"""




											return MaskFormerSwinConfig(
											    image_size=self.image_size				,     patch_size=self.patch_size				,     num_channels=self.num_channels				,     embed_dim=self.embed_dim				,     depths=self.depths				,     num_heads=self.num_heads				,     window_size=self.window_size				,     mlp_ratio=self.mlp_ratio				,     qkv_bias=self.qkv_bias				,     hidden_dropout_prob=self.hidden_dropout_prob				,     attention_probs_dropout_prob=self.attention_probs_dropout_prob				,     drop_path_rate=self.drop_path_rate				,     hidden_act=self.hidden_act				,     use_absolute_embeddings=self.use_absolute_embeddings				,     path_norm=self.patch_norm				,     layer_norm_eps=self.layer_norm_eps				,     initializer_range=self.initializer_range				,     encoder_stride=self.encoder_stride				,     out_features=self.out_features				,     out_indices=self.out_indices				,     )


				def 				__lowerCamelCase	(					self	:			int				,     UpperCAmelCase_	:			Optional[int]				,     UpperCAmelCase_	:			str				,     UpperCAmelCase_	:			Any  )		->  Union[str, Any]:







											"""simple docstring"""




											_lowerCAmelCase  	=			MaskFormerSwinModel(config=UpperCAmelCase_  )
											model.to(UpperCAmelCase_  )
											model.eval()
											_lowerCAmelCase  	=			model(UpperCAmelCase_  )

											_lowerCAmelCase  	=			((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths  ) - 1))
											_lowerCAmelCase  	=			int(config.embed_dim * 2 ** (len(config.depths  ) - 1)  )

											self.parent.assertEqual(result.last_hidden_state.shape				,     (self.batch_size, expected_seq_len, expected_dim)  )


				def 				__lowerCamelCase	(					self	:			Optional[int]				,     UpperCAmelCase_	:			Tuple				,     UpperCAmelCase_	:			int				,     UpperCAmelCase_	:			Optional[Any]  )		->  List[str]:







											"""simple docstring"""




											_lowerCAmelCase  	=			MaskFormerSwinBackbone(config=UpperCAmelCase_  )
											model.to(UpperCAmelCase_  )
											model.eval()
											_lowerCAmelCase  	=			model(UpperCAmelCase_  )

											# verify feature maps
											self.parent.assertEqual(len(result.feature_maps  )				,     len(config.out_features  )  )
											self.parent.assertListEqual(list(result.feature_maps[0].shape  )				,     [13, 16, 16, 16]  )

											# verify channels
											self.parent.assertEqual(len(model.channels  )				,     len(config.out_features  )  )
											self.parent.assertListEqual(model.channels				,     [16, 32, 64]  )

											# verify ValueError
											with self.parent.assertRaises(UpperCAmelCase_  ):
																		_lowerCAmelCase  	=			['''stem''']
																		_lowerCAmelCase  	=			MaskFormerSwinBackbone(config=UpperCAmelCase_  )







				def 				__lowerCamelCase	(					self	:			Optional[int]  )		->  Optional[int]:







											"""simple docstring"""




											_lowerCAmelCase  	=			self.prepare_config_and_inputs()
											_lowerCAmelCase  	=			config_and_inputs
											_lowerCAmelCase  	=			{'''pixel_values''': pixel_values}
											return config, inputs_dict






@require_torch
class        _SCREAMING_SNAKE_CASE  (  __A      ,				__A      ,				unittest.TestCase							):






				'''simple docstring'''



				SCREAMING_SNAKE_CASE_:							str							=					(
				    (
				        MaskFormerSwinModel,
				        MaskFormerSwinBackbone,
				    )
				    if is_torch_available()
				    else ()
				)
				SCREAMING_SNAKE_CASE_:							Tuple							=					{"feature-extraction": MaskFormerSwinModel} if is_torch_available() else {}
				SCREAMING_SNAKE_CASE_:							str							=					False
				SCREAMING_SNAKE_CASE_:							Tuple							=					False
				SCREAMING_SNAKE_CASE_:							List[Any]							=					False
				SCREAMING_SNAKE_CASE_:							int							=					False
				SCREAMING_SNAKE_CASE_:							Union[str, Any]							=					False


				def 				__lowerCamelCase	(					self	:			Any  )		->  str:







											"""simple docstring"""




											_lowerCAmelCase  	=			MaskFormerSwinModelTester(self  )
											_lowerCAmelCase  	=			ConfigTester(self				,     config_class=UpperCAmelCase_				,     embed_dim=37  )


				@require_torch_multi_gpu
				@unittest.skip(
				    reason=(
				        '`MaskFormerSwinModel` outputs `hidden_states_spatial_dimensions` which doesn\'t work well with'
				        ' `nn.DataParallel`'
				    )  )
				def 				__lowerCamelCase	(					self	:			Any  )		->  str:







											"""simple docstring"""




											pass


				def 				__lowerCamelCase	(					self	:			str  )		->  Optional[int]:







											"""simple docstring"""




											self.create_and_test_config_common_properties()
											self.config_tester.create_and_test_config_to_json_string()
											self.config_tester.create_and_test_config_to_json_file()
											self.config_tester.create_and_test_config_from_and_save_pretrained()
											self.config_tester.create_and_test_config_with_num_labels()
											self.config_tester.check_config_can_be_init_without_params()
											self.config_tester.check_config_arguments_init()


				def 				__lowerCamelCase	(					self	:			List[Any]  )		->  Optional[Any]:







											"""simple docstring"""




											return


				def 				__lowerCamelCase	(					self	:			Optional[int]  )		->  Tuple:







											"""simple docstring"""




											_lowerCAmelCase  	=			self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_model(*UpperCAmelCase_  )


				def 				__lowerCamelCase	(					self	:			Optional[int]  )		->  Dict:







											"""simple docstring"""




											_lowerCAmelCase  	=			self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_backbone(*UpperCAmelCase_  )


				@unittest.skip('Swin does not use inputs_embeds'  )
				def 				__lowerCamelCase	(					self	:			Optional[int]  )		->  Dict:







											"""simple docstring"""




											pass


				@unittest.skip('Swin does not support feedforward chunking'  )
				def 				__lowerCamelCase	(					self	:			Tuple  )		->  Dict:







											"""simple docstring"""




											pass


				def 				__lowerCamelCase	(					self	:			str  )		->  str:







											"""simple docstring"""




											_lowerCAmelCase  	=			self.model_tester.prepare_config_and_inputs_for_common()

											for model_class in self.all_model_classes:
																		_lowerCAmelCase  	=			model_class(UpperCAmelCase_  )
																		self.assertIsInstance(model.get_input_embeddings()				,     (nn.Module)  )
																		_lowerCAmelCase  	=			model.get_output_embeddings()
																		self.assertTrue(x is None or isinstance(UpperCAmelCase_				,     nn.Linear  )  )


				def 				__lowerCamelCase	(					self	:			Any  )		->  str:







											"""simple docstring"""




											_lowerCAmelCase  	=			self.model_tester.prepare_config_and_inputs_for_common()

											for model_class in self.all_model_classes:
																		_lowerCAmelCase  	=			model_class(UpperCAmelCase_  )
																		_lowerCAmelCase  	=			inspect.signature(model.forward  )
																		# signature.parameters is an OrderedDict => so arg_names order is deterministic
																		_lowerCAmelCase  	=			[*signature.parameters.keys()]

																		_lowerCAmelCase  	=			['''pixel_values''']
																		self.assertListEqual(arg_names[:1]				,     UpperCAmelCase_  )


				@unittest.skip(reason='MaskFormerSwin is only used as backbone and doesn\'t support output_attentions'  )
				def 				__lowerCamelCase	(					self	:			str  )		->  Any:







											"""simple docstring"""




											pass


				@unittest.skip(reason='MaskFormerSwin is only used as an internal backbone'  )
				def 				__lowerCamelCase	(					self	:			List[str]  )		->  Optional[Any]:







											"""simple docstring"""




											pass


				def 				__lowerCamelCase	(					self	:			Optional[Any]				,     UpperCAmelCase_	:			str				,     UpperCAmelCase_	:			Tuple				,     UpperCAmelCase_	:			List[str]				,     UpperCAmelCase_	:			Dict  )		->  Any:







											"""simple docstring"""




											_lowerCAmelCase  	=			model_class(UpperCAmelCase_  )
											model.to(UpperCAmelCase_  )
											model.eval()

											with torch.no_grad():
																		_lowerCAmelCase  	=			model(**self._prepare_for_class(UpperCAmelCase_				,     UpperCAmelCase_  )  )

											_lowerCAmelCase  	=			outputs.hidden_states

											_lowerCAmelCase  	=			getattr(
											    self.model_tester				,     'expected_num_hidden_layers'				,     len(self.model_tester.depths  ) + 1  )
											self.assertEqual(len(UpperCAmelCase_  )				,     UpperCAmelCase_  )

											# Swin has a different seq_length
											_lowerCAmelCase  	=			(
											    config.patch_size
											    if isinstance(config.patch_size				,     collections.abc.Iterable  )
											    else (config.patch_size, config.patch_size)
											)

											_lowerCAmelCase  	=			(image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])

											self.assertListEqual(
											    list(hidden_states[0].shape[-2:]  )				,     [num_patches, self.model_tester.embed_dim]				,     )


				def 				__lowerCamelCase	(					self	:			List[Any]  )		->  Optional[int]:







											"""simple docstring"""




											_lowerCAmelCase  	=			self.model_tester.prepare_config_and_inputs_for_common()

											_lowerCAmelCase  	=			(
											    self.model_tester.image_size
											    if isinstance(self.model_tester.image_size				,     collections.abc.Iterable  )
											    else (self.model_tester.image_size, self.model_tester.image_size)
											)

											for model_class in self.all_model_classes:
																		_lowerCAmelCase  	=			True
																		self.check_hidden_states_output(UpperCAmelCase_				,     UpperCAmelCase_				,     UpperCAmelCase_				,     UpperCAmelCase_  )

																		# check that output_hidden_states also work using config
																		del inputs_dict["output_hidden_states"]
																		_lowerCAmelCase  	=			True

																		self.check_hidden_states_output(UpperCAmelCase_				,     UpperCAmelCase_				,     UpperCAmelCase_				,     UpperCAmelCase_  )


				def 				__lowerCamelCase	(					self	:			Union[str, Any]  )		->  Optional[int]:







											"""simple docstring"""




											_lowerCAmelCase  	=			self.model_tester.prepare_config_and_inputs_for_common()
											_lowerCAmelCase  	=			3

											_lowerCAmelCase  	=			(
											    self.model_tester.image_size
											    if isinstance(self.model_tester.image_size				,     collections.abc.Iterable  )
											    else (self.model_tester.image_size, self.model_tester.image_size)
											)
											_lowerCAmelCase  	=			(
											    config.patch_size
											    if isinstance(config.patch_size				,     collections.abc.Iterable  )
											    else (config.patch_size, config.patch_size)
											)

											_lowerCAmelCase  	=			image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
											_lowerCAmelCase  	=			image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

											for model_class in self.all_model_classes:
																		_lowerCAmelCase  	=			True
																		self.check_hidden_states_output(UpperCAmelCase_				,     UpperCAmelCase_				,     UpperCAmelCase_				,     (padded_height, padded_width)  )

																		# check that output_hidden_states also work using config
																		del inputs_dict["output_hidden_states"]
																		_lowerCAmelCase  	=			True
																		self.check_hidden_states_output(UpperCAmelCase_				,     UpperCAmelCase_				,     UpperCAmelCase_				,     (padded_height, padded_width)  )


				@unittest.skip(reason='MaskFormerSwin doesn\'t have pretrained checkpoints'  )
				def 				__lowerCamelCase	(					self	:			str  )		->  List[str]:







											"""simple docstring"""




											pass


				@unittest.skip(reason='This will be fixed once MaskFormerSwin is replaced by native Swin'  )
				def 				__lowerCamelCase	(					self	:			int  )		->  List[Any]:







											"""simple docstring"""




											pass


				@unittest.skip(reason='This will be fixed once MaskFormerSwin is replaced by native Swin'  )
				def 				__lowerCamelCase	(					self	:			Union[str, Any]  )		->  str:







											"""simple docstring"""




											pass







				def 				__lowerCamelCase	(					self	:			Optional[Any]  )		->  Any:







											"""simple docstring"""




											_lowerCAmelCase  	=			self.model_tester.prepare_config_and_inputs_for_common()

											def set_nan_tensor_to_zero(UpperCAmelCase_	:			List[str]  ):
																		_lowerCAmelCase  	=			0
																		return t

											def check_equivalence(UpperCAmelCase_	:			Optional[int]				,     UpperCAmelCase_	:			str				,     UpperCAmelCase_	:			Dict				,     UpperCAmelCase_	:			Optional[int]={}  ):
																		with torch.no_grad():
																									_lowerCAmelCase  	=			model(**UpperCAmelCase_				,     return_dict=UpperCAmelCase_				,     **UpperCAmelCase_  )
																									_lowerCAmelCase  	=			model(**UpperCAmelCase_				,     return_dict=UpperCAmelCase_				,     **UpperCAmelCase_  ).to_tuple()

																									def recursive_check(UpperCAmelCase_	:			int				,     UpperCAmelCase_	:			Tuple  ):
																																if isinstance(UpperCAmelCase_				,     (List, Tuple)  ):
																																							for tuple_iterable_value, dict_iterable_value in zip(UpperCAmelCase_				,     UpperCAmelCase_  ):
																																														recursive_check(UpperCAmelCase_				,     UpperCAmelCase_  )
																																elif isinstance(UpperCAmelCase_				,     UpperCAmelCase_  ):
																																							for tuple_iterable_value, dict_iterable_value in zip(
																																							    tuple_object.values()				,     dict_object.values()  ):
																																														recursive_check(UpperCAmelCase_				,     UpperCAmelCase_  )
																																elif tuple_object is None:
																																							return
																																else:
																																							self.assertTrue(
																																							    torch.allclose(
																																							        set_nan_tensor_to_zero(UpperCAmelCase_  )				,     set_nan_tensor_to_zero(UpperCAmelCase_  )				,     atol=1E-5  )				,     msg=(
																																							        'Tuple and dict output are not equal. Difference:'
																																							        F""" {torch.max(torch.abs(tuple_object - dict_object  )  )}. Tuple has `nan`:"""
																																							        F""" {torch.isnan(UpperCAmelCase_  ).any()} and `inf`: {torch.isinf(UpperCAmelCase_  )}. Dict has"""
																																							        F""" `nan`: {torch.isnan(UpperCAmelCase_  ).any()} and `inf`: {torch.isinf(UpperCAmelCase_  )}."""
																																							    )				,     )

																									recursive_check(UpperCAmelCase_				,     UpperCAmelCase_  )

											for model_class in self.all_model_classes:
																		_lowerCAmelCase  	=			model_class(UpperCAmelCase_  )
																		model.to(UpperCAmelCase_  )
																		model.eval()

																		_lowerCAmelCase  	=			self._prepare_for_class(UpperCAmelCase_				,     UpperCAmelCase_  )
																		_lowerCAmelCase  	=			self._prepare_for_class(UpperCAmelCase_				,     UpperCAmelCase_  )
																		check_equivalence(UpperCAmelCase_				,     UpperCAmelCase_				,     UpperCAmelCase_  )

																		_lowerCAmelCase  	=			self._prepare_for_class(UpperCAmelCase_				,     UpperCAmelCase_				,     return_labels=UpperCAmelCase_  )
																		_lowerCAmelCase  	=			self._prepare_for_class(UpperCAmelCase_				,     UpperCAmelCase_				,     return_labels=UpperCAmelCase_  )
																		check_equivalence(UpperCAmelCase_				,     UpperCAmelCase_				,     UpperCAmelCase_  )

																		_lowerCAmelCase  	=			self._prepare_for_class(UpperCAmelCase_				,     UpperCAmelCase_  )
																		_lowerCAmelCase  	=			self._prepare_for_class(UpperCAmelCase_				,     UpperCAmelCase_  )
																		check_equivalence(UpperCAmelCase_				,     UpperCAmelCase_				,     UpperCAmelCase_				,     {'output_hidden_states': True}  )

																		_lowerCAmelCase  	=			self._prepare_for_class(UpperCAmelCase_				,     UpperCAmelCase_				,     return_labels=UpperCAmelCase_  )
																		_lowerCAmelCase  	=			self._prepare_for_class(UpperCAmelCase_				,     UpperCAmelCase_				,     return_labels=UpperCAmelCase_  )
																		check_equivalence(UpperCAmelCase_				,     UpperCAmelCase_				,     UpperCAmelCase_				,     {'output_hidden_states': True}  )






@require_torch
class        _SCREAMING_SNAKE_CASE  (  unittest.TestCase      ,				__A							):






				'''simple docstring'''



				SCREAMING_SNAKE_CASE_:							Optional[int]							=					(MaskFormerSwinBackbone,) if is_torch_available() else ()
				SCREAMING_SNAKE_CASE_:							str							=					MaskFormerSwinConfig


				def 				__lowerCamelCase	(					self	:			Optional[int]  )		->  Dict:







											"""simple docstring"""




											_lowerCAmelCase  	=			MaskFormerSwinModelTester(self  )







				def 				__lowerCamelCase	(					self	:			List[str]  )		->  Tuple:







											"""simple docstring"""




											_lowerCAmelCase  	=			self.model_tester.prepare_config_and_inputs_for_common()
											_lowerCAmelCase  	=			inputs_dict['''pixel_values'''].shape[0]

											for backbone_class in self.all_model_classes:
																		_lowerCAmelCase  	=			backbone_class(UpperCAmelCase_  )
																		backbone.to(UpperCAmelCase_  )
																		backbone.eval()

																		_lowerCAmelCase  	=			backbone(**UpperCAmelCase_  )

																		# Test default outputs and verify feature maps
																		self.assertIsInstance(outputs.feature_maps				,     UpperCAmelCase_  )
																		self.assertTrue(len(outputs.feature_maps  ) == len(backbone.channels  )  )
																		for feature_map, n_channels in zip(outputs.feature_maps				,     backbone.channels  ):
																									self.assertTrue(feature_map.shape[:2]				,     (batch_size, n_channels)  )
																		self.assertIsNone(outputs.hidden_states  )
																		self.assertIsNone(outputs.attentions  )

																		# Test output_hidden_states=True
																		_lowerCAmelCase  	=			backbone(**UpperCAmelCase_				,     output_hidden_states=UpperCAmelCase_  )
																		self.assertIsNotNone(outputs.hidden_states  )
																		self.assertTrue(len(outputs.hidden_states  )				,     len(backbone.stage_names  )  )
																		# We skip the stem layer
																		for hidden_states, n_channels in zip(outputs.hidden_states[1:]				,     backbone.channels  ):
																									for hidden_state in hidden_states:
																																# Hidden states are in the format (batch_size, (height * width), n_channels)
																																_lowerCAmelCase  	=			hidden_state.shape
																																self.assertTrue((h_batch_size, h_n_channels)				,     (batch_size, n_channels)  )

																																  # Test output_attentions=True
																		if self.has_attentions:
																									_lowerCAmelCase  	=			backbone(**UpperCAmelCase_				,     output_attentions=UpperCAmelCase_  )
																									self.assertIsNotNone(outputs.attentions  )








"""simple docstring"""



import argparse

import intel_extension_for_pytorch as ipex
import torch

from diffusers import DPMSolverMultistepScheduler, StableDiffusionPipeline


_snake_case          =						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''')
_snake_case          =						parser.parse_args()


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

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

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

# optimize with ipex
_snake_case          =						torch.randn(2, 4, 6_4, 6_4)
_snake_case          =						torch.rand(1) * 9_9_9
_snake_case          =						torch.randn(2, 7_7, 7_6_8)
_snake_case          =						(sample, timestep, encoder_hidden_status)
try:
	_snake_case          =						ipex.optimize(pipe.unet.eval(), dtype=torch.bfloataa, inplace=True, sample_input=input_example)
except Exception:
	_snake_case          =						ipex.optimize(pipe.unet.eval(), dtype=torch.bfloataa, inplace=True)
_snake_case          =						ipex.optimize(pipe.vae.eval(), dtype=torch.bfloataa, inplace=True)
_snake_case          =						ipex.optimize(pipe.text_encoder.eval(), dtype=torch.bfloataa, inplace=True)
if pipe.requires_safety_checker:
	_snake_case          =						ipex.optimize(pipe.safety_checker.eval(), dtype=torch.bfloataa, inplace=True)

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

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

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






