






"""simple docstring"""






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 							lowerCAmelCase__				:






      '''simple docstring'''

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




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_      :  Dict    						=		parent
          SCREAMING_SNAKE_CASE_      :  Tuple    						=		out_indices if out_indices is not None else [4]
          SCREAMING_SNAKE_CASE_      :  Optional[int]    						=		stage_names
          SCREAMING_SNAKE_CASE_      :  Any    						=		out_features
          SCREAMING_SNAKE_CASE_      :  List[str]    						=		backbone
          SCREAMING_SNAKE_CASE_      :  Union[str, Any]    						=		batch_size
          SCREAMING_SNAKE_CASE_      :  Optional[Any]    						=		image_size
          SCREAMING_SNAKE_CASE_      :  Dict    						=		num_channels
          SCREAMING_SNAKE_CASE_      :  Any    						=		use_pretrained_backbone
          SCREAMING_SNAKE_CASE_      :  Any    						=		is_training
      def _SCREAMING_SNAKE_CASE (						self     :  Optional[int]):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_      :  List[str]    						=		floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size])
          SCREAMING_SNAKE_CASE_      :  List[Any]    						=		self.get_config()

          return config, pixel_values
      def _SCREAMING_SNAKE_CASE (						self     :  Dict):




          '''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 _SCREAMING_SNAKE_CASE (						self     :  List[str]						,	lowercase_     :  Dict						,	lowercase_     :  List[str]):




          '''simple docstring'''


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



      def _SCREAMING_SNAKE_CASE (						self     :  List[Any]):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_      :  List[str]    						=		self.prepare_config_and_inputs()
          SCREAMING_SNAKE_CASE_						,			SCREAMING_SNAKE_CASE_      :  Optional[Any]    						=		config_and_inputs
          SCREAMING_SNAKE_CASE_      :  List[Any]    						=		{'''pixel_values''': pixel_values}
          return config, inputs_dict




@require_torch
@require_timm
class 							lowerCAmelCase__				(			UpperCAmelCase__				,		UpperCAmelCase__				,		UpperCAmelCase__				,		unittest.TestCase ):






      '''simple docstring'''

      __UpperCamelCase	 =  (TimmBackbone,) if is_torch_available() else ()
      __UpperCamelCase	 =  {"feature-extraction": TimmBackbone} if is_torch_available() else {}
      __UpperCamelCase	 =  False
      __UpperCamelCase	 =  False
      __UpperCamelCase	 =  False
      __UpperCamelCase	 =  False
      def _SCREAMING_SNAKE_CASE (						self     :  Any):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_      :  Dict    						=		TimmBackboneModelTester(self)
          SCREAMING_SNAKE_CASE_      :  Optional[int]    						=		ConfigTester(self						,	config_class=lowercase_						,	has_text_modality=lowercase_)
      def _SCREAMING_SNAKE_CASE (						self     :  Dict):




          '''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 _SCREAMING_SNAKE_CASE (						self     :  Dict):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_      :  Union[str, Any]    						=		'''resnet18'''
          SCREAMING_SNAKE_CASE_      :  List[Any]    						=		'''microsoft/resnet-18'''

          SCREAMING_SNAKE_CASE_      :  str    						=		AutoBackbone.from_pretrained(lowercase_						,	use_timm_backbone=lowercase_)
          SCREAMING_SNAKE_CASE_      :  str    						=		AutoBackbone.from_pretrained(lowercase_)

          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])

          SCREAMING_SNAKE_CASE_      :  Optional[int]    						=		AutoBackbone.from_pretrained(lowercase_						,	use_timm_backbone=lowercase_						,	out_indices=[1, 2, 3])
          SCREAMING_SNAKE_CASE_      :  Optional[Any]    						=		AutoBackbone.from_pretrained(lowercase_						,	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 _SCREAMING_SNAKE_CASE (						self     :  Union[str, Any]):




          '''simple docstring'''


          pass
      @unittest.skip('''TimmBackbone doesn\'t have num_hidden_layers attribute''')
      def _SCREAMING_SNAKE_CASE (						self     :  Optional[Any]):




          '''simple docstring'''


          pass
      @unittest.skip('''TimmBackbone initialization is managed on the timm side''')
      def _SCREAMING_SNAKE_CASE (						self     :  str):




          '''simple docstring'''


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




          '''simple docstring'''


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




          '''simple docstring'''


          pass
      @unittest.skip('''TimmBackbone model cannot be created without specifying a backbone checkpoint''')
      def _SCREAMING_SNAKE_CASE (						self     :  Optional[int]):




          '''simple docstring'''


          pass
      @unittest.skip('''Only checkpoints on timm can be loaded into TimmBackbone''')
      def _SCREAMING_SNAKE_CASE (						self     :  Union[str, Any]):




          '''simple docstring'''


          pass
      @unittest.skip('''model weights aren\'t tied in TimmBackbone.''')
      def _SCREAMING_SNAKE_CASE (						self     :  List[str]):




          '''simple docstring'''


          pass
      @unittest.skip('''model weights aren\'t tied in TimmBackbone.''')
      def _SCREAMING_SNAKE_CASE (						self     :  int):




          '''simple docstring'''


          pass
      @unittest.skip('''Only checkpoints on timm can be loaded into TimmBackbone''')
      def _SCREAMING_SNAKE_CASE (						self     :  Any):




          '''simple docstring'''


          pass
      @unittest.skip('''Only checkpoints on timm can be loaded into TimmBackbone''')
      def _SCREAMING_SNAKE_CASE (						self     :  Union[str, Any]):




          '''simple docstring'''


          pass
      @unittest.skip('''TimmBackbone doesn\'t have hidden size info in its configuration.''')
      def _SCREAMING_SNAKE_CASE (						self     :  str):




          '''simple docstring'''


          pass
      @unittest.skip('''TimmBackbone doesn\'t support output_attentions.''')
      def _SCREAMING_SNAKE_CASE (						self     :  Union[str, Any]):




          '''simple docstring'''


          pass
      @unittest.skip('''Safetensors is not supported by timm.''')
      def _SCREAMING_SNAKE_CASE (						self     :  Union[str, Any]):




          '''simple docstring'''


          pass
      @unittest.skip('''Will be fixed soon by reducing the size of the model used for common tests.''')
      def _SCREAMING_SNAKE_CASE (						self     :  List[Any]):




          '''simple docstring'''


          pass
      def _SCREAMING_SNAKE_CASE (						self     :  Optional[int]):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_						,			SCREAMING_SNAKE_CASE_      :  Union[str, Any]    						=		self.model_tester.prepare_config_and_inputs_for_common()

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

              SCREAMING_SNAKE_CASE_      :  Optional[int]    						=		['''pixel_values''']
              self.assertListEqual(arg_names[:1]						,	lowercase_)
      def _SCREAMING_SNAKE_CASE (						self     :  Optional[int]):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_						,			SCREAMING_SNAKE_CASE_      :  List[str]    						=		self.model_tester.prepare_config_and_inputs_for_common()
          SCREAMING_SNAKE_CASE_      :  List[str]    						=		True
          SCREAMING_SNAKE_CASE_      :  Optional[Any]    						=		self.has_attentions

          # no need to test all models as different heads yield the same functionality
          SCREAMING_SNAKE_CASE_      :  Optional[int]    						=		self.all_model_classes[0]
          SCREAMING_SNAKE_CASE_      :  List[Any]    						=		model_class(lowercase_)
          model.to(lowercase_)

          SCREAMING_SNAKE_CASE_      :  Optional[Any]    						=		self._prepare_for_class(lowercase_						,	lowercase_)
          SCREAMING_SNAKE_CASE_      :  List[str]    						=		model(**lowercase_)
          SCREAMING_SNAKE_CASE_      :  int    						=		outputs[0][-1]

          # Encoder-/Decoder-only models
          SCREAMING_SNAKE_CASE_      :  List[str]    						=		outputs.hidden_states[0]
          hidden_states.retain_grad()

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

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

          self.assertIsNotNone(hidden_states.grad)

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



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




          '''simple docstring'''


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

          for model_class in self.all_model_classes:
              SCREAMING_SNAKE_CASE_      :  int    						=		model_class(lowercase_)
              model.to(lowercase_)
              model.eval()
              SCREAMING_SNAKE_CASE_      :  int    						=		model(**lowercase_)

              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
              SCREAMING_SNAKE_CASE_      :  List[str]    						=		copy.deepcopy(lowercase_)
              SCREAMING_SNAKE_CASE_      :  int    						=		None
              SCREAMING_SNAKE_CASE_      :  Any    						=		model_class(lowercase_)
              model.to(lowercase_)
              model.eval()
              SCREAMING_SNAKE_CASE_      :  Union[str, Any]    						=		model(**lowercase_)

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

              # Check backbone can be initialized with fresh weights
              SCREAMING_SNAKE_CASE_      :  int    						=		copy.deepcopy(lowercase_)
              SCREAMING_SNAKE_CASE_      :  List[str]    						=		False
              SCREAMING_SNAKE_CASE_      :  Any    						=		model_class(lowercase_)
              model.to(lowercase_)
              model.eval()
              SCREAMING_SNAKE_CASE_      :  Dict    						=		model(**lowercase_)










"""simple docstring"""






import json
from typing import TYPE_CHECKING, List, Optional, Tuple

from tokenizers import pre_tokenizers

from ...tokenization_utils_base import BatchEncoding
from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import logging
from .tokenization_gpta import GPTaTokenizer


if TYPE_CHECKING:
  from transformers.pipelines.conversational import Conversation


UpperCAmelCase_   : Optional[int]   			= logging.get_logger(__name__)

UpperCAmelCase_   : Dict   			= {"""vocab_file""": """vocab.json""", """merges_file""": """merges.txt""", """tokenizer_file""": """tokenizer.json"""}

UpperCAmelCase_   : Dict   			= {
    """vocab_file""": {
        """gpt2""": """https://huggingface.co/gpt2/resolve/main/vocab.json""",
        """gpt2-medium""": """https://huggingface.co/gpt2-medium/resolve/main/vocab.json""",
        """gpt2-large""": """https://huggingface.co/gpt2-large/resolve/main/vocab.json""",
        """gpt2-xl""": """https://huggingface.co/gpt2-xl/resolve/main/vocab.json""",
        """distilgpt2""": """https://huggingface.co/distilgpt2/resolve/main/vocab.json""",
    },
    """merges_file""": {
        """gpt2""": """https://huggingface.co/gpt2/resolve/main/merges.txt""",
        """gpt2-medium""": """https://huggingface.co/gpt2-medium/resolve/main/merges.txt""",
        """gpt2-large""": """https://huggingface.co/gpt2-large/resolve/main/merges.txt""",
        """gpt2-xl""": """https://huggingface.co/gpt2-xl/resolve/main/merges.txt""",
        """distilgpt2""": """https://huggingface.co/distilgpt2/resolve/main/merges.txt""",
    },
    """tokenizer_file""": {
        """gpt2""": """https://huggingface.co/gpt2/resolve/main/tokenizer.json""",
        """gpt2-medium""": """https://huggingface.co/gpt2-medium/resolve/main/tokenizer.json""",
        """gpt2-large""": """https://huggingface.co/gpt2-large/resolve/main/tokenizer.json""",
        """gpt2-xl""": """https://huggingface.co/gpt2-xl/resolve/main/tokenizer.json""",
        """distilgpt2""": """https://huggingface.co/distilgpt2/resolve/main/tokenizer.json""",
    },
}

UpperCAmelCase_   : List[str]   			= {
    """gpt2""": 1024,
    """gpt2-medium""": 1024,
    """gpt2-large""": 1024,
    """gpt2-xl""": 1024,
    """distilgpt2""": 1024,
}




class 							lowerCAmelCase__				(			UpperCAmelCase__ ):






      '''simple docstring'''

      __UpperCamelCase	 =  VOCAB_FILES_NAMES
      __UpperCamelCase	 =  PRETRAINED_VOCAB_FILES_MAP
      __UpperCamelCase	 =  PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
      __UpperCamelCase	 =  ["input_ids", "attention_mask"]
      __UpperCamelCase	 =  GPTaTokenizer
      def __init__(						self     :  Optional[int]						,	lowercase_     :  int=None						,	lowercase_     :  List[str]=None						,	lowercase_     :  Union[str, Any]=None						,	lowercase_     :  Tuple="<|endoftext|>"						,	lowercase_     :  str="<|endoftext|>"						,	lowercase_     :  Dict="<|endoftext|>"						,	lowercase_     :  Tuple=False						,	**lowercase_     :  Optional[int]						,	):




          '''simple docstring'''


          super().__init__(
              lowercase_						,	lowercase_						,	tokenizer_file=lowercase_						,	unk_token=lowercase_						,	bos_token=lowercase_						,	eos_token=lowercase_						,	add_prefix_space=lowercase_						,	**lowercase_						,	)

          SCREAMING_SNAKE_CASE_      :  Union[str, Any]    						=		kwargs.pop('''add_bos_token'''						,	lowercase_)

          SCREAMING_SNAKE_CASE_      :  Dict    						=		json.loads(self.backend_tokenizer.pre_tokenizer.__getstate__())
          if pre_tok_state.get('''add_prefix_space'''						,	lowercase_) != add_prefix_space:
              SCREAMING_SNAKE_CASE_      :  int    						=		getattr(lowercase_						,	pre_tok_state.pop('''type'''))
              SCREAMING_SNAKE_CASE_      :  str    						=		add_prefix_space
              SCREAMING_SNAKE_CASE_      :  Dict    						=		pre_tok_class(**lowercase_)

          SCREAMING_SNAKE_CASE_      :  Optional[Any]    						=		add_prefix_space
      def _SCREAMING_SNAKE_CASE (						self     :  str						,	*lowercase_     :  List[Any]						,	**lowercase_     :  Optional[Any]):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_      :  List[Any]    						=		kwargs.get('''is_split_into_words'''						,	lowercase_)
          assert self.add_prefix_space or not is_split_into_words, (
              F'You need to instantiate {self.__class__.__name__} with add_prefix_space=True '
              "to use it with pretokenized inputs."
          )

          return super()._batch_encode_plus(*lowercase_						,	**lowercase_)
      def _SCREAMING_SNAKE_CASE (						self     :  Optional[int]						,	*lowercase_     :  List[str]						,	**lowercase_     :  List[Any]):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_      :  List[str]    						=		kwargs.get('''is_split_into_words'''						,	lowercase_)

          assert self.add_prefix_space or not is_split_into_words, (
              F'You need to instantiate {self.__class__.__name__} with add_prefix_space=True '
              "to use it with pretokenized inputs."
          )

          return super()._encode_plus(*lowercase_						,	**lowercase_)
      def _SCREAMING_SNAKE_CASE (						self     :  int						,	lowercase_     :  str						,	lowercase_     :  Optional[str] = None):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_      :  List[str]    						=		self._tokenizer.model.save(lowercase_						,	name=lowercase_)
          return tuple(lowercase_)



      def _SCREAMING_SNAKE_CASE (						self     :  int						,	lowercase_     :  "Conversation"):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_      :  Dict    						=		[]
          for is_user, text in conversation.iter_texts():
              input_ids.extend(self.encode(lowercase_						,	add_special_tokens=lowercase_) + [self.eos_token_id])

          if len(lowercase_) > self.model_max_length:
              SCREAMING_SNAKE_CASE_      :  Any    						=		input_ids[-self.model_max_length :]
          return input_ids


