"""simple docstring"""


from __future__ import annotations

import unittest

from transformers import BlenderbotConfig, BlenderbotTokenizer, is_tf_available
from transformers.testing_utils import require_tf, require_tokenizers, slow
from transformers.utils import cached_property

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


if is_tf_available():
    import tensorflow as tf

    from transformers import TFAutoModelForSeqaSeqLM, TFBlenderbotForConditionalGeneration, TFBlenderbotModel




@require_tf
class  UpperCamelCase					:
       SCREAMING_SNAKE_CASE_			=      BlenderbotConfig
       SCREAMING_SNAKE_CASE_			=      {}
       SCREAMING_SNAKE_CASE_			=      "gelu"







       def __init__( self,							lowerCAmelCase__,							lowerCAmelCase__=13,							lowerCAmelCase__=7,							lowerCAmelCase__=True,							lowerCAmelCase__=False,							lowerCAmelCase__=99,							lowerCAmelCase__=32,							lowerCAmelCase__=2,							lowerCAmelCase__=4,							lowerCAmelCase__=37,							lowerCAmelCase__=0.1,							lowerCAmelCase__=0.1,							lowerCAmelCase__=20,							lowerCAmelCase__=2,							lowerCAmelCase__=1,							lowerCAmelCase__=0,							)      ->      Optional[int]:
            snake_case_					       =					parent
            snake_case_					       =					batch_size
            snake_case_					       =					seq_length
            snake_case_					       =					is_training
            snake_case_					       =					use_labels
            snake_case_					       =					vocab_size
            snake_case_					       =					hidden_size
            snake_case_					       =					num_hidden_layers
            snake_case_					       =					num_attention_heads
            snake_case_					       =					intermediate_size

            snake_case_					       =					hidden_dropout_prob
            snake_case_					       =					attention_probs_dropout_prob
            snake_case_					       =					max_position_embeddings
            snake_case_					       =					eos_token_id
            snake_case_					       =					pad_token_id
            snake_case_					       =					bos_token_id







       def 		a_						( self)      ->      List[str]:
            snake_case_					       =					ids_tensor([self.batch_size, self.seq_length - 1],							self.vocab_size)
            snake_case_					       =					tf.expand_dims(tf.constant([self.eos_token_id] * self.batch_size),							1)
            snake_case_					       =					tf.concat([input_ids, eos_tensor],							axis=1)

            snake_case_					       =					ids_tensor([self.batch_size, self.seq_length],							self.vocab_size)

            snake_case_					       =					self.config_cls(
                vocab_size=self.vocab_size,							d_model=self.hidden_size,							encoder_layers=self.num_hidden_layers,							decoder_layers=self.num_hidden_layers,							encoder_attention_heads=self.num_attention_heads,							decoder_attention_heads=self.num_attention_heads,							encoder_ffn_dim=self.intermediate_size,							decoder_ffn_dim=self.intermediate_size,							dropout=self.hidden_dropout_prob,							attention_dropout=self.attention_probs_dropout_prob,							max_position_embeddings=self.max_position_embeddings,							eos_token_ids=[2],							bos_token_id=self.bos_token_id,							pad_token_id=self.pad_token_id,							decoder_start_token_id=self.pad_token_id,							**self.config_updates,							)
            snake_case_					       =					prepare_blenderbot_inputs_dict(lowerCAmelCase__,							lowerCAmelCase__,							lowerCAmelCase__)
            return config, inputs_dict







       def 		a_						( self,							lowerCAmelCase__,							lowerCAmelCase__)      ->      Dict:
            snake_case_					       =					TFBlenderbotModel(config=lowerCAmelCase__).get_decoder()
            snake_case_					       =					inputs_dict['input_ids']

            snake_case_					       =					input_ids[:1, :]
            snake_case_					       =					inputs_dict['attention_mask'][:1, :]
            snake_case_					       =					inputs_dict['head_mask']
            snake_case_					       =					1

            # first forward pass
            snake_case_					       =					model(lowerCAmelCase__,							attention_mask=lowerCAmelCase__,							head_mask=lowerCAmelCase__,							use_cache=lowerCAmelCase__)

            snake_case_       ,	snake_case_					       =					outputs.to_tuple()

            # create hypothetical next token and extent to next_input_ids
            snake_case_					       =					ids_tensor((self.batch_size, 3),							config.vocab_size)
            snake_case_					       =					tf.cast(ids_tensor((self.batch_size, 3),							2),							tf.inta)

            # append to next input_ids and
            snake_case_					       =					tf.concat([input_ids, next_tokens],							axis=-1)
            snake_case_					       =					tf.concat([attention_mask, next_attn_mask],							axis=-1)

            snake_case_					       =					model(lowerCAmelCase__,							attention_mask=lowerCAmelCase__)[0]
            snake_case_					       =					model(lowerCAmelCase__,							attention_mask=lowerCAmelCase__,							past_key_values=lowerCAmelCase__)[0]

            self.parent.assertEqual(next_tokens.shape[1],							output_from_past.shape[1])

            # select random slice
            snake_case_					       =					int(ids_tensor((1,),							output_from_past.shape[-1]))
            snake_case_					       =					output_from_no_past[:, -3:, random_slice_idx]
            snake_case_					       =					output_from_past[:, :, random_slice_idx]

            # test that outputs are equal for slice
            tf.debugging.assert_near(lowerCAmelCase__,							lowerCAmelCase__,							rtol=1e-3)







def 					UpperCAmelCase    (		UpperCAmelCase						,					UpperCAmelCase						,					UpperCAmelCase						,					UpperCAmelCase=None						,					UpperCAmelCase=None						,					UpperCAmelCase=None						,					UpperCAmelCase=None						,					UpperCAmelCase=None						,					)				->      Optional[Any]:
     if attention_mask is None:
          snake_case_					       =					tf.cast(tf.math.not_equal(UpperCAmelCase						,					config.pad_token_id					)						,					tf.inta					)
     if decoder_attention_mask is None:
          snake_case_					       =					tf.concat(
              [
                  tf.ones(decoder_input_ids[:, :1].shape						,					dtype=tf.inta					),
                  tf.cast(tf.math.not_equal(decoder_input_ids[:, 1:]						,					config.pad_token_id					)						,					tf.inta					),
              ]						,					axis=-1						,					)
     if head_mask is None:
          snake_case_					       =					tf.ones((config.encoder_layers, config.encoder_attention_heads)					)
     if decoder_head_mask is None:
          snake_case_					       =					tf.ones((config.decoder_layers, config.decoder_attention_heads)					)
     if cross_attn_head_mask is None:
          snake_case_					       =					tf.ones((config.decoder_layers, config.decoder_attention_heads)					)
     return {
         "input_ids": input_ids,
         "decoder_input_ids": decoder_input_ids,
         "attention_mask": attention_mask,
         "decoder_attention_mask": decoder_attention_mask,
         "head_mask": head_mask,
         "decoder_head_mask": decoder_head_mask,
         "cross_attn_head_mask": cross_attn_head_mask,
     }




@require_tf
class  UpperCamelCase					(				lowerCAmelCase__    ,		lowerCAmelCase__    ,		unittest.TestCase   ):
       SCREAMING_SNAKE_CASE_			=      (TFBlenderbotForConditionalGeneration, TFBlenderbotModel) if is_tf_available() else ()
       SCREAMING_SNAKE_CASE_			=      (TFBlenderbotForConditionalGeneration,) if is_tf_available() else ()
       SCREAMING_SNAKE_CASE_			=      (
           {
               "conversational": TFBlenderbotForConditionalGeneration,
               "feature-extraction": TFBlenderbotModel,
               "summarization": TFBlenderbotForConditionalGeneration,
               "text2text-generation": TFBlenderbotForConditionalGeneration,
               "translation": TFBlenderbotForConditionalGeneration,
           }
           if is_tf_available()
           else {}
       )
       SCREAMING_SNAKE_CASE_			=      True
       SCREAMING_SNAKE_CASE_			=      False
       SCREAMING_SNAKE_CASE_			=      False







       def 		a_						( self)      ->      Union[str, Any]:
            snake_case_					       =					TFBlenderbotModelTester(self)
            snake_case_					       =					ConfigTester(self,							config_class=lowerCAmelCase__)







       def 		a_						( self)      ->      Dict:
            self.config_tester.run_common_tests()







       def 		a_						( self)      ->      Tuple:
            snake_case_					       =					self.model_tester.prepare_config_and_inputs_for_common()
            self.model_tester.check_decoder_model_past_large_inputs(*lowerCAmelCase__)




@require_tokenizers
@require_tf
class  UpperCamelCase					(				unittest.TestCase   ):
       SCREAMING_SNAKE_CASE_			=      ["My friends are cool but they eat too many carbs."]
       SCREAMING_SNAKE_CASE_			=      "facebook/blenderbot-400M-distill"







       @cached_property
       def 		a_						( self)      ->      Union[str, Any]:
            return BlenderbotTokenizer.from_pretrained(self.model_name)







       @cached_property
       def 		a_						( self)      ->      Union[str, Any]:
            snake_case_					       =					TFAutoModelForSeqaSeqLM.from_pretrained(self.model_name)
            return model







       @slow
       def 		a_						( self)      ->      Dict:
            snake_case_					       =					self.tokenizer(self.src_text,							return_tensors='tf')
            snake_case_					       =					self.model.generate(
                model_inputs.input_ids,							)
            snake_case_					       =					self.tokenizer.batch_decode(generated_ids.numpy(),							skip_special_tokens=lowerCAmelCase__)[0]
            assert (
                generated_words
                == " That's unfortunate. Are they trying to lose weight or are they just trying to be healthier?"
            )








import inspect
import unittest

from transformers import ConvNextConfig
from transformers.testing_utils import 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, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
    import torch

    from transformers import ConvNextBackbone, ConvNextForImageClassification, ConvNextModel
    from transformers.models.convnext.modeling_convnext import CONVNEXT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
    from PIL import Image

    from transformers import AutoImageProcessor

class 		SCREAMING_SNAKE_CASE__				:


      def __init__(self       :      Any				,			a__       :      List[Any]				,			a__       :      Dict=13				,			a__       :      str=32				,			a__       :      Tuple=3				,			a__       :      Optional[Any]=4				,			a__       :      Optional[int]=[10, 20, 30, 40]				,			a__       :      List[Any]=[2, 2, 3, 2]				,			a__       :      List[Any]=True				,			a__       :      int=True				,			a__       :      List[Any]=37				,			a__       :      Any="gelu"				,			a__       :      int=10				,			a__       :      Dict=0.0_2				,			a__       :      Dict=["stage2", "stage3", "stage4"]				,			a__       :      Tuple=[2, 3, 4]				,			a__       :      List[str]=None				,			):





         """simple docstring"""



         __snake_case							       =   parent
         __snake_case							       =   batch_size
         __snake_case							       =   image_size
         __snake_case							       =   num_channels
         __snake_case							       =   num_stages
         __snake_case							       =   hidden_sizes
         __snake_case							       =   depths
         __snake_case							       =   is_training
         __snake_case							       =   use_labels
         __snake_case							       =   intermediate_size
         __snake_case							       =   hidden_act
         __snake_case							       =   num_labels
         __snake_case							       =   initializer_range
         __snake_case							       =   out_features
         __snake_case							       =   out_indices
         __snake_case							       =   scope


      def    a (self       :      Dict      ):





         """simple docstring"""



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

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

         __snake_case							       =   self.get_config()
         return config, pixel_values, labels


      def    a (self       :      List[str]      ):





         """simple docstring"""



         return ConvNextConfig(
             num_channels=self.num_channels				,			hidden_sizes=self.hidden_sizes				,			depths=self.depths				,			num_stages=self.num_stages				,			hidden_act=self.hidden_act				,			is_decoder=a__				,			initializer_range=self.initializer_range				,			out_features=self.out_features				,			out_indices=self.out_indices				,			num_labels=self.num_labels				,			)


      def    a (self       :      str				,			a__       :      Union[str, Any]				,			a__       :      List[str]				,			a__       :      List[Any]      ):





         """simple docstring"""



         __snake_case							       =   ConvNextModel(config=a__      )
         model.to(a__      )
         model.eval()
         __snake_case							       =   model(a__      )
         # 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    a (self       :      Optional[Any]				,			a__       :      List[Any]				,			a__       :      str				,			a__       :      List[Any]      ):





         """simple docstring"""



         __snake_case							       =   ConvNextForImageClassification(a__      )
         model.to(a__      )
         model.eval()
         __snake_case							       =   model(a__				,			labels=a__      )
         self.parent.assertEqual(result.logits.shape				,			(self.batch_size, self.num_labels)      )


      def    a (self       :      Tuple				,			a__       :      List[Any]				,			a__       :      List[str]				,			a__       :      List[str]      ):





         """simple docstring"""



         __snake_case							       =   ConvNextBackbone(config=a__      )
         model.to(a__      )
         model.eval()
         __snake_case							       =   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, self.hidden_sizes[1], 4, 4]      )

         # verify channels
         self.parent.assertEqual(len(model.channels      )				,			len(config.out_features      )      )
         self.parent.assertListEqual(model.channels				,			config.hidden_sizes[1:]      )

         # verify backbone works with out_features=None
         __snake_case							       =   None
         __snake_case							       =   ConvNextBackbone(config=a__      )
         model.to(a__      )
         model.eval()
         __snake_case							       =   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, self.hidden_sizes[-1], 1, 1]      )

         # verify channels
         self.parent.assertEqual(len(model.channels      )				,			1      )
         self.parent.assertListEqual(model.channels				,			[config.hidden_sizes[-1]]      )


      def    a (self       :      Tuple      ):





         """simple docstring"""



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






@require_torch
class 		SCREAMING_SNAKE_CASE__				(       _UpperCAmelCase						,      _UpperCAmelCase						,      unittest.TestCase  ):
      A_						:				Dict							=    (
          (
              ConvNextModel,
              ConvNextForImageClassification,
              ConvNextBackbone,
          )
          if is_torch_available()
          else ()
      )
      A_						:				Optional[Any]							=    (
          {'feature-extraction': ConvNextModel, 'image-classification': ConvNextForImageClassification}
          if is_torch_available()
          else {}
      )

      A_						:				Dict							=    True
      A_						:				Optional[Any]							=    False
      A_						:				int							=    False
      A_						:				int							=    False
      A_						:				List[str]							=    False


      def    a (self       :      List[str]      ):





         """simple docstring"""



         __snake_case							       =   ConvNextModelTester(self      )
         __snake_case							       =   ConfigTester(self				,			config_class=a__				,			has_text_modality=a__				,			hidden_size=37      )


      def    a (self       :      Tuple      ):





         """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    a (self       :      str      ):





         """simple docstring"""



         return


      @unittest.skip(reason='''ConvNext does not use inputs_embeds'''      )
      def    a (self       :      int      ):





         """simple docstring"""



         pass


      @unittest.skip(reason='''ConvNext does not support input and output embeddings'''      )
      def    a (self       :      Dict      ):





         """simple docstring"""



         pass


      @unittest.skip(reason='''ConvNext does not use feedforward chunking'''      )
      def    a (self       :      List[Any]      ):





         """simple docstring"""



         pass


      def    a (self       :      Optional[Any]      ):





         """simple docstring"""



         __snake_case       ,	__snake_case							       =   self.model_tester.prepare_config_and_inputs_for_common()

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

            __snake_case							       =   ['''pixel_values''']
            self.assertListEqual(arg_names[:1]				,			a__      )


      def    a (self       :      List[Any]      ):





         """simple docstring"""



         __snake_case							       =   self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*a__      )


      def    a (self       :      Dict      ):





         """simple docstring"""



         __snake_case							       =   self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_backbone(*a__      )


      def    a (self       :      Dict      ):





         """simple docstring"""



         def check_hidden_states_output(a__       :      List[str]				,			a__       :      str				,			a__       :      Tuple      ):
            __snake_case							       =   model_class(a__      )
            model.to(a__      )
            model.eval()

            with torch.no_grad():
               __snake_case							       =   model(**self._prepare_for_class(a__				,			a__      )      )

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

            __snake_case							       =   self.model_tester.num_stages
            self.assertEqual(len(a__      )				,			expected_num_stages + 1      )

            # ConvNext'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							       =   self.model_tester.prepare_config_and_inputs_for_common()

         for model_class in self.all_model_classes:
            __snake_case							       =   True
            check_hidden_states_output(a__				,			a__				,			a__      )

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

            check_hidden_states_output(a__				,			a__				,			a__      )


      def    a (self       :      Optional[Any]      ):





         """simple docstring"""



         __snake_case							       =   self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_image_classification(*a__      )


      @slow
      def    a (self       :      Any      ):





         """simple docstring"""



         for model_name in CONVNEXT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
            __snake_case							       =   ConvNextModel.from_pretrained(a__      )
            self.assertIsNotNone(a__      )






def lowerCamelCase__    (							)      ->				List[str]:
   __snake_case							       =   Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''       )
   return image

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


      @cached_property
      def    a (self       :      Tuple      ):





         """simple docstring"""



         return AutoImageProcessor.from_pretrained('''facebook/convnext-tiny-224'''      ) if is_vision_available() else None


      @slow
      def    a (self       :      Optional[Any]      ):





         """simple docstring"""



         __snake_case							       =   ConvNextForImageClassification.from_pretrained('''facebook/convnext-tiny-224'''      ).to(a__      )

         __snake_case							       =   self.default_image_processor
         __snake_case							       =   prepare_img()
         __snake_case							       =   image_processor(images=a__				,			return_tensors='''pt'''      ).to(a__      )

         # forward pass
         with torch.no_grad():
            __snake_case							       =   model(**a__      )

         # verify the logits
         __snake_case							       =   torch.Size((1, 1000)      )
         self.assertEqual(outputs.logits.shape				,			a__      )

         __snake_case							       =   torch.tensor([-0.0_2_6_0, -0.4_7_3_9, 0.1_9_1_1]      ).to(a__      )

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






@require_torch
class 		SCREAMING_SNAKE_CASE__				(       unittest.TestCase						,      _UpperCAmelCase  ):
      A_						:				Union[str, Any]							=    (ConvNextBackbone,) if is_torch_available() else ()
      A_						:				List[Any]							=    ConvNextConfig

      A_						:				Optional[Any]							=    False


      def    a (self       :      Optional[int]      ):





         """simple docstring"""



         __snake_case							       =   ConvNextModelTester(self      )

