
import torch
import torch.nn as nn
from transformers.modeling_utils import ModuleUtilsMixin
from transformers.models.ta.modeling_ta import (
    TaBlock,
    TaConfig,
    TaLayerNorm,
)

from ...configuration_utils import ConfigMixin, register_to_config
from ...models import ModelMixin






class 					__lowercase		(					A							,       A							,       A       ):


					@register_to_config
					def __init__(	self       ,       a__       ,       a__       ,       a__       ,       a__       ,       a__       ,       a__       ,       a__       ,       a__       ,       a__       ,       a__ = False       ,       )		->							str:





									'''simple docstring'''
									super().__init__()

									A_       	=  nn.Linear(a__       ,       a__       ,       bias=a__						)

									A_       	=  nn.Embedding(a__       ,       a__						)
									A_       	=  False

									A_       	=  nn.Dropout(p=a__						)

									A_       	=  TaConfig(
									    d_model=a__       ,       num_heads=a__       ,       d_kv=a__       ,       d_ff=a__       ,       feed_forward_proj=a__       ,       dropout_rate=a__       ,       is_decoder=a__       ,       is_encoder_decoder=a__       ,       )
									A_       	=  nn.ModuleList()
									for lyr_num in range(a__						):
													A_       	=  TaBlock(a__						)
													self.encoders.append(a__						)

									A_       	=  TaLayerNorm(a__						)
									A_       	=  nn.Dropout(p=a__						)


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





									'''simple docstring'''
									A_       	=  self.input_proj(a__						)

									# terminal relative positional encodings
									A_       	=  encoder_inputs.shape[1]
									A_       	=  torch.arange(a__       ,       device=encoder_inputs.device						)

									A_       	=  encoder_inputs_mask.sum(-1						)
									A_       	=  torch.roll(input_positions.unsqueeze(0						)       ,       tuple(seq_lens.tolist()						)       ,       dims=0						)
									x += self.position_encoding(a__						)

									A_       	=  self.dropout_pre(a__						)

									# inverted the attention mask
									A_       	=  encoder_inputs.size()
									A_       	=  self.get_extended_attention_mask(a__       ,       a__						)

									for lyr in self.encoders:
													A_       	=  lyr(a__       ,       a__						)[0]
									A_       	=  self.layer_norm(a__						)

									return self.dropout_post(a__						), encoder_inputs_mask

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__						)