



import unittest

from transformers import load_tool

from .test_tools_common import ToolTesterMixin


__A				    =						'''
Hugging Face was founded in 2016 by French entrepreneurs Clément Delangue, Julien Chaumond, and Thomas Wolf originally as a company that developed a chatbot app targeted at teenagers.[2] After open-sourcing the model behind the chatbot, the company pivoted to focus on being a platform for machine learning.

In March 2021, Hugging Face raised $40 million in a Series B funding round.[3]

On April 28, 2021, the company launched the BigScience Research Workshop in collaboration with several other research groups to release an open large language model.[4] In 2022, the workshop concluded with the announcement of BLOOM, a multilingual large language model with 176 billion parameters.[5]
'''






class 		lowercase						( unittest.TestCase ,    snake_case__):






	"""simple docstring"""


	def   _SCREAMING_SNAKE_CASE		(	self	:						int     )			-> Optional[Any]:
							UpperCAmelCase_=   load_tool("""summarization"""     )
							self.tool.setup()
							UpperCAmelCase_=   load_tool("""summarization"""						,  remote=__UpperCAmelCase     )




	def   _SCREAMING_SNAKE_CASE		(	self	:						str     )			-> int:
							UpperCAmelCase_=   self.tool(__UpperCAmelCase     )
							self.assertEqual(
							    __UpperCAmelCase						,  """Hugging Face was founded in 2016 by French entrepreneurs Clément Delangue, Julien Chaumond, and Thomas Wolf. In March 2021, Hugging Face raised $40 million in a Series B funding round. On April 28, 2021, the company launched the BigScience Research Workshop in collaboration with several other research groups to release an open large language model. In 2022, the workshop concluded with the announcement of BLOOM."""						,  )




	def   _SCREAMING_SNAKE_CASE		(	self	:						Union[str, Any]     )			-> List[str]:
							UpperCAmelCase_=   self.remote_tool(__UpperCAmelCase     )
							self.assertEqual(
							    __UpperCAmelCase						,  """Hugging Face was founded in 2016 by French entrepreneurs Clément Delangue, Julien Chaumond, and Thomas Wolf. In March 2021, Hugging Face raised $40 million in a Series B funding round. On April 28, 2021, the company launched the BigScience Research Workshop in collaboration with several other research groups to release an open large language model. In 2022, the workshop concluded with the announcement of BLOOM."""						,  )




	def   _SCREAMING_SNAKE_CASE		(	self	:						str     )			-> Optional[int]:
							UpperCAmelCase_=   self.tool(text=__UpperCAmelCase     )
							self.assertEqual(
							    __UpperCAmelCase						,  """Hugging Face was founded in 2016 by French entrepreneurs Clément Delangue, Julien Chaumond, and Thomas Wolf. In March 2021, Hugging Face raised $40 million in a Series B funding round. On April 28, 2021, the company launched the BigScience Research Workshop in collaboration with several other research groups to release an open large language model. In 2022, the workshop concluded with the announcement of BLOOM."""						,  )




	def   _SCREAMING_SNAKE_CASE		(	self	:						Union[str, Any]     )			-> Optional[int]:
							UpperCAmelCase_=   self.remote_tool(text=__UpperCAmelCase     )
							self.assertEqual(
							    __UpperCAmelCase						,  """Hugging Face was founded in 2016 by French entrepreneurs Clément Delangue, Julien Chaumond, and Thomas Wolf. In March 2021, Hugging Face raised $40 million in a Series B funding round. On April 28, 2021, the company launched the BigScience Research Workshop in collaboration with several other research groups to release an open large language model. In 2022, the workshop concluded with the announcement of BLOOM."""						,  )









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 		lowercase						:






	"""simple docstring"""


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




	def   _SCREAMING_SNAKE_CASE		(	self	:						Tuple     )			-> List[str]:
							UpperCAmelCase_=   floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]     )

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

							UpperCAmelCase_=   self.get_config()

							return config, pixel_values, labels




	def   _SCREAMING_SNAKE_CASE		(	self	:						str     )			-> 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   _SCREAMING_SNAKE_CASE		(	self	:						Any						,  __UpperCAmelCase	:						List[str]						,  __UpperCAmelCase	:						Tuple						,  __UpperCAmelCase	:						Dict     )			-> Optional[Any]:
							UpperCAmelCase_=   SwinModel(config=__UpperCAmelCase     )
							model.to(__UpperCAmelCase     )
							model.eval()
							UpperCAmelCase_=   model(__UpperCAmelCase     )

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

							# 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], 16, 16]     )

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

							# verify backbone works with out_features=None
							UpperCAmelCase_=   None
							UpperCAmelCase_=   SwinBackbone(config=__UpperCAmelCase     )
							model.to(__UpperCAmelCase     )
							model.eval()
							UpperCAmelCase_=   model(__UpperCAmelCase     )

							# 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   _SCREAMING_SNAKE_CASE		(	self	:						List[Any]						,  __UpperCAmelCase	:						Tuple						,  __UpperCAmelCase	:						Optional[Any]						,  __UpperCAmelCase	:						List[str]     )			-> int:
							UpperCAmelCase_=   SwinForMaskedImageModeling(config=__UpperCAmelCase     )
							model.to(__UpperCAmelCase     )
							model.eval()
							UpperCAmelCase_=   model(__UpperCAmelCase     )
							self.parent.assertEqual(
							    result.logits.shape						,  (self.batch_size, self.num_channels, self.image_size, self.image_size)     )

							# test greyscale images
							UpperCAmelCase_=   1
							UpperCAmelCase_=   SwinForMaskedImageModeling(__UpperCAmelCase     )
							model.to(__UpperCAmelCase     )
							model.eval()

							UpperCAmelCase_=   floats_tensor([self.batch_size, 1, self.image_size, self.image_size]     )
							UpperCAmelCase_=   model(__UpperCAmelCase     )
							self.parent.assertEqual(result.logits.shape						,  (self.batch_size, 1, self.image_size, self.image_size)     )




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

							# test greyscale images
							UpperCAmelCase_=   1
							UpperCAmelCase_=   SwinForImageClassification(__UpperCAmelCase     )
							model.to(__UpperCAmelCase     )
							model.eval()

							UpperCAmelCase_=   floats_tensor([self.batch_size, 1, self.image_size, self.image_size]     )
							UpperCAmelCase_=   model(__UpperCAmelCase     )
							self.parent.assertEqual(result.logits.shape						,  (self.batch_size, self.type_sequence_label_size)     )




	def   _SCREAMING_SNAKE_CASE		(	self	:						List[Any]     )			-> Any:
							UpperCAmelCase_=   self.prepare_config_and_inputs()
							(
							    (
							    UpperCAmelCase_
							),   (
							    UpperCAmelCase_
							),   (
							    UpperCAmelCase_
							),   
							)=   config_and_inputs
							UpperCAmelCase_=   {"""pixel_values""": pixel_values}
							return config, inputs_dict






@require_torch
class 		lowercase						( snake_case__ ,    snake_case__ ,    unittest.TestCase):






	"""simple docstring"""


	a__      :					int		   =							(
	    (
	        SwinModel,
	        SwinBackbone,
	        SwinForImageClassification,
	        SwinForMaskedImageModeling,
	    )
	    if is_torch_available()
	    else ()
	)
	a__      :					str		   =							(
	    {"feature-extraction": SwinModel, "image-classification": SwinForImageClassification}
	    if is_torch_available()
	    else {}
	)
	a__      :					int		   =							True

	a__      :					Tuple		   =							False
	a__      :					Union[str, Any]		   =							False
	a__      :					Optional[int]		   =							False




	def   _SCREAMING_SNAKE_CASE		(	self	:						Optional[int]     )			-> Optional[int]:
							UpperCAmelCase_=   SwinModelTester(self     )
							UpperCAmelCase_=   ConfigTester(self						,  config_class=__UpperCAmelCase						,  embed_dim=37     )




	def   _SCREAMING_SNAKE_CASE		(	self	:						List[Any]     )			-> Dict:
							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   _SCREAMING_SNAKE_CASE		(	self	:						Dict     )			-> List[Any]:
							return




	def   _SCREAMING_SNAKE_CASE		(	self	:						Any     )			-> List[Any]:
							UpperCAmelCase_=   self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_model(*__UpperCAmelCase     )




	@unittest.skip(reason="""Got `CUDA error: misaligned address` with PyTorch 2.0.0."""     )
	def   _SCREAMING_SNAKE_CASE		(	self	:						Optional[Any]     )			-> Tuple:
							pass




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




	def   _SCREAMING_SNAKE_CASE		(	self	:						Union[str, Any]     )			-> int:
							UpperCAmelCase_=   self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_backbone(*__UpperCAmelCase     )




	def   _SCREAMING_SNAKE_CASE		(	self	:						Dict     )			-> Tuple:
							UpperCAmelCase_=   self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_masked_image_modeling(*__UpperCAmelCase     )




	def   _SCREAMING_SNAKE_CASE		(	self	:						Optional[int]     )			-> Optional[Any]:
							UpperCAmelCase_=   self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_image_classification(*__UpperCAmelCase     )




	@unittest.skip(reason="""Swin does not use inputs_embeds"""     )
	def   _SCREAMING_SNAKE_CASE		(	self	:						Union[str, Any]     )			-> Dict:
							pass




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




	def   _SCREAMING_SNAKE_CASE		(	self	:						List[str]     )			-> Any:
							UpperCAmelCase_,   UpperCAmelCase_=   self.model_tester.prepare_config_and_inputs_for_common()

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




	def   _SCREAMING_SNAKE_CASE		(	self	:						List[str]     )			-> List[Any]:
							UpperCAmelCase_,   UpperCAmelCase_=   self.model_tester.prepare_config_and_inputs_for_common()

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

													UpperCAmelCase_=   ["""pixel_values"""]
													self.assertListEqual(arg_names[:1]						,  __UpperCAmelCase     )




	def   _SCREAMING_SNAKE_CASE		(	self	:						Optional[int]     )			-> Tuple:
							UpperCAmelCase_,   UpperCAmelCase_=   self.model_tester.prepare_config_and_inputs_for_common()
							UpperCAmelCase_=   True

							for model_class in self.all_model_classes:
													UpperCAmelCase_=   True
													UpperCAmelCase_=   False
													UpperCAmelCase_=   True
													UpperCAmelCase_=   model_class(__UpperCAmelCase     )
													model.to(__UpperCAmelCase     )
													model.eval()
													with torch.no_grad():
																			UpperCAmelCase_=   model(**self._prepare_for_class(__UpperCAmelCase						,  __UpperCAmelCase     )     )
													UpperCAmelCase_=   outputs.attentions
													UpperCAmelCase_=   len(self.model_tester.depths     )
													self.assertEqual(len(__UpperCAmelCase     )						,  __UpperCAmelCase     )

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

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

													# Check attention is always last and order is fine
													UpperCAmelCase_=   True
													UpperCAmelCase_=   True
													UpperCAmelCase_=   model_class(__UpperCAmelCase     )
													model.to(__UpperCAmelCase     )
													model.eval()
													with torch.no_grad():
																			UpperCAmelCase_=   model(**self._prepare_for_class(__UpperCAmelCase						,  __UpperCAmelCase     )     )

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

													UpperCAmelCase_=   outputs.attentions

													self.assertEqual(len(__UpperCAmelCase     )						,  __UpperCAmelCase     )

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




	def   _SCREAMING_SNAKE_CASE		(	self	:						Optional[Any]						,  __UpperCAmelCase	:						str						,  __UpperCAmelCase	:						Any						,  __UpperCAmelCase	:						Tuple						,  __UpperCAmelCase	:						Dict     )			-> str:
							UpperCAmelCase_=   model_class(__UpperCAmelCase     )
							model.to(__UpperCAmelCase     )
							model.eval()

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

							UpperCAmelCase_=   outputs.hidden_states

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

							UpperCAmelCase_=   (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":
													UpperCAmelCase_=   outputs.reshaped_hidden_states
													self.assertEqual(len(__UpperCAmelCase     )						,  __UpperCAmelCase     )

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




	def   _SCREAMING_SNAKE_CASE		(	self	:						Any     )			-> Tuple:
							UpperCAmelCase_,   UpperCAmelCase_=   self.model_tester.prepare_config_and_inputs_for_common()

							UpperCAmelCase_=   (
							    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:
													UpperCAmelCase_=   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"]
													UpperCAmelCase_=   True

													self.check_hidden_states_output(__UpperCAmelCase						,  __UpperCAmelCase						,  __UpperCAmelCase						,  __UpperCAmelCase     )




	def   _SCREAMING_SNAKE_CASE		(	self	:						Optional[Any]     )			-> List[Any]:
							UpperCAmelCase_,   UpperCAmelCase_=   self.model_tester.prepare_config_and_inputs_for_common()
							UpperCAmelCase_=   3

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

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

							for model_class in self.all_model_classes:
													UpperCAmelCase_=   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"]
													UpperCAmelCase_=   True
													self.check_hidden_states_output(__UpperCAmelCase						,  __UpperCAmelCase						,  __UpperCAmelCase						,  (padded_height, padded_width)     )




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




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

							UpperCAmelCase_=   _config_zero_init(__UpperCAmelCase     )
							for model_class in self.all_model_classes:
													UpperCAmelCase_=   model_class(config=__UpperCAmelCase     )
													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 		lowercase						( unittest.TestCase):






	"""simple docstring"""


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




	@slow
	def   _SCREAMING_SNAKE_CASE		(	self	:						Tuple     )			-> int:
							UpperCAmelCase_=   SwinForImageClassification.from_pretrained("""microsoft/swin-tiny-patch4-window7-224"""     ).to(__UpperCAmelCase     )
							UpperCAmelCase_=   self.default_image_processor

							UpperCAmelCase_=   Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""     )
							UpperCAmelCase_=   image_processor(images=__UpperCAmelCase						,  return_tensors="""pt"""     ).to(__UpperCAmelCase     )

							# forward pass
							with torch.no_grad():
													UpperCAmelCase_=   model(**__UpperCAmelCase     )

							# verify the logits
							UpperCAmelCase_=   torch.Size((1, 1_000)     )
							self.assertEqual(outputs.logits.shape						,  __UpperCAmelCase     )
							UpperCAmelCase_=   torch.tensor([-0.0_948, -0.6_454, -0.0_921]     ).to(__UpperCAmelCase     )
							self.assertTrue(torch.allclose(outputs.logits[0, :3]						,  __UpperCAmelCase						,  atol=1E-4     )     )






@require_torch
class 		lowercase						( unittest.TestCase ,    snake_case__):






	"""simple docstring"""


	a__      :					Any		   =							(SwinBackbone,) if is_torch_available() else ()
	a__      :					int		   =							SwinConfig




	def   _SCREAMING_SNAKE_CASE		(	self	:						Optional[Any]     )			-> Optional[Any]:
							UpperCAmelCase_=   SwinModelTester(self     )




