





'''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 lowerCamelCase						:







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






        """simple docstring"""





        _snake_case		:	Union[str, Any]					     =     parent
        _snake_case		:	Optional[Any]					     =     batch_size
        _snake_case		:	Optional[Any]					     =     image_size
        _snake_case		:	Dict					     =     num_channels
        _snake_case		:	Optional[Any]					     =     embeddings_size
        _snake_case		:	List[Any]					     =     hidden_sizes
        _snake_case		:	List[str]					     =     depths
        _snake_case		:	str					     =     is_training
        _snake_case		:	int					     =     use_labels
        _snake_case		:	str					     =     hidden_act
        _snake_case		:	Optional[int]					     =     num_labels
        _snake_case		:	Any					     =     scope
        _snake_case		:	str					     =     len(_snake_case		)







  def 				UpperCAmelCase_				(		self		)		->						Any:






        """simple docstring"""





        _snake_case		:	Optional[int]					     =     floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]		)

        _snake_case		:	List[Any]					     =     None
        if self.use_labels:
              _snake_case		:	Optional[Any]					     =     ids_tensor([self.batch_size]     ,     self.num_labels		)

        _snake_case		:	Any					     =     self.get_config()

        return config, pixel_values, labels







  def 				UpperCAmelCase_				(		self		)		->						int:






        """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     ,     lowercase__     ,     lowercase__     ,     lowercase__		)		->						List[Any]:






        """simple docstring"""





        _snake_case		:	List[Any]					     =     TFResNetModel(config=_snake_case		)
        _snake_case		:	List[Any]					     =     model(_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     ,     lowercase__     ,     lowercase__     ,     lowercase__		)		->						List[Any]:






        """simple docstring"""





        _snake_case		:	Optional[int]					     =     self.num_labels
        _snake_case		:	List[str]					     =     TFResNetForImageClassification(_snake_case		)
        _snake_case		:	Optional[int]					     =     model(_snake_case     ,     labels=_snake_case		)
        self.parent.assertEqual(result.logits.shape     ,     (self.batch_size, self.num_labels)		)







  def 				UpperCAmelCase_				(		self		)		->						str:






        """simple docstring"""





        _snake_case		:	Dict					     =     self.prepare_config_and_inputs()
        _snake_case     ,							_snake_case     ,							_snake_case		:	str					     =     config_and_inputs
        _snake_case		:	Tuple					     =     {'''pixel_values''': pixel_values}
        return config, inputs_dict





@require_tf
class lowerCamelCase						(UpperCAmelCase_						,      UpperCAmelCase_						,      unittest.TestCase					):
  _lowercase  :	Dict       					=				(TFResNetModel, TFResNetForImageClassification) if is_tf_available() else ()
  _lowercase  :	List[str]       					=				(
      {"feature-extraction": TFResNetModel, "image-classification": TFResNetForImageClassification}
      if is_tf_available()
      else {}
  )

  _lowercase  :	Any       					=				False
  _lowercase  :	Dict       					=				False
  _lowercase  :	Optional[Any]       					=				False
  _lowercase  :	str       					=				False
  _lowercase  :	str       					=				False







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






        """simple docstring"""





        _snake_case		:	str					     =     TFResNetModelTester(self		)
        _snake_case		:	Optional[int]					     =     ConfigTester(self     ,     config_class=_snake_case     ,     has_text_modality=_snake_case		)







  def 				UpperCAmelCase_				(		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 				UpperCAmelCase_				(		self		)		->						List[str]:






        """simple docstring"""





        return







  @unittest.skip(reason='''ResNet does not use inputs_embeds'''		)
  def 				UpperCAmelCase_				(		self		)		->						Dict:






        """simple docstring"""





        pass







  @unittest.skip(reason='''ResNet does not support input and output embeddings'''		)
  def 				UpperCAmelCase_				(		self		)		->						Dict:






        """simple docstring"""





        pass







  def 				UpperCAmelCase_				(		self		)		->						str:






        """simple docstring"""





        _snake_case     ,							_snake_case		:	str					     =     self.model_tester.prepare_config_and_inputs_for_common()

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

              _snake_case		:	int					     =     ['''pixel_values''']
              self.assertListEqual(arg_names[:1]     ,     _snake_case		)







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






        """simple docstring"""





        _snake_case		:	Optional[Any]					     =     self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_model(*_snake_case		)







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






        """simple docstring"""





        def check_hidden_states_output(lowercase__     ,     lowercase__     ,     lowercase__		):
              _snake_case		:	Tuple					     =     model_class(_snake_case		)
              _snake_case		:	Dict					     =     model(**self._prepare_for_class(_snake_case     ,     _snake_case		)		)

              _snake_case		:	str					     =     outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

              _snake_case		:	Union[str, Any]					     =     self.model_tester.num_stages
              self.assertEqual(len(_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]     ,     )

        _snake_case     ,							_snake_case		:	List[Any]					     =     self.model_tester.prepare_config_and_inputs_for_common()
        _snake_case		:	int					     =     ['''basic''', '''bottleneck''']
        for model_class in self.all_model_classes:
              for layer_type in layers_type:
                    _snake_case		:	str					     =     layer_type
                    _snake_case		:	Dict					     =     True
                    check_hidden_states_output(_snake_case     ,     _snake_case     ,     _snake_case		)

                    # check that output_hidden_states also work using config
                    del inputs_dict["output_hidden_states"]
                    _snake_case		:	str					     =     True

                    check_hidden_states_output(_snake_case     ,     _snake_case     ,     _snake_case		)







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






        """simple docstring"""





        _snake_case		:	int					     =     self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_image_classification(*_snake_case		)







  @slow
  def 				UpperCAmelCase_				(		self		)		->						str:






        """simple docstring"""





        for model_name in TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
              _snake_case		:	List[str]					     =     TFResNetModel.from_pretrained(_snake_case		)
              self.assertIsNotNone(_snake_case		)




def    _a    (							):





      """simple docstring"""



      _snake_case		:	str					     =     Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''	)
      return image





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







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






        """simple docstring"""





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







  @slow
  def 				UpperCAmelCase_				(		self		)		->						List[Any]:






        """simple docstring"""





        _snake_case		:	Any					     =     TFResNetForImageClassification.from_pretrained(TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]		)

        _snake_case		:	Optional[int]					     =     self.default_image_processor
        _snake_case		:	int					     =     prepare_img()
        _snake_case		:	Optional[Any]					     =     image_processor(images=_snake_case     ,     return_tensors='''tf'''		)

        # forward pass
        _snake_case		:	Dict					     =     model(**_snake_case		)

        # verify the logits
        _snake_case		:	List[str]					     =     tf.TensorShape((1, 1_000)		)
        self.assertEqual(outputs.logits.shape     ,     _snake_case		)

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

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









'''simple docstring'''

import unittest

from transformers import is_flax_available
from transformers.testing_utils import require_flax, require_sentencepiece, require_tokenizers, require_torch, slow


if is_flax_available():
   import optax
   from flax.training.common_utils import onehot

   from transformers import AutoTokenizer, FlaxMTaForConditionalGeneration
   from transformers.models.ta.modeling_flax_ta import shift_tokens_right





@require_torch
@require_sentencepiece
@require_tokenizers
@require_flax
class lowerCamelCase						(unittest.TestCase					):







  @slow
  def 				UpperCAmelCase_				(		self		)		->						int:






        """simple docstring"""





        _snake_case		:	Tuple					     =     FlaxMTaForConditionalGeneration.from_pretrained('''google/mt5-small'''		)
        _snake_case		:	Any					     =     AutoTokenizer.from_pretrained('''google/mt5-small'''		)

        _snake_case		:	List[str]					     =     tokenizer('''Hello there'''     ,     return_tensors='''np'''		).input_ids
        _snake_case		:	Dict					     =     tokenizer('''Hi I am'''     ,     return_tensors='''np'''		).input_ids

        _snake_case		:	Any					     =     shift_tokens_right(lowercase__     ,     model.config.pad_token_id     ,     model.config.decoder_start_token_id		)

        _snake_case		:	Any					     =     model(lowercase__     ,     decoder_input_ids=lowercase__		).logits
        _snake_case		:	Tuple					     =     optax.softmax_cross_entropy(lowercase__     ,     onehot(lowercase__     ,     logits.shape[-1]		)		).mean()

        _snake_case		:	Tuple					     =     -(labels.shape[-1] * loss.item())

        _snake_case		:	Union[str, Any]					     =     -84.9_127
        self.assertTrue(abs(mtf_score - EXPECTED_SCORE		) < 1E-4		)


