"""simple docstring"""


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

				def __init__(				self     ,			_lowerCamelCase     ,			_lowerCamelCase=100     ,			_lowerCamelCase=13     ,			_lowerCamelCase=30     ,			_lowerCamelCase=2     ,			_lowerCamelCase=3     ,			_lowerCamelCase=True     ,			_lowerCamelCase=True     ,			_lowerCamelCase=32     ,			_lowerCamelCase=4     ,			_lowerCamelCase=4     ,			_lowerCamelCase=37     ,			_lowerCamelCase="gelu"     ,			_lowerCamelCase=0.1     ,			_lowerCamelCase=0.1     ,			_lowerCamelCase=10     ,			_lowerCamelCase=0.0_2     ,			_lowerCamelCase=3     ,			_lowerCamelCase=None     ,			_lowerCamelCase=[0, 1, 2, 3]     ,			):
										lowerCamelCase__ =parent
										lowerCamelCase__ =100
										lowerCamelCase__ =batch_size
										lowerCamelCase__ =image_size
										lowerCamelCase__ =patch_size
										lowerCamelCase__ =num_channels
										lowerCamelCase__ =is_training
										lowerCamelCase__ =use_labels
										lowerCamelCase__ =hidden_size
										lowerCamelCase__ =num_hidden_layers
										lowerCamelCase__ =num_attention_heads
										lowerCamelCase__ =intermediate_size
										lowerCamelCase__ =hidden_act
										lowerCamelCase__ =hidden_dropout_prob
										lowerCamelCase__ =attention_probs_dropout_prob
										lowerCamelCase__ =type_sequence_label_size
										lowerCamelCase__ =initializer_range
										lowerCamelCase__ =scope
										lowerCamelCase__ =out_indices
										lowerCamelCase__ =num_labels

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

				def 		_a     (				self				):
										lowerCamelCase__ =floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]				)

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

										lowerCamelCase__ =self.get_config()

										return config, pixel_values, labels, pixel_labels

				def 		_a     (				self				):
										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=_lowerCamelCase     ,			initializer_range=self.initializer_range     ,			out_indices=self.out_indices     ,			)

				def 		_a     (				self     ,			_lowerCamelCase     ,			_lowerCamelCase     ,			_lowerCamelCase     ,			_lowerCamelCase				):
										lowerCamelCase__ =DataaVecVisionModel(config=_lowerCamelCase				)
										model.to(_lowerCamelCase				)
										model.eval()
										lowerCamelCase__ =model(_lowerCamelCase				)
										# expected sequence length = num_patches + 1 (we add 1 for the [CLS] token)
										lowerCamelCase__ =(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 		_a     (				self     ,			_lowerCamelCase     ,			_lowerCamelCase     ,			_lowerCamelCase     ,			_lowerCamelCase				):
										lowerCamelCase__ =self.type_sequence_label_size
										lowerCamelCase__ =DataaVecVisionForImageClassification(_lowerCamelCase				)
										model.to(_lowerCamelCase				)
										model.eval()
										lowerCamelCase__ =model(_lowerCamelCase     ,			labels=_lowerCamelCase				)
										self.parent.assertEqual(result.logits.shape     ,			(self.batch_size, self.type_sequence_label_size)				)

				def 		_a     (				self     ,			_lowerCamelCase     ,			_lowerCamelCase     ,			_lowerCamelCase     ,			_lowerCamelCase				):
										lowerCamelCase__ =self.num_labels
										lowerCamelCase__ =DataaVecVisionForSemanticSegmentation(_lowerCamelCase				)
										model.to(_lowerCamelCase				)
										model.eval()
										lowerCamelCase__ =model(_lowerCamelCase				)
										self.parent.assertEqual(
										    result.logits.shape     ,			(self.batch_size, self.num_labels, self.image_size * 2, self.image_size * 2)				)
										lowerCamelCase__ =model(_lowerCamelCase     ,			labels=_lowerCamelCase				)
										self.parent.assertEqual(
										    result.logits.shape     ,			(self.batch_size, self.num_labels, self.image_size * 2, self.image_size * 2)				)






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






@require_torch
class        __UpperCAmelCase						(     __lowerCAmelCase				,				__lowerCAmelCase				,				unittest.TestCase     ):
				A__				:       Union[str, Any]  							=	(
				    (DataaVecVisionModel, DataaVecVisionForImageClassification, DataaVecVisionForSemanticSegmentation)
				    if is_torch_available()
				    else ()
				)
				A__				:       List[Any]  							=	(
				    {
				        '''feature-extraction''': DataaVecVisionModel,
				        '''image-classification''': DataaVecVisionForImageClassification,
				        '''image-segmentation''': DataaVecVisionForSemanticSegmentation,
				    }
				    if is_torch_available()
				    else {}
				)

				A__				:       Dict  							=	False
				A__				:       str  							=	False
				A__				:       Any  							=	False

				def 		_a     (				self				):
										lowerCamelCase__ =DataaVecVisionModelTester(self				)
										lowerCamelCase__ =ConfigTester(
										    self     ,			config_class=_lowerCamelCase     ,			has_text_modality=_lowerCamelCase     ,			hidden_size=37				)

				def 		_a     (				self				):
										self.config_tester.run_common_tests()

				def 		_a     (				self				):
										# 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 		_a     (				self				):
										pass

				def 		_a     (				self				):
										lowerCamelCase__ ,				lowerCamelCase__ =self.model_tester.prepare_config_and_inputs_for_common()

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

				def 		_a     (				self				):
										lowerCamelCase__ ,				lowerCamelCase__ =self.model_tester.prepare_config_and_inputs_for_common()

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

																lowerCamelCase__ =["pixel_values"]
																self.assertListEqual(arg_names[:1]     ,			_lowerCamelCase				)

				def 		_a     (				self				):
										lowerCamelCase__ =self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_model(*_lowerCamelCase				)

				def 		_a     (				self				):
										lowerCamelCase__ =self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_image_segmentation(*_lowerCamelCase				)

				def 		_a     (				self				):
										if not self.model_tester.is_training:
																return

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

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

																lowerCamelCase__ =model_class(_lowerCamelCase				)
																model.to(_lowerCamelCase				)
																model.train()
																lowerCamelCase__ =self._prepare_for_class(_lowerCamelCase     ,			_lowerCamelCase     ,			return_labels=_lowerCamelCase				)
																lowerCamelCase__ =model(**_lowerCamelCase				).loss
																loss.backward()

				def 		_a     (				self				):
										lowerCamelCase__ ,				lowerCamelCase__ =self.model_tester.prepare_config_and_inputs_for_common()
										if not self.model_tester.is_training:
																return

										lowerCamelCase__ =False
										lowerCamelCase__ =True

										for model_class in self.all_model_classes:
																if model_class in [*get_values(_lowerCamelCase				)] 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":
																						lowerCamelCase__ ,				lowerCamelCase__ ,				lowerCamelCase__ ,				lowerCamelCase__ =inputs_dict["pixel_values"].shape
																						lowerCamelCase__ =torch.zeros(
																						    [self.model_tester.batch_size, height, width]     ,			device=_lowerCamelCase				).long()
																lowerCamelCase__ =model_class(_lowerCamelCase				)
																model.gradient_checkpointing_enable()
																model.to(_lowerCamelCase				)
																model.train()
																lowerCamelCase__ =self._prepare_for_class(_lowerCamelCase     ,			_lowerCamelCase     ,			return_labels=_lowerCamelCase				)
																lowerCamelCase__ =model(**_lowerCamelCase				).loss
																loss.backward()

				def 		_a     (				self				):
										lowerCamelCase__ ,				lowerCamelCase__ =self.model_tester.prepare_config_and_inputs_for_common()

										lowerCamelCase__ =_config_zero_init(_lowerCamelCase				)
										for model_class in self.all_model_classes:
																lowerCamelCase__ =model_class(config=_lowerCamelCase				)
																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 		_a     (				self     ,			_lowerCamelCase     ,			_lowerCamelCase     ,			_lowerCamelCase     ,			_lowerCamelCase=2E-4     ,			_lowerCamelCase="outputs"     ,			_lowerCamelCase=None				):
										# We override with a slightly higher tol value, as semseg models tend to diverge a bit more
										super().check_pt_tf_outputs(_lowerCamelCase     ,			_lowerCamelCase     ,			_lowerCamelCase     ,			_lowerCamelCase     ,			_lowerCamelCase     ,			_lowerCamelCase				)

				def 		_a     (				self				):
										lowerCamelCase__ =self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_image_classification(*_lowerCamelCase				)






				@slow
				def 		_a     (				self				):
										for model_name in DATA2VEC_VISION_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																lowerCamelCase__ =DataaVecVisionModel.from_pretrained(_lowerCamelCase				)
																self.assertIsNotNone(_lowerCamelCase				)





def       lowerCamelCase_			( )							-> Optional[Any]:




						'''simple docstring'''



						lowerCamelCase__ =Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"    )
						return image






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

				@cached_property
				def 		_a     (				self				):
										return (
										    BeitImageProcessor.from_pretrained("facebook/data2vec-vision-base-ft1k"				) if is_vision_available() else None
										)






				@slow
				def 		_a     (				self				):
										lowerCamelCase__ =DataaVecVisionForImageClassification.from_pretrained("facebook/data2vec-vision-base-ft1k"				).to(
										    _lowerCamelCase				)

										lowerCamelCase__ =self.default_image_processor
										lowerCamelCase__ =prepare_img()
										lowerCamelCase__ =image_processor(images=_lowerCamelCase     ,			return_tensors="pt"				).to(_lowerCamelCase				)

										# forward pass
										with torch.no_grad():
																lowerCamelCase__ =model(**_lowerCamelCase				)
										lowerCamelCase__ =outputs.logits

										# verify the logits
										lowerCamelCase__ =torch.Size((1, 1000)				)
										self.assertEqual(logits.shape     ,			_lowerCamelCase				)

										lowerCamelCase__ =torch.tensor([0.3_2_7_7, -0.1_3_9_5, 0.0_9_1_1]				).to(_lowerCamelCase				)

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

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



"""simple docstring"""


from typing import TYPE_CHECKING

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


a							={
    'configuration_openai': ['OPENAI_GPT_PRETRAINED_CONFIG_ARCHIVE_MAP', 'OpenAIGPTConfig'],
    'tokenization_openai': ['OpenAIGPTTokenizer'],
}

try:
	if not is_tokenizers_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	a							=['OpenAIGPTTokenizerFast']

try:
	if not is_torch_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	a							=[
	    'OPENAI_GPT_PRETRAINED_MODEL_ARCHIVE_LIST',
	    'OpenAIGPTDoubleHeadsModel',
	    'OpenAIGPTForSequenceClassification',
	    'OpenAIGPTLMHeadModel',
	    'OpenAIGPTModel',
	    'OpenAIGPTPreTrainedModel',
	    'load_tf_weights_in_openai_gpt',
	]

try:
	if not is_tf_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	a							=[
	    'TF_OPENAI_GPT_PRETRAINED_MODEL_ARCHIVE_LIST',
	    'TFOpenAIGPTDoubleHeadsModel',
	    'TFOpenAIGPTForSequenceClassification',
	    'TFOpenAIGPTLMHeadModel',
	    'TFOpenAIGPTMainLayer',
	    'TFOpenAIGPTModel',
	    'TFOpenAIGPTPreTrainedModel',
	]


if TYPE_CHECKING:
	from .configuration_openai import OPENAI_GPT_PRETRAINED_CONFIG_ARCHIVE_MAP, OpenAIGPTConfig
	from .tokenization_openai import OpenAIGPTTokenizer

	try:
		if not is_tokenizers_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .tokenization_openai_fast import OpenAIGPTTokenizerFast

	try:
		if not is_torch_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .modeling_openai import (
		    OPENAI_GPT_PRETRAINED_MODEL_ARCHIVE_LIST,
		    OpenAIGPTDoubleHeadsModel,
		    OpenAIGPTForSequenceClassification,
		    OpenAIGPTLMHeadModel,
		    OpenAIGPTModel,
		    OpenAIGPTPreTrainedModel,
		    load_tf_weights_in_openai_gpt,
		)

	try:
		if not is_tf_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .modeling_tf_openai import (
		    TF_OPENAI_GPT_PRETRAINED_MODEL_ARCHIVE_LIST,
		    TFOpenAIGPTDoubleHeadsModel,
		    TFOpenAIGPTForSequenceClassification,
		    TFOpenAIGPTLMHeadModel,
		    TFOpenAIGPTMainLayer,
		    TFOpenAIGPTModel,
		    TFOpenAIGPTPreTrainedModel,
		)

else:
	import sys

	a							=_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)


