code: 
  
  
  import collections
  import inspect
  import unittest
  
  from transformers import DinatConfig
  from transformers.testing_utils import require_natten, 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 DinatBackbone, DinatForImageClassification, DinatModel
  		from transformers.models.dinat.modeling_dinat import DINAT_PRETRAINED_MODEL_ARCHIVE_LIST
  
  if is_vision_available():
  		from PIL import Image
  
  		from transformers import AutoImageProcessor
  
  
  
  
  class 					_UpperCamelCase :
  
  
  
  
  
  
  
  							'''simple docstring'''
  
  
  
  
  
  
  
  							def __init__(		self  :				Dict		,				SCREAMING_SNAKE_CASE_  :				Optional[Any]		,				SCREAMING_SNAKE_CASE_  :				List[str]=1_3		,				SCREAMING_SNAKE_CASE_  :				List[str]=6_4		,				SCREAMING_SNAKE_CASE_  :				Union[str, Any]=4		,				SCREAMING_SNAKE_CASE_  :				Any=3		,				SCREAMING_SNAKE_CASE_  :				Optional[Any]=1_6		,				SCREAMING_SNAKE_CASE_  :				Optional[int]=[1, 2, 1]		,				SCREAMING_SNAKE_CASE_  :				List[str]=[2, 4, 8]		,				SCREAMING_SNAKE_CASE_  :				Union[str, Any]=3		,				SCREAMING_SNAKE_CASE_  :				Any=[[3], [1, 2], [1]]		,				SCREAMING_SNAKE_CASE_  :				Any=2.0		,				SCREAMING_SNAKE_CASE_  :				Union[str, Any]=True		,				SCREAMING_SNAKE_CASE_  :				Any=0.0		,				SCREAMING_SNAKE_CASE_  :				Dict=0.0		,				SCREAMING_SNAKE_CASE_  :				List[str]=0.1		,				SCREAMING_SNAKE_CASE_  :				Optional[int]="gelu"		,				SCREAMING_SNAKE_CASE_  :				List[Any]=True		,				SCREAMING_SNAKE_CASE_  :				List[Any]=0.02		,				SCREAMING_SNAKE_CASE_  :				Dict=1e-5		,				SCREAMING_SNAKE_CASE_  :				Union[str, Any]=True		,				SCREAMING_SNAKE_CASE_  :				str=None		,				SCREAMING_SNAKE_CASE_  :				Tuple=True		,				SCREAMING_SNAKE_CASE_  :				Tuple=1_0		,				SCREAMING_SNAKE_CASE_  :				int=["stage1", "stage2"]		,				SCREAMING_SNAKE_CASE_  :				str=[1, 2]		,				):
  													_a     =			parent
  													_a     =			batch_size
  													_a     =			image_size
  													_a     =			patch_size
  													_a     =			num_channels
  													_a     =			embed_dim
  													_a     =			depths
  													_a     =			num_heads
  													_a     =			kernel_size
  													_a     =			dilations
  													_a     =			mlp_ratio
  													_a     =			qkv_bias
  													_a     =			hidden_dropout_prob
  													_a     =			attention_probs_dropout_prob
  													_a     =			drop_path_rate
  													_a     =			hidden_act
  													_a     =			patch_norm
  													_a     =			layer_norm_eps
  													_a     =			initializer_range
  													_a     =			is_training
  													_a     =			scope
  													_a     =			use_labels
  													_a     =			num_labels
  													_a     =			out_features
  													_a     =			out_indices
  
  
  
  
  
  
  
  							def 		_UpperCAmelCase	(		self  :				int		):
  													_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.num_labels		)
  
  													_a     =			self.get_config()
  
  													return config, pixel_values, labels
  
  
  
  
  
  
  
  							def 		_UpperCAmelCase	(		self  :				Dict		):
  													return DinatConfig(
  													    num_labels=self.num_labels		,				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		,				kernel_size=self.kernel_size		,				dilations=self.dilations		,				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		,				patch_norm=self.patch_norm		,				layer_norm_eps=self.layer_norm_eps		,				initializer_range=self.initializer_range		,				out_features=self.out_features		,				out_indices=self.out_indices		,				)
  
  
  
  
  
  
  
  							def 		_UpperCAmelCase	(		self  :				str		,				SCREAMING_SNAKE_CASE_  :				int		,				SCREAMING_SNAKE_CASE_  :				List[Any]		,				SCREAMING_SNAKE_CASE_  :				Union[str, Any]		):
  													_a     =			DinatModel(config=a_		)
  													model.to(a_		)
  													model.eval()
  													_a     =			model(a_		)
  
  													_a     =			_a     =			(config.image_size // config.patch_size) // (2 ** (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_height, expected_width, expected_dim)		)
  
  
  
  
  
  
  
  							def 		_UpperCAmelCase	(		self  :				str		,				SCREAMING_SNAKE_CASE_  :				Tuple		,				SCREAMING_SNAKE_CASE_  :				int		,				SCREAMING_SNAKE_CASE_  :				Optional[int]		):
  													_a     =			DinatForImageClassification(a_		)
  													model.to(a_		)
  													model.eval()
  													_a     =			model(a_		,				labels=a_		)
  													self.parent.assertEqual(result.logits.shape		,				(self.batch_size, self.num_labels)		)
  
  													# test greyscale images
  													_a     =			1
  													_a     =			DinatForImageClassification(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.num_labels)		)
  
  
  
  
  
  
  
  							def 		_UpperCAmelCase	(		self  :				Optional[Any]		,				SCREAMING_SNAKE_CASE_  :				str		,				SCREAMING_SNAKE_CASE_  :				str		,				SCREAMING_SNAKE_CASE_  :				Tuple		):
  													_a     =			DinatBackbone(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     =			DinatBackbone(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 		_UpperCAmelCase	(		self  :				Optional[Any]		):
  													_a     =			self.prepare_config_and_inputs()
  													_a ,	_a ,	_a     =			config_and_inputs
  													_a     =			{'pixel_values': pixel_values}
  													return config, inputs_dict
  
  
  
  
  @require_natten
  @require_torch
  class 					_UpperCamelCase (      lowerCamelCase__			,							lowerCamelCase__			,							unittest.TestCase	):
  
  
  
  
  
  
  
  							'''simple docstring'''
  							_A  				=  (
  							    (
  							        DinatModel,
  							        DinatForImageClassification,
  							        DinatBackbone,
  							    )
  							    if is_torch_available()
  							    else ()
  							)
  							_A  				=  (
  							    {'''feature-extraction''': DinatModel, '''image-classification''': DinatForImageClassification}
  							    if is_torch_available()
  							    else {}
  							)
  							_A  				=  False
  
  							_A  				=  False
  							_A  				=  False
  							_A  				=  False
  							_A  				=  False
  
  
  
  
  
  
  
  							def 		_UpperCAmelCase	(		self  :				int		):
  													_a     =			DinatModelTester(self		)
  													_a     =			ConfigTester(self		,				config_class=a_		,				embed_dim=3_7		)
  
  
  
  
  
  
  
  							def 		_UpperCAmelCase	(		self  :				Tuple		):
  													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 		_UpperCAmelCase	(		self  :				List[str]		):
  													return
  
  
  
  
  
  
  
  							def 		_UpperCAmelCase	(		self  :				Optional[int]		):
  													_a     =			self.model_tester.prepare_config_and_inputs()
  													self.model_tester.create_and_check_model(*a_		)
  
  
  
  
  
  
  
  							def 		_UpperCAmelCase	(		self  :				Any		):
  													_a     =			self.model_tester.prepare_config_and_inputs()
  													self.model_tester.create_and_check_for_image_classification(*a_		)
  
  
  
  
  
  
  
  							def 		_UpperCAmelCase	(		self  :				List[Any]		):
  													_a     =			self.model_tester.prepare_config_and_inputs()
  													self.model_tester.create_and_check_backbone(*a_		)
  
  
  
  
  
  
  
  							@unittest.skip(reason='Dinat does not use inputs_embeds'		)
  							def 		_UpperCAmelCase	(		self  :				Any		):
  													pass
  
  
  
  
  
  
  
  							@unittest.skip(reason='Dinat does not use feedforward chunking'		)
  							def 		_UpperCAmelCase	(		self  :				int		):
  													pass
  
  
  
  
  
  
  
  							def 		_UpperCAmelCase	(		self  :				int		):
  													_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 		_UpperCAmelCase	(		self  :				Union[str, Any]		):
  													_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 		_UpperCAmelCase	(		self  :				int		):
  													self.skipTest('Dinat\'s attention operation is handled entirely by NATTEN.'		)
  
  
  
  
  
  
  
  							def 		_UpperCAmelCase	(		self  :				str		,				SCREAMING_SNAKE_CASE_  :				Union[str, Any]		,				SCREAMING_SNAKE_CASE_  :				str		,				SCREAMING_SNAKE_CASE_  :				List[Any]		,				SCREAMING_SNAKE_CASE_  :				Union[str, Any]		):
  													_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_		)
  
  													# Dinat 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[0] // patch_size[0]
  													_a     =			image_size[1] // patch_size[1]
  
  													self.assertListEqual(
  													    list(hidden_states[0].shape[-3:]		)		,				[height, width, self.model_tester.embed_dim]		,				)
  
  													if model_class.__name__ != "DinatBackbone":
  																			_a     =			outputs.reshaped_hidden_states
  																			self.assertEqual(len(a_		)		,				a_		)
  
  																			_a ,	_a ,	_a ,	_a     =			reshaped_hidden_states[0].shape
  																			_a     =			(
  																			    reshaped_hidden_states[0].view(a_		,				a_		,				a_		,				a_		).permute(0		,				2		,				3		,				1		)
  																			)
  																			self.assertListEqual(
  																			    list(reshaped_hidden_states.shape[-3:]		)		,				[height, width, self.model_tester.embed_dim]		,				)
  
  
  
  
  
  
  
  							def 		_UpperCAmelCase	(		self  :				Tuple		):
  													_a ,	_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_		)
  
  
  
  
  
  
  
  							@slow
  							def 		_UpperCAmelCase	(		self  :				Any		):
  													for model_name in DINAT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
  																			_a     =			DinatModel.from_pretrained(a_		)
  																			self.assertIsNotNone(a_		)
  
  
  
  
  
  
  
  							def 		_UpperCAmelCase	(		self  :				Any		):
  													_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():
  																									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_natten
  @require_vision
  @require_torch
  class 					_UpperCamelCase (      unittest.TestCase	):
  
  
  
  
  
  
  
  							'''simple docstring'''
  
  
  
  
  
  
  
  							@cached_property
  							def 		_UpperCAmelCase	(		self  :				Optional[int]		):
  													return AutoImageProcessor.from_pretrained('shi-labs/dinat-mini-in1k-224'		) if is_vision_available() else None
  
  
  
  
  
  
  
  							@slow
  							def 		_UpperCAmelCase	(		self  :				Dict		):
  													_a     =			DinatForImageClassification.from_pretrained('shi-labs/dinat-mini-in1k-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.1545, -0.7667, 0.4642]		).to(a_		)
  													self.assertTrue(torch.allclose(outputs.logits[0, :3]		,				a_		,				atol=1e-4		)		)
  
  
  
  
  @require_torch
  @require_natten
  class 					_UpperCamelCase (      unittest.TestCase			,							lowerCamelCase__	):
  
  
  
  
  
  
  
  							'''simple docstring'''
  							_A  				=  (DinatBackbone,) if is_torch_available() else ()
  							_A  				=  DinatConfig
  
  
  
  
  
  
  
  							def 		_UpperCAmelCase	(		self  :				Dict		):
  													_a     =			DinatModelTester(self		)
  
style_context: 
  
  
  from typing import TYPE_CHECKING
  
  from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tokenizers_available, is_torch_available
  
  
  lowercase_								=    {
      'configuration_codegen': ['CODEGEN_PRETRAINED_CONFIG_ARCHIVE_MAP', 'CodeGenConfig', 'CodeGenOnnxConfig'],
      'tokenization_codegen': ['CodeGenTokenizer'],
  }
  
  try:
  		if not is_tokenizers_available():
  				raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
  		pass
  else:
  		lowercase_								=    ['CodeGenTokenizerFast']
  
  try:
  		if not is_torch_available():
  				raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
  		pass
  else:
  		lowercase_								=    [
  		    'CODEGEN_PRETRAINED_MODEL_ARCHIVE_LIST',
  		    'CodeGenForCausalLM',
  		    'CodeGenModel',
  		    'CodeGenPreTrainedModel',
  		]
  
  if TYPE_CHECKING:
  		from .configuration_codegen import CODEGEN_PRETRAINED_CONFIG_ARCHIVE_MAP, CodeGenConfig, CodeGenOnnxConfig
  		from .tokenization_codegen import CodeGenTokenizer
  
  		try:
  				if not is_tokenizers_available():
  						raise OptionalDependencyNotAvailable()
  		except OptionalDependencyNotAvailable:
  				pass
  		else:
  				from .tokenization_codegen_fast import CodeGenTokenizerFast
  
  		try:
  				if not is_torch_available():
  						raise OptionalDependencyNotAvailable()
  		except OptionalDependencyNotAvailable:
  				pass
  		else:
  				from .modeling_codegen import (
  				    CODEGEN_PRETRAINED_MODEL_ARCHIVE_LIST,
  				    CodeGenForCausalLM,
  				    CodeGenModel,
  				    CodeGenPreTrainedModel,
  				)
  
  else:
  		import sys
  
  		lowercase_								=    _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)
  
  
  