
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		:


					def __init__(	self       ,       a__       ,       a__=1_3       ,       a__=3_2       ,       a__=2       ,       a__=3       ,       a__=1_6       ,       a__=[1, 2, 1]       ,       a__=[2, 2, 4]       ,       a__=2       ,       a__=2.0       ,       a__=True       ,       a__=0.0       ,       a__=0.0       ,       a__=0.1       ,       a__="gelu"       ,       a__=False       ,       a__=True       ,       a__=0.02       ,       a__=1E-5       ,       a__=True       ,       a__=None       ,       a__=True       ,       a__=1_0       ,       a__=8       ,       a__=["stage1", "stage2"]       ,       a__=[1, 2]       ,       )		->							Tuple:





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


					def        lowerCAmelCase_    (	self						)		->							Any:





									'''simple docstring'''
									A_       	=  floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]						)

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

									A_       	=  self.get_config()

									return config, pixel_values, labels


					def        lowerCAmelCase_    (	self						)		->							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        lowerCAmelCase_    (	self       ,       a__       ,       a__       ,       a__						)		->							List[Any]:





									'''simple docstring'''
									A_       	=  SwinModel(config=a__						)
									model.to(a__						)
									model.eval()
									A_       	=  model(a__						)

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

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


					def        lowerCAmelCase_    (	self       ,       a__       ,       a__       ,       a__						)		->							Tuple:





									'''simple docstring'''
									A_       	=  SwinBackbone(config=a__						)
									model.to(a__						)
									model.eval()
									A_       	=  model(a__						)

									# 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_       	=  None
									A_       	=  SwinBackbone(config=a__						)
									model.to(a__						)
									model.eval()
									A_       	=  model(a__						)

									# 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        lowerCAmelCase_    (	self       ,       a__       ,       a__       ,       a__						)		->							Any:





									'''simple docstring'''
									A_       	=  SwinForMaskedImageModeling(config=a__						)
									model.to(a__						)
									model.eval()
									A_       	=  model(a__						)
									self.parent.assertEqual(
									    result.logits.shape       ,       (self.batch_size, self.num_channels, self.image_size, self.image_size)						)

									# test greyscale images
									A_       	=  1
									A_       	=  SwinForMaskedImageModeling(a__						)
									model.to(a__						)
									model.eval()

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


					def        lowerCAmelCase_    (	self       ,       a__       ,       a__       ,       a__						)		->							Optional[Any]:





									'''simple docstring'''
									A_       	=  self.type_sequence_label_size
									A_       	=  SwinForImageClassification(a__						)
									model.to(a__						)
									model.eval()
									A_       	=  model(a__       ,       labels=a__						)
									self.parent.assertEqual(result.logits.shape       ,       (self.batch_size, self.type_sequence_label_size)						)

									# test greyscale images
									A_       	=  1
									A_       	=  SwinForImageClassification(a__						)
									model.to(a__						)
									model.eval()

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


					def        lowerCAmelCase_    (	self						)		->							Tuple:





									'''simple docstring'''
									A_       	=  self.prepare_config_and_inputs()
									(
									    A_				
									)       	=  config_and_inputs
									A_       	=  {"pixel_values": pixel_values}
									return config, inputs_dict






@require_torch
class 					__lowercase		(					lowerCamelCase_							,       lowerCamelCase_							,       unittest.TestCase       ):
					__magic_name__						:							Optional[int]     	=	(
					    (
					        SwinModel,
					        SwinBackbone,
					        SwinForImageClassification,
					        SwinForMaskedImageModeling,
					    )
					    if is_torch_available()
					    else ()
					)
					__magic_name__						:							List[str]     	=	(
					    {"""feature-extraction""": SwinModel, """image-classification""": SwinForImageClassification}
					    if is_torch_available()
					    else {}
					)
					__magic_name__						:							Optional[int]     	=	True

					__magic_name__						:							Optional[Any]     	=	False
					__magic_name__						:							Union[str, Any]     	=	False
					__magic_name__						:							Union[str, Any]     	=	False


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





									'''simple docstring'''
									A_       	=  SwinModelTester(self						)
									A_       	=  ConfigTester(self       ,       config_class=a__       ,       embed_dim=3_7						)


					def        lowerCAmelCase_    (	self						)		->							Dict:





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


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





									'''simple docstring'''
									return


					def        lowerCAmelCase_    (	self						)		->							int:





									'''simple docstring'''
									A_       	=  self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_model(*a__						)


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





									'''simple docstring'''
									pass


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





									'''simple docstring'''
									super().test_training_gradient_checkpointing()


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





									'''simple docstring'''
									A_       	=  self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_backbone(*a__						)


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





									'''simple docstring'''
									A_       	=  self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_masked_image_modeling(*a__						)


					def        lowerCAmelCase_    (	self						)		->							Tuple:





									'''simple docstring'''
									A_       	=  self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_image_classification(*a__						)


					@unittest.skip(reason='''Swin does not use inputs_embeds'''						)
					def        lowerCAmelCase_    (	self						)		->							Tuple:





									'''simple docstring'''
									pass


					@unittest.skip(reason='''Swin Transformer does not use feedforward chunking'''						)
					def        lowerCAmelCase_    (	self						)		->							Any:





									'''simple docstring'''
									pass


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





									'''simple docstring'''
									A_       	=  self.model_tester.prepare_config_and_inputs_for_common()

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


					def        lowerCAmelCase_    (	self						)		->							int:





									'''simple docstring'''
									A_       	=  self.model_tester.prepare_config_and_inputs_for_common()

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

													A_       	=  ["pixel_values"]
													self.assertListEqual(arg_names[:1]       ,       a__						)


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





									'''simple docstring'''
									A_       	=  self.model_tester.prepare_config_and_inputs_for_common()
									A_       	=  True

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

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

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

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

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

													A_       	=  outputs.attentions

													self.assertEqual(len(a__						)       ,       a__						)

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


					def        lowerCAmelCase_    (	self       ,       a__       ,       a__       ,       a__       ,       a__						)		->							Dict:





									'''simple docstring'''
									A_       	=  model_class(a__						)
									model.to(a__						)
									model.eval()

									with torch.no_grad():
													A_       	=  model(**self._prepare_for_class(a__       ,       a__						)						)

									A_       	=  outputs.hidden_states

									A_       	=  getattr(
									    self.model_tester       ,       '''expected_num_hidden_layers'''       ,       len(self.model_tester.depths						) + 1						)
									self.assertEqual(len(a__						)       ,       a__						)

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

									A_       	=  (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_       	=  outputs.reshaped_hidden_states
													self.assertEqual(len(a__						)       ,       a__						)

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


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





									'''simple docstring'''
									A_       	=  self.model_tester.prepare_config_and_inputs_for_common()

									A_       	=  (
									    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_       	=  True
													self.check_hidden_states_output(a__       ,       a__       ,       a__       ,       a__						)

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

													self.check_hidden_states_output(a__       ,       a__       ,       a__       ,       a__						)


					def        lowerCAmelCase_    (	self						)		->							str:





									'''simple docstring'''
									A_       	=  self.model_tester.prepare_config_and_inputs_for_common()
									A_       	=  3

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

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

									for model_class in self.all_model_classes:
													A_       	=  True
													self.check_hidden_states_output(a__       ,       a__       ,       a__       ,       (padded_height, padded_width)						)

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


					@slow
					def        lowerCAmelCase_    (	self						)		->							Optional[Any]:





									'''simple docstring'''







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


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





									'''simple docstring'''
									A_       	=  self.model_tester.prepare_config_and_inputs_for_common()

									A_       	=  _config_zero_init(a__						)
									for model_class in self.all_model_classes:
													A_       	=  model_class(config=a__						)
													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       ):


					@cached_property
					def        lowerCAmelCase_    (	self						)		->							Optional[Any]:





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


					@slow
					def        lowerCAmelCase_    (	self						)		->							Dict:





									'''simple docstring'''
									A_       	=  SwinForImageClassification.from_pretrained('''microsoft/swin-tiny-patch4-window7-224'''						).to(a__						)
									A_       	=  self.default_image_processor

									A_       	=  Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''						)
									A_       	=  image_processor(images=a__       ,       return_tensors='''pt'''						).to(a__						)

									# forward pass
									with torch.no_grad():
													A_       	=  model(**a__						)

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






@require_torch
class 					__lowercase		(					unittest.TestCase							,       lowerCamelCase_       ):
					__magic_name__						:							str     	=	(SwinBackbone,) if is_torch_available() else ()
					__magic_name__						:							List[Any]     	=	SwinConfig


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





									'''simple docstring'''
									A_       	=  SwinModelTester(self						)

import inspect
import unittest

from transformers import DataaVecVisionConfig
from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, require_torch_multi_gpu, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

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 (
						    MODEL_MAPPING,
						    DataaVecVisionForImageClassification,
						    DataaVecVisionForSemanticSegmentation,
						    DataaVecVisionModel,
						)
						from transformers.models.dataavec.modeling_dataavec_vision import DATA2VEC_VISION_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
						from PIL import Image

						from transformers import BeitImageProcessor






class 					__lowercase		:


					def __init__(	self       ,       a__       ,       a__=1_0_0       ,       a__=1_3       ,       a__=3_0       ,       a__=2       ,       a__=3       ,       a__=True       ,       a__=True       ,       a__=3_2       ,       a__=4       ,       a__=4       ,       a__=3_7       ,       a__="gelu"       ,       a__=0.1       ,       a__=0.1       ,       a__=1_0       ,       a__=0.02       ,       a__=3       ,       a__=None       ,       a__=[0, 1, 2, 3]       ,       )		->							Optional[int]:





									'''simple docstring'''
									A_       	=  parent
									A_       	=  1_0_0
									A_       	=  batch_size
									A_       	=  image_size
									A_       	=  patch_size
									A_       	=  num_channels
									A_       	=  is_training
									A_       	=  use_labels
									A_       	=  hidden_size
									A_       	=  num_hidden_layers
									A_       	=  num_attention_heads
									A_       	=  intermediate_size
									A_       	=  hidden_act
									A_       	=  hidden_dropout_prob
									A_       	=  attention_probs_dropout_prob
									A_       	=  type_sequence_label_size
									A_       	=  initializer_range
									A_       	=  scope
									A_       	=  out_indices
									A_       	=  num_labels

									# in BeiT, the seq length equals the number of patches + 1 (we add 1 for the [CLS] token)
									A_       	=  (image_size // patch_size) ** 2
									A_       	=  num_patches + 1


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





									'''simple docstring'''
									A_       	=  floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]						)

									A_       	=  None
									A_       	=  None
									if self.use_labels:
													A_       	=  ids_tensor([self.batch_size]       ,       self.type_sequence_label_size						)
													A_       	=  ids_tensor([self.batch_size, self.image_size, self.image_size]       ,       self.num_labels						)

									A_       	=  self.get_config()

									return config, pixel_values, labels, pixel_labels


					def        lowerCAmelCase_    (	self						)		->							int:





									'''simple docstring'''
									return DataaVecVisionConfig(
									    vocab_size=self.vocab_size       ,       image_size=self.image_size       ,       patch_size=self.patch_size       ,       num_channels=self.num_channels       ,       hidden_size=self.hidden_size       ,       num_hidden_layers=self.num_hidden_layers       ,       num_attention_heads=self.num_attention_heads       ,       intermediate_size=self.intermediate_size       ,       hidden_act=self.hidden_act       ,       hidden_dropout_prob=self.hidden_dropout_prob       ,       attention_probs_dropout_prob=self.attention_probs_dropout_prob       ,       is_decoder=a__       ,       initializer_range=self.initializer_range       ,       out_indices=self.out_indices       ,       )


					def        lowerCAmelCase_    (	self       ,       a__       ,       a__       ,       a__       ,       a__						)		->							List[str]:





									'''simple docstring'''
									A_       	=  DataaVecVisionModel(config=a__						)
									model.to(a__						)
									model.eval()
									A_       	=  model(a__						)
									# expected sequence length = num_patches + 1 (we add 1 for the [CLS] token)
									A_       	=  (self.image_size // self.patch_size) ** 2
									self.parent.assertEqual(result.last_hidden_state.shape       ,       (self.batch_size, num_patches + 1, self.hidden_size)						)


					def        lowerCAmelCase_    (	self       ,       a__       ,       a__       ,       a__       ,       a__						)		->							Any:





									'''simple docstring'''
									A_       	=  self.type_sequence_label_size
									A_       	=  DataaVecVisionForImageClassification(a__						)
									model.to(a__						)
									model.eval()
									A_       	=  model(a__       ,       labels=a__						)
									self.parent.assertEqual(result.logits.shape       ,       (self.batch_size, self.type_sequence_label_size)						)


					def        lowerCAmelCase_    (	self       ,       a__       ,       a__       ,       a__       ,       a__						)		->							int:





									'''simple docstring'''
									A_       	=  self.num_labels
									A_       	=  DataaVecVisionForSemanticSegmentation(a__						)
									model.to(a__						)
									model.eval()
									A_       	=  model(a__						)
									self.parent.assertEqual(
									    result.logits.shape       ,       (self.batch_size, self.num_labels, self.image_size * 2, self.image_size * 2)						)
									A_       	=  model(a__       ,       labels=a__						)
									self.parent.assertEqual(
									    result.logits.shape       ,       (self.batch_size, self.num_labels, self.image_size * 2, self.image_size * 2)						)


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





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






@require_torch
class 					__lowercase		(					A							,       A							,       unittest.TestCase       ):
					__magic_name__						:							int     	=	(
					    (DataaVecVisionModel, DataaVecVisionForImageClassification, DataaVecVisionForSemanticSegmentation)
					    if is_torch_available()
					    else ()
					)
					__magic_name__						:							Any     	=	(
					    {
					        '''feature-extraction''': DataaVecVisionModel,
					        '''image-classification''': DataaVecVisionForImageClassification,
					        '''image-segmentation''': DataaVecVisionForSemanticSegmentation,
					    }
					    if is_torch_available()
					    else {}
					)

					__magic_name__						:							Union[str, Any]     	=	False
					__magic_name__						:							str     	=	False
					__magic_name__						:							Union[str, Any]     	=	False


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





									'''simple docstring'''
									A_       	=  DataaVecVisionModelTester(self						)
									A_       	=  ConfigTester(
									    self       ,       config_class=a__       ,       has_text_modality=a__       ,       hidden_size=3_7						)


					def        lowerCAmelCase_    (	self						)		->							str:





									'''simple docstring'''
									self.config_tester.run_common_tests()


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





									'''simple docstring'''
									# Data2VecVision does not use inputs_embeds
									pass


					@require_torch_multi_gpu
					@unittest.skip(
					    reason='''Data2VecVision has some layers using `add_module` which doesn\'t work well with `nn.DataParallel`'''						)
					def        lowerCAmelCase_    (	self						)		->							Optional[int]:





									'''simple docstring'''
									pass


					def        lowerCAmelCase_    (	self						)		->							Tuple:





									'''simple docstring'''
									A_	,					A_       	=  self.model_tester.prepare_config_and_inputs_for_common()

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


					def        lowerCAmelCase_    (	self						)		->							Dict:





									'''simple docstring'''
									A_	,					A_       	=  self.model_tester.prepare_config_and_inputs_for_common()

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

													A_       	=  ['''pixel_values''']
													self.assertListEqual(arg_names[:1]       ,       a__						)


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





									'''simple docstring'''
									A_       	=  self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_model(*a__						)


					def        lowerCAmelCase_    (	self						)		->							Tuple:





									'''simple docstring'''
									A_       	=  self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_image_segmentation(*a__						)


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





									'''simple docstring'''
									if not self.model_tester.is_training:
													return

									A_	,					A_       	=  self.model_tester.prepare_config_and_inputs_for_common()
									A_       	=  True

									for model_class in self.all_model_classes:
													if model_class in [*get_values(a__						)]:
																	continue

													A_       	=  model_class(a__						)
													model.to(a__						)
													model.train()
													A_       	=  self._prepare_for_class(a__       ,       a__       ,       return_labels=a__						)
													A_       	=  model(**a__						).loss
													loss.backward()


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





									'''simple docstring'''
									A_	,					A_       	=  self.model_tester.prepare_config_and_inputs_for_common()
									if not self.model_tester.is_training:
													return

									A_       	=  False
									A_       	=  True

									for model_class in self.all_model_classes:
													if model_class in [*get_values(a__						)] or not model_class.supports_gradient_checkpointing:
																	continue
													# TODO: remove the following 3 lines once we have a MODEL_FOR_SEMANTIC_SEGMENTATION_MAPPING
													# this can then be incorporated into _prepare_for_class in test_modeling_common.py
													elif model_class.__name__ == "Data2VecVisionForSemanticSegmentation":
																	A_	,					A_	,					A_	,					A_       	=  inputs_dict['''pixel_values'''].shape
																	A_       	=  torch.zeros(
																	    [self.model_tester.batch_size, height, width]       ,       device=a__						).long()
													A_       	=  model_class(a__						)
													model.gradient_checkpointing_enable()
													model.to(a__						)
													model.train()
													A_       	=  self._prepare_for_class(a__       ,       a__       ,       return_labels=a__						)
													A_       	=  model(**a__						).loss
													loss.backward()


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





									'''simple docstring'''
									A_	,					A_       	=  self.model_tester.prepare_config_and_inputs_for_common()

									A_       	=  _config_zero_init(a__						)
									for model_class in self.all_model_classes:
													A_       	=  model_class(config=a__						)
													for name, param in model.named_parameters():
																	# we skip lambda parameters as these require special initial values
																	# determined by config.layer_scale_init_value
																	if "lambda" in name:
																					continue
																	if 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"       ,       )


					def        lowerCAmelCase_    (	self       ,       a__       ,       a__       ,       a__       ,       a__=2E-4       ,       a__="outputs"       ,       a__=None						)		->							Dict:





									'''simple docstring'''
									# We override with a slightly higher tol value, as semseg models tend to diverge a bit more
									super().check_pt_tf_outputs(a__       ,       a__       ,       a__       ,       a__       ,       a__       ,       a__						)


					def        lowerCAmelCase_    (	self						)		->							Dict:





									'''simple docstring'''
									A_       	=  self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_image_classification(*a__						)


					@slow
					def        lowerCAmelCase_    (	self						)		->							Any:





									'''simple docstring'''
									for model_name in DATA2VEC_VISION_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
													A_       	=  DataaVecVisionModel.from_pretrained(a__						)
													self.assertIsNotNone(a__						)



def        lowerCamelCase_  (   ):
				A_       	=  Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''     )
				return image






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


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





									'''simple docstring'''
									return (
									    BeitImageProcessor.from_pretrained('''facebook/data2vec-vision-base-ft1k'''						) if is_vision_available() else None
									)


					@slow
					def        lowerCAmelCase_    (	self						)		->							Union[str, Any]:





									'''simple docstring'''
									A_       	=  DataaVecVisionForImageClassification.from_pretrained('''facebook/data2vec-vision-base-ft1k'''						).to(
									    a__						)

									A_       	=  self.default_image_processor
									A_       	=  prepare_img()
									A_       	=  image_processor(images=a__       ,       return_tensors='''pt'''						).to(a__						)

									# forward pass
									with torch.no_grad():
													A_       	=  model(**a__						)
									A_       	=  outputs.logits

									# verify the logits
									A_       	=  torch.Size((1, 1_0_0_0)						)
									self.assertEqual(logits.shape       ,       a__						)

									A_       	=  torch.tensor([0.32_77, -0.13_95, 0.09_11]						).to(a__						)

									self.assertTrue(torch.allclose(logits[0, :3]       ,       a__       ,       atol=1E-4						)						)

									A_       	=  [model.config.labelaid[i] for i in ['''remote control, remote''', '''tabby, tabby cat''']]
									self.assertEqual(logits[0].topk(2						).indices.cpu().tolist()       ,       a__						)