

'''simple docstring'''





from __future__ import annotations

import inspect
import unittest

import numpy as np

from transformers import ResNetConfig
from transformers.testing_utils import require_tf, require_vision, slow
from transformers.utils import cached_property, is_tf_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
				import tensorflow as tf

				from transformers import TFResNetForImageClassification, TFResNetModel
				from transformers.models.resnet.modeling_tf_resnet import TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
				from PIL import Image

				from transformers import AutoImageProcessor


class  UpperCAmelCase :

		'''simple docstring'''






		def __init__(					self   ,			SCREAMING_SNAKE_CASE_   ,			SCREAMING_SNAKE_CASE_=3   ,			SCREAMING_SNAKE_CASE_=32   ,			SCREAMING_SNAKE_CASE_=3   ,			SCREAMING_SNAKE_CASE_=10   ,			SCREAMING_SNAKE_CASE_=[10, 20, 30, 40]   ,			SCREAMING_SNAKE_CASE_=[1, 1, 2, 1]   ,			SCREAMING_SNAKE_CASE_=True   ,			SCREAMING_SNAKE_CASE_=True   ,			SCREAMING_SNAKE_CASE_="relu"   ,			SCREAMING_SNAKE_CASE_=3   ,			SCREAMING_SNAKE_CASE_=None   ,			)  ->     str:






							'''simple docstring'''



							lowerCamelCase_  				=      parent
							lowerCamelCase_  				=      batch_size
							lowerCamelCase_  				=      image_size
							lowerCamelCase_  				=      num_channels
							lowerCamelCase_  				=      embeddings_size
							lowerCamelCase_  				=      hidden_sizes
							lowerCamelCase_  				=      depths
							lowerCamelCase_  				=      is_training
							lowerCamelCase_  				=      use_labels
							lowerCamelCase_  				=      hidden_act
							lowerCamelCase_  				=      num_labels
							lowerCamelCase_  				=      scope
							lowerCamelCase_  				=      len(SCREAMING_SNAKE_CASE_		)
		def 			UpperCamelCase(					self		)  ->     Tuple:






							'''simple docstring'''



							lowerCamelCase_  				=      floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]		)

							lowerCamelCase_  				=      None
							if self.use_labels:
												lowerCamelCase_  				=      ids_tensor([self.batch_size]   ,			self.num_labels		)

							lowerCamelCase_  				=      self.get_config()

							return config, pixel_values, labels
		def 			UpperCamelCase(					self		)  ->     str:






							'''simple docstring'''



							return ResNetConfig(
							    num_channels=self.num_channels   ,			embeddings_size=self.embeddings_size   ,			hidden_sizes=self.hidden_sizes   ,			depths=self.depths   ,			hidden_act=self.hidden_act   ,			num_labels=self.num_labels   ,			image_size=self.image_size   ,			)
		def 			UpperCamelCase(					self   ,			SCREAMING_SNAKE_CASE_   ,			SCREAMING_SNAKE_CASE_   ,			SCREAMING_SNAKE_CASE_		)  ->     Tuple:






							'''simple docstring'''



							lowerCamelCase_  				=      TFResNetModel(config=SCREAMING_SNAKE_CASE_		)
							lowerCamelCase_  				=      model(SCREAMING_SNAKE_CASE_		)
							# expected last hidden states: B, C, H // 32, W // 32
							self.parent.assertEqual(
							    result.last_hidden_state.shape   ,			(self.batch_size, self.hidden_sizes[-1], self.image_size // 32, self.image_size // 32)   ,			)
		def 			UpperCamelCase(					self   ,			SCREAMING_SNAKE_CASE_   ,			SCREAMING_SNAKE_CASE_   ,			SCREAMING_SNAKE_CASE_		)  ->     List[Any]:






							'''simple docstring'''



							lowerCamelCase_  				=      self.num_labels
							lowerCamelCase_  				=      TFResNetForImageClassification(SCREAMING_SNAKE_CASE_		)
							lowerCamelCase_  				=      model(SCREAMING_SNAKE_CASE_   ,			labels=SCREAMING_SNAKE_CASE_		)
							self.parent.assertEqual(result.logits.shape   ,			(self.batch_size, self.num_labels)		)






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






							'''simple docstring'''



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


@require_tf
class  UpperCAmelCase (							UpperCAmelCase__  , UpperCAmelCase__  , unittest.TestCase    ):

		'''simple docstring'''






		SCREAMING_SNAKE_CASE_           =					(TFResNetModel, TFResNetForImageClassification) if is_tf_available() else ()
		SCREAMING_SNAKE_CASE_           =					(
		    {'feature-extraction': TFResNetModel, 'image-classification': TFResNetForImageClassification}
		    if is_tf_available()
		    else {}
		)

		SCREAMING_SNAKE_CASE_           =					False
		SCREAMING_SNAKE_CASE_           =					False
		SCREAMING_SNAKE_CASE_           =					False
		SCREAMING_SNAKE_CASE_           =					False
		SCREAMING_SNAKE_CASE_           =					False
		def 			UpperCamelCase(					self		)  ->     str:






							'''simple docstring'''



							lowerCamelCase_  				=      TFResNetModelTester(self		)
							lowerCamelCase_  				=      ConfigTester(self   ,			config_class=SCREAMING_SNAKE_CASE_   ,			has_text_modality=SCREAMING_SNAKE_CASE_		)
		def 			UpperCamelCase(					self		)  ->     Optional[Any]:






							'''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 			UpperCamelCase(					self		)  ->     Optional[Any]:






							'''simple docstring'''



							return
		@unittest.skip(reason='ResNet does not use inputs_embeds'		)
		def 			UpperCamelCase(					self		)  ->     str:






							'''simple docstring'''



							pass
		@unittest.skip(reason='ResNet does not support input and output embeddings'		)
		def 			UpperCamelCase(					self		)  ->     Union[str, Any]:






							'''simple docstring'''



							pass
		def 			UpperCamelCase(					self		)  ->     Tuple:






							'''simple docstring'''



							lowerCamelCase_				,lowerCamelCase_  				=      self.model_tester.prepare_config_and_inputs_for_common()

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

												lowerCamelCase_  				=      ['pixel_values']
												self.assertListEqual(arg_names[:1]   ,			SCREAMING_SNAKE_CASE_		)
		def 			UpperCamelCase(					self		)  ->     Optional[int]:






							'''simple docstring'''



							lowerCamelCase_  				=      self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_model(*SCREAMING_SNAKE_CASE_		)
		def 			UpperCamelCase(					self		)  ->     Any:






							'''simple docstring'''



							def check_hidden_states_output(SCREAMING_SNAKE_CASE_   ,			SCREAMING_SNAKE_CASE_   ,			SCREAMING_SNAKE_CASE_		):
												lowerCamelCase_  				=      model_class(SCREAMING_SNAKE_CASE_		)
												lowerCamelCase_  				=      model(**self._prepare_for_class(SCREAMING_SNAKE_CASE_   ,			SCREAMING_SNAKE_CASE_		)		)

												lowerCamelCase_  				=      outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

												lowerCamelCase_  				=      self.model_tester.num_stages
												self.assertEqual(len(SCREAMING_SNAKE_CASE_		)   ,			expected_num_stages + 1		)

												# ResNet's feature maps are of shape (batch_size, num_channels, height, width)
												self.assertListEqual(
												    list(hidden_states[0].shape[-2:]		)   ,			[self.model_tester.image_size // 4, self.model_tester.image_size // 4]   ,			)

							lowerCamelCase_				,lowerCamelCase_  				=      self.model_tester.prepare_config_and_inputs_for_common()
							lowerCamelCase_  				=      ['basic', 'bottleneck']
							for model_class in self.all_model_classes:
												for layer_type in layers_type:
																	lowerCamelCase_  				=      layer_type
																	lowerCamelCase_  				=      True
																	check_hidden_states_output(SCREAMING_SNAKE_CASE_   ,			SCREAMING_SNAKE_CASE_   ,			SCREAMING_SNAKE_CASE_		)

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

																	check_hidden_states_output(SCREAMING_SNAKE_CASE_   ,			SCREAMING_SNAKE_CASE_   ,			SCREAMING_SNAKE_CASE_		)
		def 			UpperCamelCase(					self		)  ->     Dict:






							'''simple docstring'''



							lowerCamelCase_  				=      self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_image_classification(*SCREAMING_SNAKE_CASE_		)






		@slow
		def 			UpperCamelCase(					self		)  ->     str:






							'''simple docstring'''



							for model_name in TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
												lowerCamelCase_  				=      TFResNetModel.from_pretrained(SCREAMING_SNAKE_CASE_		)
												self.assertIsNotNone(SCREAMING_SNAKE_CASE_		)







def   _UpperCamelCase	(		)       ->			Dict:
					lowerCamelCase_  				=      Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'	)
					return image







@require_tf
@require_vision
class  UpperCAmelCase (							unittest.TestCase    ):

		'''simple docstring'''






		@cached_property
		def 			UpperCamelCase(					self		)  ->     str:






							'''simple docstring'''



							return (
							    AutoImageProcessor.from_pretrained(TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]		)
							    if is_vision_available()
							    else None
							)






		@slow
		def 			UpperCamelCase(					self		)  ->     List[str]:






							'''simple docstring'''



							lowerCamelCase_  				=      TFResNetForImageClassification.from_pretrained(TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]		)

							lowerCamelCase_  				=      self.default_image_processor
							lowerCamelCase_  				=      prepare_img()
							lowerCamelCase_  				=      image_processor(images=SCREAMING_SNAKE_CASE_   ,			return_tensors='tf'		)

							# forward pass
							lowerCamelCase_  				=      model(**SCREAMING_SNAKE_CASE_		)

							# verify the logits
							lowerCamelCase_  				=      tf.TensorShape((1, 1000)		)
							self.assertEqual(outputs.logits.shape   ,			SCREAMING_SNAKE_CASE_		)

							lowerCamelCase_  				=      tf.constant([-11.1_069, -9.7_877, -8.3_777]		)

							self.assertTrue(np.allclose(outputs.logits[0, :3].numpy()   ,			SCREAMING_SNAKE_CASE_   ,			atol=1E-4		)		)







'''simple docstring'''

from typing import TYPE_CHECKING

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


lowerCamelCase				:  Tuple    		=      {
    'configuration_distilbert': [
        'DISTILBERT_PRETRAINED_CONFIG_ARCHIVE_MAP',
        'DistilBertConfig',
        'DistilBertOnnxConfig',
    ],
    'tokenization_distilbert': ['DistilBertTokenizer'],
}

try:
 if not is_tokenizers_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 lowerCamelCase				:  str    		=      ['DistilBertTokenizerFast']

try:
 if not is_torch_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 lowerCamelCase				:  List[str]    		=      [
     'DISTILBERT_PRETRAINED_MODEL_ARCHIVE_LIST',
     'DistilBertForMaskedLM',
     'DistilBertForMultipleChoice',
     'DistilBertForQuestionAnswering',
     'DistilBertForSequenceClassification',
     'DistilBertForTokenClassification',
     'DistilBertModel',
     'DistilBertPreTrainedModel',
 ]

try:
 if not is_tf_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 lowerCamelCase				:  Union[str, Any]    		=      [
     'TF_DISTILBERT_PRETRAINED_MODEL_ARCHIVE_LIST',
     'TFDistilBertForMaskedLM',
     'TFDistilBertForMultipleChoice',
     'TFDistilBertForQuestionAnswering',
     'TFDistilBertForSequenceClassification',
     'TFDistilBertForTokenClassification',
     'TFDistilBertMainLayer',
     'TFDistilBertModel',
     'TFDistilBertPreTrainedModel',
 ]

try:
 if not is_flax_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 lowerCamelCase				:  str    		=      [
     'FlaxDistilBertForMaskedLM',
     'FlaxDistilBertForMultipleChoice',
     'FlaxDistilBertForQuestionAnswering',
     'FlaxDistilBertForSequenceClassification',
     'FlaxDistilBertForTokenClassification',
     'FlaxDistilBertModel',
     'FlaxDistilBertPreTrainedModel',
 ]


if TYPE_CHECKING:
 from .configuration_distilbert import (
     DISTILBERT_PRETRAINED_CONFIG_ARCHIVE_MAP,
     DistilBertConfig,
     DistilBertOnnxConfig,
 )
 from .tokenization_distilbert import DistilBertTokenizer

 try:
  if not is_tokenizers_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .tokenization_distilbert_fast import DistilBertTokenizerFast

 try:
  if not is_torch_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_distilbert import (
      DISTILBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
      DistilBertForMaskedLM,
      DistilBertForMultipleChoice,
      DistilBertForQuestionAnswering,
      DistilBertForSequenceClassification,
      DistilBertForTokenClassification,
      DistilBertModel,
      DistilBertPreTrainedModel,
  )

 try:
  if not is_tf_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_tf_distilbert import (
      TF_DISTILBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
      TFDistilBertForMaskedLM,
      TFDistilBertForMultipleChoice,
      TFDistilBertForQuestionAnswering,
      TFDistilBertForSequenceClassification,
      TFDistilBertForTokenClassification,
      TFDistilBertMainLayer,
      TFDistilBertModel,
      TFDistilBertPreTrainedModel,
  )

 try:
  if not is_flax_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_flax_distilbert import (
      FlaxDistilBertForMaskedLM,
      FlaxDistilBertForMultipleChoice,
      FlaxDistilBertForQuestionAnswering,
      FlaxDistilBertForSequenceClassification,
      FlaxDistilBertForTokenClassification,
      FlaxDistilBertModel,
      FlaxDistilBertPreTrainedModel,
  )

else:
 import sys

 lowerCamelCase				:  int    		=      _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)




