




'''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 	lowerCamelCase_				:




					'''simple docstring'''






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






					def 							__SCREAMING_SNAKE_CASE      (       self					):
							_snake_case      			=			floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]					)

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

							_snake_case      			=			self.get_config()

							return config, pixel_values, labels






					def 							__SCREAMING_SNAKE_CASE      (       self					):
							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,    __UpperCamelCase,    __UpperCamelCase,    __UpperCamelCase					):
							_snake_case      			=			SwinModel(config=__UpperCamelCase					)
							model.to(__UpperCamelCase					)
							model.eval()
							_snake_case      			=			model(__UpperCamelCase					)

							_snake_case      			=			((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths					) - 1))
							_snake_case      			=			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,    __UpperCamelCase,    __UpperCamelCase,    __UpperCamelCase					):
							_snake_case      			=			SwinBackbone(config=__UpperCamelCase					)
							model.to(__UpperCamelCase					)
							model.eval()
							_snake_case      			=			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
							_snake_case      			=			None
							_snake_case      			=			SwinBackbone(config=__UpperCamelCase					)
							model.to(__UpperCamelCase					)
							model.eval()
							_snake_case      			=			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,    __UpperCamelCase,    __UpperCamelCase,    __UpperCamelCase					):
							_snake_case      			=			SwinForMaskedImageModeling(config=__UpperCamelCase					)
							model.to(__UpperCamelCase					)
							model.eval()
							_snake_case      			=			model(__UpperCamelCase					)
							self.parent.assertEqual(
							    result.logits.shape,    (self.batch_size, self.num_channels, self.image_size, self.image_size)					)

							# test greyscale images
							_snake_case      			=			1
							_snake_case      			=			SwinForMaskedImageModeling(__UpperCamelCase					)
							model.to(__UpperCamelCase					)
							model.eval()

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






					def 							__SCREAMING_SNAKE_CASE      (       self,    __UpperCamelCase,    __UpperCamelCase,    __UpperCamelCase					):
							_snake_case      			=			self.type_sequence_label_size
							_snake_case      			=			SwinForImageClassification(__UpperCamelCase					)
							model.to(__UpperCamelCase					)
							model.eval()
							_snake_case      			=			model(__UpperCamelCase,    labels=__UpperCamelCase					)
							self.parent.assertEqual(result.logits.shape,    (self.batch_size, self.type_sequence_label_size)					)

							# test greyscale images
							_snake_case      			=			1
							_snake_case      			=			SwinForImageClassification(__UpperCamelCase					)
							model.to(__UpperCamelCase					)
							model.eval()

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






					def 							__SCREAMING_SNAKE_CASE      (       self					):
							_snake_case      			=			self.prepare_config_and_inputs()
							(
							    (
							    _snake_case
							)			,       (
							    _snake_case
							)			,       (
							    _snake_case
							)			,       
							)      			=			config_and_inputs
							_snake_case      			=			{"pixel_values": pixel_values}
							return config, inputs_dict





@require_torch
class 	lowerCamelCase_				(			UpperCAmelCase_,			UpperCAmelCase_,			unittest.TestCase				):




					'''simple docstring'''






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

					lowercase__       =					False
					lowercase__       =					False
					lowercase__       =					False






					def 							__SCREAMING_SNAKE_CASE      (       self					):
							_snake_case      			=			SwinModelTester(self					)
							_snake_case      			=			ConfigTester(self,    config_class=__UpperCamelCase,    embed_dim=37					)






					def 							__SCREAMING_SNAKE_CASE      (       self					):
							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					):
							return






					def 							__SCREAMING_SNAKE_CASE      (       self					):
							_snake_case      			=			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					):
							pass






					def 							__SCREAMING_SNAKE_CASE      (       self					):
							super().test_training_gradient_checkpointing()






					def 							__SCREAMING_SNAKE_CASE      (       self					):
							_snake_case      			=			self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_backbone(*__UpperCamelCase					)






					def 							__SCREAMING_SNAKE_CASE      (       self					):
							_snake_case      			=			self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_masked_image_modeling(*__UpperCamelCase					)






					def 							__SCREAMING_SNAKE_CASE      (       self					):
							_snake_case      			=			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					):
							pass






					@unittest.skip(reason="Swin Transformer does not use feedforward chunking"					)
					def 							__SCREAMING_SNAKE_CASE      (       self					):
							pass






					def 							__SCREAMING_SNAKE_CASE      (       self					):
							_snake_case			,       _snake_case      			=			self.model_tester.prepare_config_and_inputs_for_common()

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






					def 							__SCREAMING_SNAKE_CASE      (       self					):
							_snake_case			,       _snake_case      			=			self.model_tester.prepare_config_and_inputs_for_common()

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

									_snake_case      			=			["pixel_values"]
									self.assertListEqual(arg_names[:1],    __UpperCamelCase					)






					def 							__SCREAMING_SNAKE_CASE      (       self					):
							_snake_case			,       _snake_case      			=			self.model_tester.prepare_config_and_inputs_for_common()
							_snake_case      			=			True

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

									# check that output_attentions also work using config
									del inputs_dict["output_attentions"]
									_snake_case      			=			True
									_snake_case      			=			config.window_size**2
									_snake_case      			=			model_class(__UpperCamelCase					)
									model.to(__UpperCamelCase					)
									model.eval()
									with torch.no_grad():
											_snake_case      			=			model(**self._prepare_for_class(__UpperCamelCase,    __UpperCamelCase					)					)
									_snake_case      			=			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],    )
									_snake_case      			=			len(__UpperCamelCase					)

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

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

									_snake_case      			=			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,    __UpperCamelCase,    __UpperCamelCase,    __UpperCamelCase,    __UpperCamelCase					):
							_snake_case      			=			model_class(__UpperCamelCase					)
							model.to(__UpperCamelCase					)
							model.eval()

							with torch.no_grad():
									_snake_case      			=			model(**self._prepare_for_class(__UpperCamelCase,    __UpperCamelCase					)					)

							_snake_case      			=			outputs.hidden_states

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

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

									_snake_case			,       _snake_case			,       _snake_case			,       _snake_case      			=			reshaped_hidden_states[0].shape
									_snake_case      			=			(
									    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					):
							_snake_case			,       _snake_case      			=			self.model_tester.prepare_config_and_inputs_for_common()

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

									self.check_hidden_states_output(__UpperCamelCase,    __UpperCamelCase,    __UpperCamelCase,    __UpperCamelCase					)






					def 							__SCREAMING_SNAKE_CASE      (       self					):
							_snake_case			,       _snake_case      			=			self.model_tester.prepare_config_and_inputs_for_common()
							_snake_case      			=			3

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

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

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






					@slow
					def 							__SCREAMING_SNAKE_CASE      (       self					):

							for model_name in SWIN_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
									_snake_case      			=			SwinModel.from_pretrained(__UpperCamelCase					)
									self.assertIsNotNone(__UpperCamelCase					)






					def 							__SCREAMING_SNAKE_CASE      (       self					):
							_snake_case			,       _snake_case      			=			self.model_tester.prepare_config_and_inputs_for_common()

							_snake_case      			=			_config_zero_init(__UpperCamelCase					)
							for model_class in self.all_model_classes:
									_snake_case      			=			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 	lowerCamelCase_				(			unittest.TestCase				):




					'''simple docstring'''






					@cached_property
					def 							__SCREAMING_SNAKE_CASE      (       self					):
							return (
							    AutoImageProcessor.from_pretrained("microsoft/swin-tiny-patch4-window7-224"					)
							    if is_vision_available()
							    else None
							)






					@slow
					def 							__SCREAMING_SNAKE_CASE      (       self					):
							_snake_case      			=			SwinForImageClassification.from_pretrained("microsoft/swin-tiny-patch4-window7-224"					).to(__UpperCamelCase					)
							_snake_case      			=			self.default_image_processor

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

							# forward pass
							with torch.no_grad():
									_snake_case      			=			model(**__UpperCamelCase					)

							# verify the logits
							_snake_case      			=			torch.Size((1, 1_000)					)
							self.assertEqual(outputs.logits.shape,    __UpperCamelCase					)
							_snake_case      			=			torch.tensor([-0.09_48, -0.64_54, -0.09_21]					).to(__UpperCamelCase					)
							self.assertTrue(torch.allclose(outputs.logits[0, :3],    __UpperCamelCase,    atol=1E-4					)					)





@require_torch
class 	lowerCamelCase_				(			unittest.TestCase,			UpperCAmelCase_				):




					'''simple docstring'''






					lowercase__       =					(SwinBackbone,) if is_torch_available() else ()
					lowercase__       =					SwinConfig






					def 							__SCREAMING_SNAKE_CASE      (       self					):
							_snake_case      			=			SwinModelTester(self					)






"""simple docstring"""
from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_sentencepiece_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


SCREAMING_SNAKE_CASE__       =	{
    "configuration_marian": ["MARIAN_PRETRAINED_CONFIG_ARCHIVE_MAP", "MarianConfig", "MarianOnnxConfig"],
}

try:
					if not is_sentencepiece_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					SCREAMING_SNAKE_CASE__       =	["MarianTokenizer"]

try:
					if not is_torch_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					SCREAMING_SNAKE_CASE__       =	[
					    "MARIAN_PRETRAINED_MODEL_ARCHIVE_LIST",
					    "MarianForCausalLM",
					    "MarianModel",
					    "MarianMTModel",
					    "MarianPreTrainedModel",
					]

try:
					if not is_tf_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					SCREAMING_SNAKE_CASE__       =	["TFMarianModel", "TFMarianMTModel", "TFMarianPreTrainedModel"]

try:
					if not is_flax_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					SCREAMING_SNAKE_CASE__       =	["FlaxMarianModel", "FlaxMarianMTModel", "FlaxMarianPreTrainedModel"]

if TYPE_CHECKING:
					from .configuration_marian import MARIAN_PRETRAINED_CONFIG_ARCHIVE_MAP, MarianConfig, MarianOnnxConfig

					try:
										if not is_sentencepiece_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .tokenization_marian import MarianTokenizer

					try:
										if not is_torch_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_marian import (
										    MARIAN_PRETRAINED_MODEL_ARCHIVE_LIST,
										    MarianForCausalLM,
										    MarianModel,
										    MarianMTModel,
										    MarianPreTrainedModel,
										)

					try:
										if not is_tf_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_tf_marian import TFMarianModel, TFMarianMTModel, TFMarianPreTrainedModel

					try:
										if not is_flax_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_flax_marian import FlaxMarianModel, FlaxMarianMTModel, FlaxMarianPreTrainedModel

else:
					import sys

					SCREAMING_SNAKE_CASE__       =	_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)


