"""simple docstring"""






import collections
import inspect
import unittest

from transformers import SwinConfig
from transformers.testing_utils import require_torch, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

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


if is_torch_available():
				import torch
				from torch import nn

				from transformers import SwinBackbone, SwinForImageClassification, SwinForMaskedImageModeling, SwinModel
				from transformers.models.swin.modeling_swin import SWIN_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
				from PIL import Image

				from transformers import AutoImageProcessor
class   UpperCAmelCase__				:


	"""simple docstring"""







	def __init__(			self       ,     _SCREAMING_SNAKE_CASE       ,     _SCREAMING_SNAKE_CASE=1_3       ,     _SCREAMING_SNAKE_CASE=3_2       ,     _SCREAMING_SNAKE_CASE=2       ,     _SCREAMING_SNAKE_CASE=3       ,     _SCREAMING_SNAKE_CASE=1_6       ,     _SCREAMING_SNAKE_CASE=[1, 2, 1]       ,     _SCREAMING_SNAKE_CASE=[2, 2, 4]       ,     _SCREAMING_SNAKE_CASE=2       ,     _SCREAMING_SNAKE_CASE=2.0       ,     _SCREAMING_SNAKE_CASE=True       ,     _SCREAMING_SNAKE_CASE=0.0       ,     _SCREAMING_SNAKE_CASE=0.0       ,     _SCREAMING_SNAKE_CASE=0.1       ,     _SCREAMING_SNAKE_CASE="gelu"       ,     _SCREAMING_SNAKE_CASE=False       ,     _SCREAMING_SNAKE_CASE=True       ,     _SCREAMING_SNAKE_CASE=0.0_2       ,     _SCREAMING_SNAKE_CASE=1E-5       ,     _SCREAMING_SNAKE_CASE=True       ,     _SCREAMING_SNAKE_CASE=None       ,     _SCREAMING_SNAKE_CASE=True       ,     _SCREAMING_SNAKE_CASE=1_0       ,     _SCREAMING_SNAKE_CASE=8       ,     _SCREAMING_SNAKE_CASE=["stage1", "stage2"]       ,     _SCREAMING_SNAKE_CASE=[1, 2]       ,     )    ->	List[Any]:
							a_							:			int     		=					parent
							a_							:			Dict     		=					batch_size
							a_							:			Union[str, Any]     		=					image_size
							a_							:			Any     		=					patch_size
							a_							:			str     		=					num_channels
							a_							:			Optional[Any]     		=					embed_dim
							a_							:			List[Any]     		=					depths
							a_							:			Tuple     		=					num_heads
							a_							:			Any     		=					window_size
							a_							:			Any     		=					mlp_ratio
							a_							:			Optional[int]     		=					qkv_bias
							a_							:			Union[str, Any]     		=					hidden_dropout_prob
							a_							:			Optional[int]     		=					attention_probs_dropout_prob
							a_							:			Optional[Any]     		=					drop_path_rate
							a_							:			Union[str, Any]     		=					hidden_act
							a_							:			List[Any]     		=					use_absolute_embeddings
							a_							:			List[Any]     		=					patch_norm
							a_							:			List[str]     		=					layer_norm_eps
							a_							:			Union[str, Any]     		=					initializer_range
							a_							:			str     		=					is_training
							a_							:			Tuple     		=					scope
							a_							:			Tuple     		=					use_labels
							a_							:			Any     		=					type_sequence_label_size
							a_							:			Dict     		=					encoder_stride
							a_							:			Any     		=					out_features
							a_							:			Tuple     		=					out_indices







	def       A    (			self )    ->	List[str]:
							a_							:			Union[str, Any]     		=					floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size] )

							a_							:			str     		=					None
							if self.use_labels:
													a_							:			Tuple     		=					ids_tensor([self.batch_size]       ,     self.type_sequence_label_size )

							a_							:			List[str]     		=					self.get_config()

							return config, pixel_values, labels







	def       A    (			self )    ->	Optional[int]:
							return SwinConfig(
							    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       A    (			self       ,     _SCREAMING_SNAKE_CASE       ,     _SCREAMING_SNAKE_CASE       ,     _SCREAMING_SNAKE_CASE )    ->	List[str]:
							a_							:			Optional[int]     		=					SwinModel(config=_SCREAMING_SNAKE_CASE )
							model.to(_SCREAMING_SNAKE_CASE )
							model.eval()
							a_							:			str     		=					model(_SCREAMING_SNAKE_CASE )

							a_							:			Optional[int]     		=					((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths ) - 1))
							a_							:			Union[str, Any]     		=					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       A    (			self       ,     _SCREAMING_SNAKE_CASE       ,     _SCREAMING_SNAKE_CASE       ,     _SCREAMING_SNAKE_CASE )    ->	Optional[int]:
							a_							:			Optional[int]     		=					SwinBackbone(config=_SCREAMING_SNAKE_CASE )
							model.to(_SCREAMING_SNAKE_CASE )
							model.eval()
							a_							:			List[str]     		=					model(_SCREAMING_SNAKE_CASE )

							# verify hidden states
							self.parent.assertEqual(len(result.feature_maps )       ,     len(config.out_features ) )
							self.parent.assertListEqual(list(result.feature_maps[0].shape )       ,     [self.batch_size, model.channels[0], 1_6, 1_6] )

							# verify channels
							self.parent.assertEqual(len(model.channels )       ,     len(config.out_features ) )

							# verify backbone works with out_features=None
							a_							:			int     		=					None
							a_							:			Optional[int]     		=					SwinBackbone(config=_SCREAMING_SNAKE_CASE )
							model.to(_SCREAMING_SNAKE_CASE )
							model.eval()
							a_							:			str     		=					model(_SCREAMING_SNAKE_CASE )

							# verify feature maps
							self.parent.assertEqual(len(result.feature_maps )       ,     1 )
							self.parent.assertListEqual(list(result.feature_maps[0].shape )       ,     [self.batch_size, model.channels[-1], 4, 4] )

							# verify channels
							self.parent.assertEqual(len(model.channels )       ,     1 )







	def       A    (			self       ,     _SCREAMING_SNAKE_CASE       ,     _SCREAMING_SNAKE_CASE       ,     _SCREAMING_SNAKE_CASE )    ->	str:
							a_							:			Dict     		=					SwinForMaskedImageModeling(config=_SCREAMING_SNAKE_CASE )
							model.to(_SCREAMING_SNAKE_CASE )
							model.eval()
							a_							:			str     		=					model(_SCREAMING_SNAKE_CASE )
							self.parent.assertEqual(
							    result.logits.shape       ,     (self.batch_size, self.num_channels, self.image_size, self.image_size) )

							# test greyscale images
							a_							:			List[str]     		=					1
							a_							:			Union[str, Any]     		=					SwinForMaskedImageModeling(_SCREAMING_SNAKE_CASE )
							model.to(_SCREAMING_SNAKE_CASE )
							model.eval()

							a_							:			List[Any]     		=					floats_tensor([self.batch_size, 1, self.image_size, self.image_size] )
							a_							:			Union[str, Any]     		=					model(_SCREAMING_SNAKE_CASE )
							self.parent.assertEqual(result.logits.shape       ,     (self.batch_size, 1, self.image_size, self.image_size) )







	def       A    (			self       ,     _SCREAMING_SNAKE_CASE       ,     _SCREAMING_SNAKE_CASE       ,     _SCREAMING_SNAKE_CASE )    ->	Union[str, Any]:
							a_							:			List[Any]     		=					self.type_sequence_label_size
							a_							:			List[str]     		=					SwinForImageClassification(_SCREAMING_SNAKE_CASE )
							model.to(_SCREAMING_SNAKE_CASE )
							model.eval()
							a_							:			Tuple     		=					model(_SCREAMING_SNAKE_CASE       ,     labels=_SCREAMING_SNAKE_CASE )
							self.parent.assertEqual(result.logits.shape       ,     (self.batch_size, self.type_sequence_label_size) )

							# test greyscale images
							a_							:			Optional[Any]     		=					1
							a_							:			List[str]     		=					SwinForImageClassification(_SCREAMING_SNAKE_CASE )
							model.to(_SCREAMING_SNAKE_CASE )
							model.eval()

							a_							:			Union[str, Any]     		=					floats_tensor([self.batch_size, 1, self.image_size, self.image_size] )
							a_							:			Union[str, Any]     		=					model(_SCREAMING_SNAKE_CASE )
							self.parent.assertEqual(result.logits.shape       ,     (self.batch_size, self.type_sequence_label_size) )







	def       A    (			self )    ->	str:
							a_							:			str     		=					self.prepare_config_and_inputs()
							(
							    (
							    a_
							)		,					(
							    a_
							)		,					(
							    a_
							)		,					
							)							:			Tuple     		=					config_and_inputs
							a_							:			Optional[int]     		=					{"pixel_values": pixel_values}
							return config, inputs_dict




@require_torch
class   UpperCAmelCase__				(    __lowerCamelCase,      __lowerCamelCase,      unittest.TestCase			):


	"""simple docstring"""
	lowerCAmelCase__    :					str						      =							(
	    (
	        SwinModel,
	        SwinBackbone,
	        SwinForImageClassification,
	        SwinForMaskedImageModeling,
	    )
	    if is_torch_available()
	    else ()
	)
	lowerCAmelCase__    :					List[Any]						      =							(
	    {"""feature-extraction""": SwinModel, """image-classification""": SwinForImageClassification}
	    if is_torch_available()
	    else {}
	)
	lowerCAmelCase__    :					Union[str, Any]						      =							True

	lowerCAmelCase__    :					int						      =							False
	lowerCAmelCase__    :					Dict						      =							False
	lowerCAmelCase__    :					Optional[int]						      =							False







	def       A    (			self )    ->	str:
							a_							:			Any     		=					SwinModelTester(self )
							a_							:			Dict     		=					ConfigTester(self       ,     config_class=_SCREAMING_SNAKE_CASE       ,     embed_dim=3_7 )







	def       A    (			self )    ->	Optional[Any]:
							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       A    (			self )    ->	str:
							return







	def       A    (			self )    ->	List[Any]:
							a_							:			Tuple     		=					self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_model(*_SCREAMING_SNAKE_CASE )







	@unittest.skip(reason="Got `CUDA error: misaligned address` with PyTorch 2.0.0." )
	def       A    (			self )    ->	int:
							pass







	def       A    (			self )    ->	List[str]:
							super().test_training_gradient_checkpointing()







	def       A    (			self )    ->	Any:
							a_							:			Tuple     		=					self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_backbone(*_SCREAMING_SNAKE_CASE )







	def       A    (			self )    ->	Optional[Any]:
							a_							:			List[str]     		=					self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_masked_image_modeling(*_SCREAMING_SNAKE_CASE )







	def       A    (			self )    ->	str:
							a_							:			Any     		=					self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_image_classification(*_SCREAMING_SNAKE_CASE )







	@unittest.skip(reason="Swin does not use inputs_embeds" )
	def       A    (			self )    ->	List[str]:
							pass







	@unittest.skip(reason="Swin Transformer does not use feedforward chunking" )
	def       A    (			self )    ->	Union[str, Any]:
							pass







	def       A    (			self )    ->	int:
							a_		,					a_							:			Optional[int]     		=					self.model_tester.prepare_config_and_inputs_for_common()

							for model_class in self.all_model_classes:
													a_							:			Optional[int]     		=					model_class(_SCREAMING_SNAKE_CASE )
													self.assertIsInstance(model.get_input_embeddings()       ,     (nn.Module) )
													a_							:			Dict     		=					model.get_output_embeddings()
													self.assertTrue(x is None or isinstance(_SCREAMING_SNAKE_CASE       ,     nn.Linear ) )







	def       A    (			self )    ->	Tuple:
							a_		,					a_							:			Optional[int]     		=					self.model_tester.prepare_config_and_inputs_for_common()

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

													a_							:			Optional[Any]     		=					["pixel_values"]
													self.assertListEqual(arg_names[:1]       ,     _SCREAMING_SNAKE_CASE )







	def       A    (			self )    ->	int:
							a_		,					a_							:			int     		=					self.model_tester.prepare_config_and_inputs_for_common()
							a_							:			Dict     		=					True

							for model_class in self.all_model_classes:
													a_							:			List[Any]     		=					True
													a_							:			int     		=					False
													a_							:			Optional[int]     		=					True
													a_							:			Any     		=					model_class(_SCREAMING_SNAKE_CASE )
													model.to(_SCREAMING_SNAKE_CASE )
													model.eval()
													with torch.no_grad():
																			a_							:			Any     		=					model(**self._prepare_for_class(_SCREAMING_SNAKE_CASE       ,     _SCREAMING_SNAKE_CASE ) )
													a_							:			Any     		=					outputs.attentions
													a_							:			Optional[Any]     		=					len(self.model_tester.depths )
													self.assertEqual(len(_SCREAMING_SNAKE_CASE )       ,     _SCREAMING_SNAKE_CASE )

													# check that output_attentions also work using config
													del inputs_dict["output_attentions"]
													a_							:			Dict     		=					True
													a_							:			int     		=					config.window_size**2
													a_							:			Optional[int]     		=					model_class(_SCREAMING_SNAKE_CASE )
													model.to(_SCREAMING_SNAKE_CASE )
													model.eval()
													with torch.no_grad():
																			a_							:			List[str]     		=					model(**self._prepare_for_class(_SCREAMING_SNAKE_CASE       ,     _SCREAMING_SNAKE_CASE ) )
													a_							:			List[str]     		=					outputs.attentions
													self.assertEqual(len(_SCREAMING_SNAKE_CASE )       ,     _SCREAMING_SNAKE_CASE )

													self.assertListEqual(
													    list(attentions[0].shape[-3:] )       ,     [self.model_tester.num_heads[0], window_size_squared, window_size_squared]       ,     )
													a_							:			str     		=					len(_SCREAMING_SNAKE_CASE )

													# Check attention is always last and order is fine
													a_							:			Optional[int]     		=					True
													a_							:			int     		=					True
													a_							:			Any     		=					model_class(_SCREAMING_SNAKE_CASE )
													model.to(_SCREAMING_SNAKE_CASE )
													model.eval()
													with torch.no_grad():
																			a_							:			int     		=					model(**self._prepare_for_class(_SCREAMING_SNAKE_CASE       ,     _SCREAMING_SNAKE_CASE ) )

													# also another +1 for reshaped_hidden_states
													a_							:			Any     		=					1 if model_class.__name__ == "SwinBackbone" else 2
													self.assertEqual(out_len + added_hidden_states       ,     len(_SCREAMING_SNAKE_CASE ) )

													a_							:			str     		=					outputs.attentions

													self.assertEqual(len(_SCREAMING_SNAKE_CASE )       ,     _SCREAMING_SNAKE_CASE )

													self.assertListEqual(
													    list(self_attentions[0].shape[-3:] )       ,     [self.model_tester.num_heads[0], window_size_squared, window_size_squared]       ,     )







	def       A    (			self       ,     _SCREAMING_SNAKE_CASE       ,     _SCREAMING_SNAKE_CASE       ,     _SCREAMING_SNAKE_CASE       ,     _SCREAMING_SNAKE_CASE )    ->	Tuple:
							a_							:			Union[str, Any]     		=					model_class(_SCREAMING_SNAKE_CASE )
							model.to(_SCREAMING_SNAKE_CASE )
							model.eval()

							with torch.no_grad():
													a_							:			Optional[Any]     		=					model(**self._prepare_for_class(_SCREAMING_SNAKE_CASE       ,     _SCREAMING_SNAKE_CASE ) )

							a_							:			Any     		=					outputs.hidden_states

							a_							:			Union[str, Any]     		=					getattr(
							    self.model_tester       ,     "expected_num_hidden_layers"       ,     len(self.model_tester.depths ) + 1 )
							self.assertEqual(len(_SCREAMING_SNAKE_CASE )       ,     _SCREAMING_SNAKE_CASE )

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

							a_							:			Tuple     		=					(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]       ,     )

							if not model_class.__name__ == "SwinBackbone":
													a_							:			Dict     		=					outputs.reshaped_hidden_states
													self.assertEqual(len(_SCREAMING_SNAKE_CASE )       ,     _SCREAMING_SNAKE_CASE )

													a_		,					a_		,					a_		,					a_							:			Dict     		=					reshaped_hidden_states[0].shape
													a_							:			Any     		=					(
													    reshaped_hidden_states[0].view(_SCREAMING_SNAKE_CASE       ,     _SCREAMING_SNAKE_CASE       ,     height * width ).permute(0       ,     2       ,     1 )
													)
													self.assertListEqual(
													    list(reshaped_hidden_states.shape[-2:] )       ,     [num_patches, self.model_tester.embed_dim]       ,     )







	def       A    (			self )    ->	int:
							a_		,					a_							:			Union[str, Any]     		=					self.model_tester.prepare_config_and_inputs_for_common()

							a_							:			int     		=					(
							    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:
													a_							:			int     		=					True
													self.check_hidden_states_output(_SCREAMING_SNAKE_CASE       ,     _SCREAMING_SNAKE_CASE       ,     _SCREAMING_SNAKE_CASE       ,     _SCREAMING_SNAKE_CASE )

													# check that output_hidden_states also work using config
													del inputs_dict["output_hidden_states"]
													a_							:			Dict     		=					True

													self.check_hidden_states_output(_SCREAMING_SNAKE_CASE       ,     _SCREAMING_SNAKE_CASE       ,     _SCREAMING_SNAKE_CASE       ,     _SCREAMING_SNAKE_CASE )







	def       A    (			self )    ->	List[Any]:
							a_		,					a_							:			List[str]     		=					self.model_tester.prepare_config_and_inputs_for_common()
							a_							:			Dict     		=					3

							a_							:			Any     		=					(
							    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)
							)
							a_							:			Dict     		=					(
							    config.patch_size
							    if isinstance(config.patch_size       ,     collections.abc.Iterable )
							    else (config.patch_size, config.patch_size)
							)

							a_							:			str     		=					image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
							a_							:			Any     		=					image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

							for model_class in self.all_model_classes:
													a_							:			List[str]     		=					True
													self.check_hidden_states_output(_SCREAMING_SNAKE_CASE       ,     _SCREAMING_SNAKE_CASE       ,     _SCREAMING_SNAKE_CASE       ,     (padded_height, padded_width) )

													# check that output_hidden_states also work using config
													del inputs_dict["output_hidden_states"]
													a_							:			Union[str, Any]     		=					True
													self.check_hidden_states_output(_SCREAMING_SNAKE_CASE       ,     _SCREAMING_SNAKE_CASE       ,     _SCREAMING_SNAKE_CASE       ,     (padded_height, padded_width) )







	@slow
	def       A    (			self )    ->	List[Any]:
							for model_name in SWIN_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
													a_							:			List[str]     		=					SwinModel.from_pretrained(_SCREAMING_SNAKE_CASE )
													self.assertIsNotNone(_SCREAMING_SNAKE_CASE )







	def       A    (			self )    ->	str:
							a_		,					a_							:			Union[str, Any]     		=					self.model_tester.prepare_config_and_inputs_for_common()

							a_							:			Tuple     		=					_config_zero_init(_SCREAMING_SNAKE_CASE )
							for model_class in self.all_model_classes:
													a_							:			List[str]     		=					model_class(config=_SCREAMING_SNAKE_CASE )
													for name, param in model.named_parameters():
																			if "embeddings" not in name and param.requires_grad:
																									self.assertIn(
																									    ((param.data.mean() * 1E9).round() / 1E9).item()       ,     [0.0, 1.0]       ,     msg=f'''Parameter {name} of model {model_class} seems not properly initialized'''       ,     )




@require_vision
@require_torch
class   UpperCAmelCase__				(    unittest.TestCase			):


	"""simple docstring"""







	@cached_property
	def       A    (			self )    ->	Optional[Any]:
							return (
							    AutoImageProcessor.from_pretrained("microsoft/swin-tiny-patch4-window7-224" )
							    if is_vision_available()
							    else None
							)







	@slow
	def       A    (			self )    ->	int:
							a_							:			List[str]     		=					SwinForImageClassification.from_pretrained("microsoft/swin-tiny-patch4-window7-224" ).to(_SCREAMING_SNAKE_CASE )
							a_							:			List[str]     		=					self.default_image_processor

							a_							:			Optional[int]     		=					Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png" )
							a_							:			Optional[int]     		=					image_processor(images=_SCREAMING_SNAKE_CASE       ,     return_tensors="pt" ).to(_SCREAMING_SNAKE_CASE )

							# forward pass
							with torch.no_grad():
													a_							:			int     		=					model(**_SCREAMING_SNAKE_CASE )

							# verify the logits
							a_							:			Tuple     		=					torch.Size((1, 1_0_0_0) )
							self.assertEqual(outputs.logits.shape       ,     _SCREAMING_SNAKE_CASE )
							a_							:			Dict     		=					torch.tensor([-0.0_9_4_8, -0.6_4_5_4, -0.0_9_2_1] ).to(_SCREAMING_SNAKE_CASE )
							self.assertTrue(torch.allclose(outputs.logits[0, :3]       ,     _SCREAMING_SNAKE_CASE       ,     atol=1E-4 ) )




@require_torch
class   UpperCAmelCase__				(    unittest.TestCase,      __lowerCamelCase			):


	"""simple docstring"""
	lowerCAmelCase__    :					List[str]						      =							(SwinBackbone,) if is_torch_available() else ()
	lowerCAmelCase__    :					Any						      =							SwinConfig







	def       A    (			self )    ->	Union[str, Any]:
							a_							:			str     		=					SwinModelTester(self )





"""simple docstring"""






import unittest

import torch

from diffusers import DDIMScheduler, TextToVideoZeroPipeline
from diffusers.utils import load_pt, require_torch_gpu, slow

from ..test_pipelines_common import assert_mean_pixel_difference
@slow
@require_torch_gpu
class   UpperCAmelCase__				(    unittest.TestCase			):


	"""simple docstring"""







	def       A    (			self )    ->	List[str]:
							a_							:			List[str]     		=					"runwayml/stable-diffusion-v1-5"
							a_							:			Optional[int]     		=					TextToVideoZeroPipeline.from_pretrained(_SCREAMING_SNAKE_CASE       ,     torch_dtype=torch.floataa ).to("cuda" )
							a_							:			Dict     		=					DDIMScheduler.from_config(pipe.scheduler.config )
							a_							:			Optional[Any]     		=					torch.Generator(device="cuda" ).manual_seed(0 )

							a_							:			List[Any]     		=					"A bear is playing a guitar on Times Square"
							a_							:			List[Any]     		=					pipe(prompt=_SCREAMING_SNAKE_CASE       ,     generator=_SCREAMING_SNAKE_CASE ).images

							a_							:			Optional[int]     		=					load_pt(
							    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/text-to-video/A bear is playing a guitar on Times Square.pt" )

							assert_mean_pixel_difference(_SCREAMING_SNAKE_CASE       ,     _SCREAMING_SNAKE_CASE )




