





"""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 				_a		:






				def __init__(				self	:					Optional[Any],				lowerCAmelCase__	:					Optional[Any],				lowerCAmelCase__	:					Optional[Any]=1_3,				lowerCAmelCase__	:					str=3_2,				lowerCAmelCase__	:					List[Any]=2,				lowerCAmelCase__	:					int=3,				lowerCAmelCase__	:					Optional[int]=1_6,				lowerCAmelCase__	:					List[Any]=[1, 2, 1],				lowerCAmelCase__	:					Optional[Any]=[2, 2, 4],				lowerCAmelCase__	:					Dict=2,				lowerCAmelCase__	:					Optional[Any]=2.0,				lowerCAmelCase__	:					str=True,				lowerCAmelCase__	:					Optional[int]=0.0,				lowerCAmelCase__	:					Optional[Any]=0.0,				lowerCAmelCase__	:					List[Any]=0.1,				lowerCAmelCase__	:					Optional[int]="gelu",				lowerCAmelCase__	:					Optional[int]=False,				lowerCAmelCase__	:					int=True,				lowerCAmelCase__	:					Optional[int]=0.02,				lowerCAmelCase__	:					Tuple=1e-5,				lowerCAmelCase__	:					str=True,				lowerCAmelCase__	:					Tuple=None,				lowerCAmelCase__	:					int=True,				lowerCAmelCase__	:					Tuple=1_0,				lowerCAmelCase__	:					List[Any]=8,				lowerCAmelCase__	:					Optional[Any]=["stage1", "stage2"],				lowerCAmelCase__	:					List[str]=[1, 2],				)			->   List[Any]:




										'''simple docstring'''



										_UpperCamelCase    :      List[str]						     =					parent
										_UpperCamelCase    :      List[Any]						     =					batch_size
										_UpperCamelCase    :      Any						     =					image_size
										_UpperCamelCase    :      List[Any]						     =					patch_size
										_UpperCamelCase    :      Dict						     =					num_channels
										_UpperCamelCase    :      int						     =					embed_dim
										_UpperCamelCase    :      Dict						     =					depths
										_UpperCamelCase    :      int						     =					num_heads
										_UpperCamelCase    :      Optional[int]						     =					window_size
										_UpperCamelCase    :      Union[str, Any]						     =					mlp_ratio
										_UpperCamelCase    :      Any						     =					qkv_bias
										_UpperCamelCase    :      List[str]						     =					hidden_dropout_prob
										_UpperCamelCase    :      Optional[Any]						     =					attention_probs_dropout_prob
										_UpperCamelCase    :      str						     =					drop_path_rate
										_UpperCamelCase    :      Any						     =					hidden_act
										_UpperCamelCase    :      int						     =					use_absolute_embeddings
										_UpperCamelCase    :      int						     =					patch_norm
										_UpperCamelCase    :      Tuple						     =					layer_norm_eps
										_UpperCamelCase    :      int						     =					initializer_range
										_UpperCamelCase    :      Optional[Any]						     =					is_training
										_UpperCamelCase    :      str						     =					scope
										_UpperCamelCase    :      str						     =					use_labels
										_UpperCamelCase    :      Optional[int]						     =					type_sequence_label_size
										_UpperCamelCase    :      Tuple						     =					encoder_stride
										_UpperCamelCase    :      int						     =					out_features
										_UpperCamelCase    :      List[Any]						     =					out_indices






				def        snake_case			(				self	:					Any							)			->   List[str]:




										'''simple docstring'''



										_UpperCamelCase    :      int						     =					floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]							)

										_UpperCamelCase    :      Any						     =					None
										if self.use_labels:
																_UpperCamelCase    :      Dict						     =					ids_tensor([self.batch_size],				self.type_sequence_label_size							)

										_UpperCamelCase    :      Optional[Any]						     =					self.get_config()

										return config, pixel_values, labels






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




										'''simple docstring'''



										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        snake_case			(				self	:					str,				lowerCAmelCase__	:					int,				lowerCAmelCase__	:					Optional[Any],				lowerCAmelCase__	:					Optional[Any]							)			->   Any:




										'''simple docstring'''



										_UpperCamelCase    :      Union[str, Any]						     =					SwinModel(config=lowerCAmelCase__							)
										model.to(lowerCAmelCase__							)
										model.eval()
										_UpperCamelCase    :      Dict						     =					model(lowerCAmelCase__							)

										_UpperCamelCase    :      Optional[int]						     =					((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths							) - 1))
										_UpperCamelCase    :      Optional[int]						     =					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        snake_case			(				self	:					int,				lowerCAmelCase__	:					Optional[int],				lowerCAmelCase__	:					Union[str, Any],				lowerCAmelCase__	:					Union[str, Any]							)			->   int:




										'''simple docstring'''



										_UpperCamelCase    :      Tuple						     =					SwinBackbone(config=lowerCAmelCase__							)
										model.to(lowerCAmelCase__							)
										model.eval()
										_UpperCamelCase    :      Optional[int]						     =					model(lowerCAmelCase__							)

										# 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
										_UpperCamelCase    :      Union[str, Any]						     =					None
										_UpperCamelCase    :      str						     =					SwinBackbone(config=lowerCAmelCase__							)
										model.to(lowerCAmelCase__							)
										model.eval()
										_UpperCamelCase    :      Dict						     =					model(lowerCAmelCase__							)

										# 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        snake_case			(				self	:					List[Any],				lowerCAmelCase__	:					Dict,				lowerCAmelCase__	:					Any,				lowerCAmelCase__	:					List[Any]							)			->   Optional[int]:




										'''simple docstring'''



										_UpperCamelCase    :      List[str]						     =					SwinForMaskedImageModeling(config=lowerCAmelCase__							)
										model.to(lowerCAmelCase__							)
										model.eval()
										_UpperCamelCase    :      Optional[Any]						     =					model(lowerCAmelCase__							)
										self.parent.assertEqual(
										    result.logits.shape,				(self.batch_size, self.num_channels, self.image_size, self.image_size)							)

										# test greyscale images
										_UpperCamelCase    :      List[str]						     =					1
										_UpperCamelCase    :      Optional[Any]						     =					SwinForMaskedImageModeling(lowerCAmelCase__							)
										model.to(lowerCAmelCase__							)
										model.eval()

										_UpperCamelCase    :      List[Any]						     =					floats_tensor([self.batch_size, 1, self.image_size, self.image_size]							)
										_UpperCamelCase    :      List[Any]						     =					model(lowerCAmelCase__							)
										self.parent.assertEqual(result.logits.shape,				(self.batch_size, 1, self.image_size, self.image_size)							)






				def        snake_case			(				self	:					Any,				lowerCAmelCase__	:					Tuple,				lowerCAmelCase__	:					str,				lowerCAmelCase__	:					str							)			->   Any:




										'''simple docstring'''



										_UpperCamelCase    :      Union[str, Any]						     =					self.type_sequence_label_size
										_UpperCamelCase    :      Any						     =					SwinForImageClassification(lowerCAmelCase__							)
										model.to(lowerCAmelCase__							)
										model.eval()
										_UpperCamelCase    :      Dict						     =					model(lowerCAmelCase__,				labels=lowerCAmelCase__							)
										self.parent.assertEqual(result.logits.shape,				(self.batch_size, self.type_sequence_label_size)							)

										# test greyscale images
										_UpperCamelCase    :      List[Any]						     =					1
										_UpperCamelCase    :      int						     =					SwinForImageClassification(lowerCAmelCase__							)
										model.to(lowerCAmelCase__							)
										model.eval()

										_UpperCamelCase    :      int						     =					floats_tensor([self.batch_size, 1, self.image_size, self.image_size]							)
										_UpperCamelCase    :      Any						     =					model(lowerCAmelCase__							)
										self.parent.assertEqual(result.logits.shape,				(self.batch_size, self.type_sequence_label_size)							)






				def        snake_case			(				self	:					List[Any]							)			->   List[Any]:




										'''simple docstring'''



										_UpperCamelCase    :      Optional[Any]						     =					self.prepare_config_and_inputs()
										(
										    (
										    _UpperCamelCase
										)     ,							(
										    _UpperCamelCase
										)     ,							(
										    _UpperCamelCase
										)     ,							
										)    :      Optional[int]						     =					config_and_inputs
										_UpperCamelCase    :      Tuple						     =					{'''pixel_values''': pixel_values}
										return config, inputs_dict




@require_torch
class 				_a		(   _lowerCAmelCase			,       _lowerCAmelCase			,       unittest.TestCase       ):
				UpperCamelCase			=					(
				    (
				        SwinModel,
				        SwinBackbone,
				        SwinForImageClassification,
				        SwinForMaskedImageModeling,
				    )
				    if is_torch_available()
				    else ()
				)
				UpperCamelCase			=					(
				    {'''feature-extraction''': SwinModel, '''image-classification''': SwinForImageClassification}
				    if is_torch_available()
				    else {}
				)
				UpperCamelCase			=					True

				UpperCamelCase			=					False
				UpperCamelCase			=					False
				UpperCamelCase			=					False






				def        snake_case			(				self	:					List[str]							)			->   Dict:




										'''simple docstring'''



										_UpperCamelCase    :      Optional[int]						     =					SwinModelTester(self							)
										_UpperCamelCase    :      Dict						     =					ConfigTester(self,				config_class=lowerCAmelCase__,				embed_dim=3_7							)






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




										'''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        snake_case			(				self	:					Dict							)			->   str:




										'''simple docstring'''



										return






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




										'''simple docstring'''



										_UpperCamelCase    :      str						     =					self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_model(*lowerCAmelCase__							)






				@unittest.skip(reason='''Got `CUDA error: misaligned address` with PyTorch 2.0.0.'''							)
				def        snake_case			(				self	:					List[Any]							)			->   Optional[Any]:




										'''simple docstring'''



										pass






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




										'''simple docstring'''



										super().test_training_gradient_checkpointing()






				def        snake_case			(				self	:					int							)			->   Any:




										'''simple docstring'''



										_UpperCamelCase    :      int						     =					self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_backbone(*lowerCAmelCase__							)






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




										'''simple docstring'''



										_UpperCamelCase    :      int						     =					self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_masked_image_modeling(*lowerCAmelCase__							)






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




										'''simple docstring'''



										_UpperCamelCase    :      Any						     =					self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_image_classification(*lowerCAmelCase__							)






				@unittest.skip(reason='''Swin does not use inputs_embeds'''							)
				def        snake_case			(				self	:					str							)			->   List[Any]:




										'''simple docstring'''



										pass






				@unittest.skip(reason='''Swin Transformer does not use feedforward chunking'''							)
				def        snake_case			(				self	:					List[Any]							)			->   Optional[Any]:




										'''simple docstring'''



										pass






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




										'''simple docstring'''



										_UpperCamelCase     ,							_UpperCamelCase    :      Dict						     =					self.model_tester.prepare_config_and_inputs_for_common()

										for model_class in self.all_model_classes:
																_UpperCamelCase    :      Optional[Any]						     =					model_class(lowerCAmelCase__							)
																self.assertIsInstance(model.get_input_embeddings(),				(nn.Module)							)
																_UpperCamelCase    :      Union[str, Any]						     =					model.get_output_embeddings()
																self.assertTrue(x is None or isinstance(lowerCAmelCase__,				nn.Linear							)							)






				def        snake_case			(				self	:					Tuple							)			->   List[Any]:




										'''simple docstring'''



										_UpperCamelCase     ,							_UpperCamelCase    :      Any						     =					self.model_tester.prepare_config_and_inputs_for_common()

										for model_class in self.all_model_classes:
																_UpperCamelCase    :      int						     =					model_class(lowerCAmelCase__							)
																_UpperCamelCase    :      Dict						     =					inspect.signature(model.forward							)
																# signature.parameters is an OrderedDict => so arg_names order is deterministic
																_UpperCamelCase    :      Union[str, Any]						     =					[*signature.parameters.keys()]

																_UpperCamelCase    :      Tuple						     =					['''pixel_values''']
																self.assertListEqual(arg_names[:1],				lowerCAmelCase__							)






				def        snake_case			(				self	:					List[str]							)			->   List[str]:




										'''simple docstring'''



										_UpperCamelCase     ,							_UpperCamelCase    :      List[Any]						     =					self.model_tester.prepare_config_and_inputs_for_common()
										_UpperCamelCase    :      Union[str, Any]						     =					True

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

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

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

																# Check attention is always last and order is fine
																_UpperCamelCase    :      List[str]						     =					True
																_UpperCamelCase    :      List[str]						     =					True
																_UpperCamelCase    :      Dict						     =					model_class(lowerCAmelCase__							)
																model.to(lowerCAmelCase__							)
																model.eval()
																with torch.no_grad():
																						_UpperCamelCase    :      List[str]						     =					model(**self._prepare_for_class(lowerCAmelCase__,				lowerCAmelCase__							)							)

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

																_UpperCamelCase    :      Optional[int]						     =					outputs.attentions

																self.assertEqual(len(lowerCAmelCase__							),				lowerCAmelCase__							)

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






				def        snake_case			(				self	:					List[Any],				lowerCAmelCase__	:					str,				lowerCAmelCase__	:					str,				lowerCAmelCase__	:					Optional[Any],				lowerCAmelCase__	:					str							)			->   str:




										'''simple docstring'''



										_UpperCamelCase    :      List[Any]						     =					model_class(lowerCAmelCase__							)
										model.to(lowerCAmelCase__							)
										model.eval()

										with torch.no_grad():
																_UpperCamelCase    :      Any						     =					model(**self._prepare_for_class(lowerCAmelCase__,				lowerCAmelCase__							)							)

										_UpperCamelCase    :      Tuple						     =					outputs.hidden_states

										_UpperCamelCase    :      Any						     =					getattr(
										    self.model_tester,				'''expected_num_hidden_layers''',				len(self.model_tester.depths							) + 1							)
										self.assertEqual(len(lowerCAmelCase__							),				lowerCAmelCase__							)

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

										_UpperCamelCase    :      int						     =					(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    :      Any						     =					outputs.reshaped_hidden_states
																self.assertEqual(len(lowerCAmelCase__							),				lowerCAmelCase__							)

																_UpperCamelCase     ,							_UpperCamelCase     ,							_UpperCamelCase     ,							_UpperCamelCase    :      Tuple						     =					reshaped_hidden_states[0].shape
																_UpperCamelCase    :      List[Any]						     =					(
																    reshaped_hidden_states[0].view(lowerCAmelCase__,				lowerCAmelCase__,				height * width							).permute(0,				2,				1							)
																)
																self.assertListEqual(
																    list(reshaped_hidden_states.shape[-2:]							),				[num_patches, self.model_tester.embed_dim],				)






				def        snake_case			(				self	:					Dict							)			->   List[Any]:




										'''simple docstring'''



										_UpperCamelCase     ,							_UpperCamelCase    :      Union[str, Any]						     =					self.model_tester.prepare_config_and_inputs_for_common()

										_UpperCamelCase    :      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:
																_UpperCamelCase    :      Union[str, Any]						     =					True
																self.check_hidden_states_output(lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__							)

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

																self.check_hidden_states_output(lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__							)






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




										'''simple docstring'''



										_UpperCamelCase     ,							_UpperCamelCase    :      Any						     =					self.model_tester.prepare_config_and_inputs_for_common()
										_UpperCamelCase    :      Union[str, Any]						     =					3

										_UpperCamelCase    :      Optional[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)
										)
										_UpperCamelCase    :      str						     =					(
										    config.patch_size
										    if isinstance(config.patch_size,				collections.abc.Iterable							)
										    else (config.patch_size, config.patch_size)
										)

										_UpperCamelCase    :      int						     =					image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
										_UpperCamelCase    :      Tuple						     =					image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

										for model_class in self.all_model_classes:
																_UpperCamelCase    :      Union[str, Any]						     =					True
																self.check_hidden_states_output(lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__,				(padded_height, padded_width)							)

																# check that output_hidden_states also work using config
																del inputs_dict["output_hidden_states"]
																_UpperCamelCase    :      Optional[int]						     =					True
																self.check_hidden_states_output(lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__,				(padded_height, padded_width)							)






				@slow
				def        snake_case			(				self	:					List[Any]							)			->   int:




										'''simple docstring'''



										for model_name in SWIN_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																_UpperCamelCase    :      List[Any]						     =					SwinModel.from_pretrained(lowerCAmelCase__							)
																self.assertIsNotNone(lowerCAmelCase__							)






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




										'''simple docstring'''



										_UpperCamelCase     ,							_UpperCamelCase    :      List[Any]						     =					self.model_tester.prepare_config_and_inputs_for_common()

										_UpperCamelCase    :      Any						     =					_config_zero_init(lowerCAmelCase__							)
										for model_class in self.all_model_classes:
																_UpperCamelCase    :      Tuple						     =					model_class(config=lowerCAmelCase__							)
																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 				_a		(   unittest.TestCase       ):






				@cached_property
				def        snake_case			(				self	:					Union[str, Any]							)			->   Any:




										'''simple docstring'''



										return (
										    AutoImageProcessor.from_pretrained('''microsoft/swin-tiny-patch4-window7-224'''							)
										    if is_vision_available()
										    else None
										)






				@slow
				def        snake_case			(				self	:					List[str]							)			->   Tuple:




										'''simple docstring'''



										_UpperCamelCase    :      Optional[int]						     =					SwinForImageClassification.from_pretrained('''microsoft/swin-tiny-patch4-window7-224'''							).to(lowerCAmelCase__							)
										_UpperCamelCase    :      int						     =					self.default_image_processor

										_UpperCamelCase    :      Dict						     =					Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''							)
										_UpperCamelCase    :      Optional[int]						     =					image_processor(images=lowerCAmelCase__,				return_tensors='''pt'''							).to(lowerCAmelCase__							)

										# forward pass
										with torch.no_grad():
																_UpperCamelCase    :      Optional[int]						     =					model(**lowerCAmelCase__							)

										# verify the logits
										_UpperCamelCase    :      int						     =					torch.Size((1, 1_0_0_0)							)
										self.assertEqual(outputs.logits.shape,				lowerCAmelCase__							)
										_UpperCamelCase    :      List[str]						     =					torch.tensor([-0.0_948, -0.6_454, -0.0_921]							).to(lowerCAmelCase__							)
										self.assertTrue(torch.allclose(outputs.logits[0, :3],				lowerCAmelCase__,				atol=1e-4							)							)




@require_torch
class 				_a		(   unittest.TestCase			,       _lowerCAmelCase       ):
				UpperCamelCase			=					(SwinBackbone,) if is_torch_available() else ()
				UpperCamelCase			=					SwinConfig






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




										'''simple docstring'''



										_UpperCamelCase    :      List[str]						     =					SwinModelTester(self							)










"""simple docstring"""




UpperCamelCase_     =1_000





def  a_       (							_lowercase     ):
						return x * x





def  a_       (							_lowercase ,		_lowercase ,		_lowercase ,		_lowercase = 4     ):
						assert callable(
						    _lowercase     ), F"""the function(object) passed should be callable your input : {function}"""
						assert isinstance(_lowercase ,		(float, int)     ), F"""a should be float or integer your input : {a}"""
						assert isinstance(function(_lowercase     ) ,		(float, int)     ), (
						    "the function should return integer or float return type of your function, "
						    F"""{type(_lowercase     )}"""
						)
						assert isinstance(_lowercase ,		(float, int)     ), F"""b should be float or integer your input : {b}"""
						assert (
						    isinstance(_lowercase ,		_lowercase     ) and precision > 0
						), F"""precision should be positive integer your input : {precision}"""

						# just applying the formula of simpson for approximate integration written in
						# mentioned article in first comment of this file and above this function

						_UpperCamelCase    :      str						     =					(b - a) / N_STEPS
						_UpperCamelCase    :      Dict						     =					function(_lowercase     ) + function(_lowercase     )

						for i in range(1 ,		_lowercase     ):
												_UpperCamelCase    :      List[Any]						     =					a + h * i
												result += function(_lowercase     ) * (4 if i % 2 else 2)

						result *= h / 3
						return round(_lowercase ,		_lowercase     )


if __name__ == "__main__":
						import doctest

						doctest.testmod()



