





from __future__ import annotations

import unittest

from transformers import BlenderbotSmallConfig, BlenderbotSmallTokenizer, 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, TFBlenderbotSmallForConditionalGeneration, TFBlenderbotSmallModel

@require_tf
class 		SCREAMING_SNAKE_CASE__				:
      A_						:				List[Any]							=    BlenderbotSmallConfig
      A_						:				Tuple							=    {}
      A_						:				Optional[Any]							=    'gelu'


      def __init__(self       :      List[str]				,			a__       :      List[str]				,			a__       :      Union[str, Any]=13				,			a__       :      str=7				,			a__       :      Dict=True				,			a__       :      Any=False				,			a__       :      str=99				,			a__       :      Dict=32				,			a__       :      Any=2				,			a__       :      Any=4				,			a__       :      List[str]=37				,			a__       :      Dict=0.1				,			a__       :      List[Any]=0.1				,			a__       :      Optional[Any]=20				,			a__       :      Tuple=2				,			a__       :      int=1				,			a__       :      Dict=0				,			):





         """simple docstring"""



         __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[Any]      ):





         """simple docstring"""



         __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_small_inputs_dict(a__				,			a__				,			a__      )
         return config, inputs_dict


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





         """simple docstring"""



         __snake_case							       =   TFBlenderbotSmallModel(config=a__      ).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(a__				,			attention_mask=a__				,			head_mask=a__				,			use_cache=a__      )

         __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(a__				,			attention_mask=a__      )[0]
         __snake_case							       =   model(a__				,			attention_mask=a__				,			past_key_values=a__      )[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(a__				,			a__				,			rtol=1E-3      )






def lowerCamelCase__    (							snake_case_	:  Tuple       ,      snake_case_	:  Tuple       ,      snake_case_	:  Optional[Any]       ,      snake_case_	:  List[Any]=None       ,      snake_case_	:  str=None       ,      snake_case_	:  Optional[Any]=None       ,      snake_case_	:  List[Any]=None       ,      snake_case_	:  Tuple=None       ,      )      ->				Union[str, Any]:
   if attention_mask is None:
      __snake_case							       =   tf.cast(tf.math.not_equal(snake_case_       ,      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 		SCREAMING_SNAKE_CASE__				(       _UpperCAmelCase						,      _UpperCAmelCase						,      unittest.TestCase  ):
      A_						:				int							=    (
          (TFBlenderbotSmallForConditionalGeneration, TFBlenderbotSmallModel) if is_tf_available() else ()
      )
      A_						:				List[Any]							=    (TFBlenderbotSmallForConditionalGeneration,) if is_tf_available() else ()
      A_						:				str							=    (
          {
              'conversational': TFBlenderbotSmallForConditionalGeneration,
              'feature-extraction': TFBlenderbotSmallModel,
              'summarization': TFBlenderbotSmallForConditionalGeneration,
              'text2text-generation': TFBlenderbotSmallForConditionalGeneration,
              'translation': TFBlenderbotSmallForConditionalGeneration,
          }
          if is_tf_available()
          else {}
      )
      A_						:				str							=    True
      A_						:				Optional[int]							=    False
      A_						:				List[str]							=    False


      def    a (self       :      Any      ):





         """simple docstring"""



         __snake_case							       =   TFBlenderbotSmallModelTester(self      )
         __snake_case							       =   ConfigTester(self				,			config_class=a__      )


      def    a (self       :      List[str]      ):





         """simple docstring"""



         self.config_tester.run_common_tests()


      def    a (self       :      Dict      ):





         """simple docstring"""



         __snake_case							       =   self.model_tester.prepare_config_and_inputs_for_common()
         self.model_tester.check_decoder_model_past_large_inputs(*a__      )






@require_tokenizers
@require_tf
class 		SCREAMING_SNAKE_CASE__				(       unittest.TestCase  ):
      A_						:				Tuple							=    [
          'Social anxiety\nWow, I am never shy. Do you have anxiety?\nYes. I end up sweating and blushing and feel like '
          '  i\'m going to throw up.\nand why is that?'
      ]
      A_						:				str							=    'facebook/blenderbot_small-90M'


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





         """simple docstring"""



         return BlenderbotSmallTokenizer.from_pretrained('''facebook/blenderbot-90M'''      )


      @cached_property
      def    a (self       :      Any      ):





         """simple docstring"""



         __snake_case							       =   TFAutoModelForSeqaSeqLM.from_pretrained(self.model_name      )
         return model


      @slow
      def    a (self       :      Union[str, Any]      ):





         """simple docstring"""



         __snake_case							       =   self.tokenizer(self.src_text				,			return_tensors='''tf'''      )
         __snake_case							       =   self.model.generate(
             model_inputs.input_ids				,			attention_mask=model_inputs.attention_mask				,			num_beams=2				,			use_cache=a__				,			)
         __snake_case							       =   self.tokenizer.batch_decode(generated_ids.numpy()				,			skip_special_tokens=a__      )[0]
         assert generated_words in (
             "i don't know. i just feel like i'm going to throw up. it's not fun.",
             "i'm not sure. i just feel like i've been feeling like i have to be in a certain place",
             "i'm not sure. i just feel like i've been in a bad situation.",
         )








import copy
import inspect
import unittest

from transformers import AutoBackbone
from transformers.configuration_utils import PretrainedConfig
from transformers.testing_utils import require_timm, require_torch, torch_device
from transformers.utils.import_utils import is_torch_available

from ...test_backbone_common import BackboneTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor


if is_torch_available():
    import torch

    from transformers import TimmBackbone, TimmBackboneConfig

from ...test_pipeline_mixin import PipelineTesterMixin

class 		SCREAMING_SNAKE_CASE__				:


      def __init__(self       :      str				,			a__       :      Dict				,			a__       :      Tuple=None				,			a__       :      List[Any]=None				,			a__       :      Dict=None				,			a__       :      Union[str, Any]="resnet50"				,			a__       :      Dict=3				,			a__       :      str=32				,			a__       :      int=3				,			a__       :      Dict=True				,			a__       :      Any=True				,			):





         """simple docstring"""



         __snake_case							       =   parent
         __snake_case							       =   out_indices if out_indices is not None else [4]
         __snake_case							       =   stage_names
         __snake_case							       =   out_features
         __snake_case							       =   backbone
         __snake_case							       =   batch_size
         __snake_case							       =   image_size
         __snake_case							       =   num_channels
         __snake_case							       =   use_pretrained_backbone
         __snake_case							       =   is_training


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





         """simple docstring"""



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

         return config, pixel_values


      def    a (self       :      Any      ):





         """simple docstring"""



         return TimmBackboneConfig(
             image_size=self.image_size				,			num_channels=self.num_channels				,			out_features=self.out_features				,			out_indices=self.out_indices				,			stage_names=self.stage_names				,			use_pretrained_backbone=self.use_pretrained_backbone				,			backbone=self.backbone				,			)


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





         """simple docstring"""



         __snake_case							       =   TimmBackbone(config=a__      )
         model.to(a__      )
         model.eval()
         with torch.no_grad():
            __snake_case							       =   model(a__      )
         self.parent.assertEqual(
             result.feature_map[-1].shape				,			(self.batch_size, model.channels[-1], 14, 14)				,			)


      def    a (self       :      str      ):





         """simple docstring"""



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






@require_torch
@require_timm
class 		SCREAMING_SNAKE_CASE__				(       _UpperCAmelCase						,      _UpperCAmelCase						,      _UpperCAmelCase						,      unittest.TestCase  ):
      A_						:				Union[str, Any]							=    (TimmBackbone,) if is_torch_available() else ()
      A_						:				Optional[Any]							=    {'feature-extraction': TimmBackbone} if is_torch_available() else {}
      A_						:				List[Any]							=    False
      A_						:				Dict							=    False
      A_						:				Any							=    False
      A_						:				List[Any]							=    False


      def    a (self       :      Tuple      ):





         """simple docstring"""



         __snake_case							       =   TimmBackboneModelTester(self      )
         __snake_case							       =   ConfigTester(self				,			config_class=a__				,			has_text_modality=a__      )


      def    a (self       :      Any      ):





         """simple docstring"""



         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       :      int      ):





         """simple docstring"""



         __snake_case							       =   '''resnet18'''
         __snake_case							       =   '''microsoft/resnet-18'''

         __snake_case							       =   AutoBackbone.from_pretrained(a__				,			use_timm_backbone=a__      )
         __snake_case							       =   AutoBackbone.from_pretrained(a__      )

         self.assertEqual(len(timm_model.out_features      )				,			len(transformers_model.out_features      )      )
         self.assertEqual(len(timm_model.stage_names      )				,			len(transformers_model.stage_names      )      )
         self.assertEqual(timm_model.channels				,			transformers_model.channels      )
         # Out indices are set to the last layer by default. For timm models, we don't know
         # the number of layers in advance, so we set it to (-1,), whereas for transformers
         # models, we set it to [len(stage_names) - 1] (kept for backward compatibility).
         self.assertEqual(timm_model.out_indices				,			(-1,)      )
         self.assertEqual(transformers_model.out_indices				,			[len(timm_model.stage_names      ) - 1]      )

         __snake_case							       =   AutoBackbone.from_pretrained(a__				,			use_timm_backbone=a__				,			out_indices=[1, 2, 3]      )
         __snake_case							       =   AutoBackbone.from_pretrained(a__				,			out_indices=[1, 2, 3]      )

         self.assertEqual(timm_model.out_indices				,			transformers_model.out_indices      )
         self.assertEqual(len(timm_model.out_features      )				,			len(transformers_model.out_features      )      )
         self.assertEqual(timm_model.channels				,			transformers_model.channels      )


      @unittest.skip('''TimmBackbone doesn\'t support feed forward chunking'''      )
      def    a (self       :      str      ):





         """simple docstring"""



         pass


      @unittest.skip('''TimmBackbone doesn\'t have num_hidden_layers attribute'''      )
      def    a (self       :      int      ):





         """simple docstring"""



         pass


      @unittest.skip('''TimmBackbone initialization is managed on the timm side'''      )
      def    a (self       :      Union[str, Any]      ):





         """simple docstring"""



         pass


      @unittest.skip('''TimmBackbone models doesn\'t have inputs_embeds'''      )
      def    a (self       :      Optional[int]      ):





         """simple docstring"""



         pass


      @unittest.skip('''TimmBackbone models doesn\'t have inputs_embeds'''      )
      def    a (self       :      int      ):





         """simple docstring"""



         pass


      @unittest.skip('''TimmBackbone model cannot be created without specifying a backbone checkpoint'''      )
      def    a (self       :      Tuple      ):





         """simple docstring"""



         pass


      @unittest.skip('''Only checkpoints on timm can be loaded into TimmBackbone'''      )
      def    a (self       :      int      ):





         """simple docstring"""



         pass


      @unittest.skip('''model weights aren\'t tied in TimmBackbone.'''      )
      def    a (self       :      Optional[Any]      ):





         """simple docstring"""



         pass


      @unittest.skip('''model weights aren\'t tied in TimmBackbone.'''      )
      def    a (self       :      Tuple      ):





         """simple docstring"""



         pass


      @unittest.skip('''Only checkpoints on timm can be loaded into TimmBackbone'''      )
      def    a (self       :      Dict      ):





         """simple docstring"""



         pass


      @unittest.skip('''Only checkpoints on timm can be loaded into TimmBackbone'''      )
      def    a (self       :      List[Any]      ):





         """simple docstring"""



         pass


      @unittest.skip('''TimmBackbone doesn\'t have hidden size info in its configuration.'''      )
      def    a (self       :      Optional[Any]      ):





         """simple docstring"""



         pass


      @unittest.skip('''TimmBackbone doesn\'t support output_attentions.'''      )
      def    a (self       :      List[Any]      ):





         """simple docstring"""



         pass


      @unittest.skip('''Safetensors is not supported by timm.'''      )
      def    a (self       :      Tuple      ):





         """simple docstring"""



         pass


      @unittest.skip('''Will be fixed soon by reducing the size of the model used for common tests.'''      )
      def    a (self       :      Tuple      ):





         """simple docstring"""



         pass


      def    a (self       :      Tuple      ):





         """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       :      Dict      ):





         """simple docstring"""



         __snake_case       ,	__snake_case							       =   self.model_tester.prepare_config_and_inputs_for_common()
         __snake_case							       =   True
         __snake_case							       =   self.has_attentions

         # no need to test all models as different heads yield the same functionality
         __snake_case							       =   self.all_model_classes[0]
         __snake_case							       =   model_class(a__      )
         model.to(a__      )

         __snake_case							       =   self._prepare_for_class(a__				,			a__      )
         __snake_case							       =   model(**a__      )
         __snake_case							       =   outputs[0][-1]

         # Encoder-/Decoder-only models
         __snake_case							       =   outputs.hidden_states[0]
         hidden_states.retain_grad()

         if self.has_attentions:
            __snake_case							       =   outputs.attentions[0]
            attentions.retain_grad()

         output.flatten()[0].backward(retain_graph=a__      )

         self.assertIsNotNone(hidden_states.grad      )

         if self.has_attentions:
            self.assertIsNotNone(attentions.grad      )


      def    a (self       :      Optional[int]      ):





         """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__      )
            model.to(a__      )
            model.eval()
            __snake_case							       =   model(**a__      )

            self.assertEqual(len(result.feature_maps      )				,			len(config.out_indices      )      )
            self.assertEqual(len(model.channels      )				,			len(config.out_indices      )      )

            # Check output of last stage is taken if out_features=None, out_indices=None
            __snake_case							       =   copy.deepcopy(a__      )
            __snake_case							       =   None
            __snake_case							       =   model_class(a__      )
            model.to(a__      )
            model.eval()
            __snake_case							       =   model(**a__      )

            self.assertEqual(len(result.feature_maps      )				,			1      )
            self.assertEqual(len(model.channels      )				,			1      )

            # Check backbone can be initialized with fresh weights
            __snake_case							       =   copy.deepcopy(a__      )
            __snake_case							       =   False
            __snake_case							       =   model_class(a__      )
            model.to(a__      )
            model.eval()
            __snake_case							       =   model(**a__      )

