
import inspect
import unittest

from transformers import ResNetConfig
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 torch import nn

   from transformers import ResNetBackbone, ResNetForImageClassification, ResNetModel
   from transformers.models.resnet.modeling_resnet import RESNET_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
   from PIL import Image

   from transformers import AutoImageProcessor






class UpperCAmelCase  :





   '''simple docstring'''


   def __init__(   self	:				Any     ,     lowerCAmelCase_	:				List[str]     ,     lowerCAmelCase_	:				Optional[Any]=3     ,     lowerCAmelCase_	:				str=3_2     ,     lowerCAmelCase_	:				Dict=3     ,     lowerCAmelCase_	:				List[Any]=1_0     ,     lowerCAmelCase_	:				Union[str, Any]=[1_0, 2_0, 3_0, 4_0]     ,     lowerCAmelCase_	:				List[Any]=[1, 1, 2, 1]     ,     lowerCAmelCase_	:				Union[str, Any]=True     ,     lowerCAmelCase_	:				str=True     ,     lowerCAmelCase_	:				Dict="relu"     ,     lowerCAmelCase_	:				List[Any]=3     ,     lowerCAmelCase_	:				Union[str, Any]=None     ,     lowerCAmelCase_	:				Optional[Any]=["stage2", "stage3", "stage4"]     ,     lowerCAmelCase_	:				Union[str, Any]=[2, 3, 4]     ,     ):

      """simple docstring"""
      _A:    Optional[Any]						     =			parent
      _A:    Dict						     =			batch_size
      _A:    str						     =			image_size
      _A:    Optional[Any]						     =			num_channels
      _A:    Dict						     =			embeddings_size
      _A:    Any						     =			hidden_sizes
      _A:    Union[str, Any]						     =			depths
      _A:    Optional[Any]						     =			is_training
      _A:    Union[str, Any]						     =			use_labels
      _A:    List[str]						     =			hidden_act
      _A:    Union[str, Any]						     =			num_labels
      _A:    int						     =			scope
      _A:    str						     =			len(lowerCAmelCase_	)
      _A:    List[str]						     =			out_features
      _A:    Union[str, Any]						     =			out_indices


   def 					__magic_name__							(   self	:				int	):

      """simple docstring"""
      _A:    str						     =			floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]	)

      _A:    List[str]						     =			None
      if self.use_labels:
         _A:    Dict						     =			ids_tensor([self.batch_size]     ,     self.num_labels	)

      _A:    Union[str, Any]						     =			self.get_config()

      return config, pixel_values, labels


   def 					__magic_name__							(   self	:				List[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     ,     out_features=self.out_features     ,     out_indices=self.out_indices     ,     )


   def 					__magic_name__							(   self	:				List[Any]     ,     lowerCAmelCase_	:				List[Any]     ,     lowerCAmelCase_	:				List[Any]     ,     lowerCAmelCase_	:				List[Any]	):

      """simple docstring"""
      _A:    str						     =			ResNetModel(config=lowerCAmelCase_	)
      model.to(lowerCAmelCase_	)
      model.eval()
      _A:    str						     =			model(lowerCAmelCase_	)
      # 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 // 3_2, self.image_size // 3_2)     ,     )


   def 					__magic_name__							(   self	:				Optional[int]     ,     lowerCAmelCase_	:				List[Any]     ,     lowerCAmelCase_	:				str     ,     lowerCAmelCase_	:				Dict	):

      """simple docstring"""
      _A:    str						     =			self.num_labels
      _A:    Tuple						     =			ResNetForImageClassification(lowerCAmelCase_	)
      model.to(lowerCAmelCase_	)
      model.eval()
      _A:    Tuple						     =			model(lowerCAmelCase_     ,     labels=lowerCAmelCase_	)
      self.parent.assertEqual(result.logits.shape     ,     (self.batch_size, self.num_labels)	)


   def 					__magic_name__							(   self	:				Optional[int]     ,     lowerCAmelCase_	:				List[str]     ,     lowerCAmelCase_	:				Tuple     ,     lowerCAmelCase_	:				List[str]	):

      """simple docstring"""
      _A:    Union[str, Any]						     =			ResNetBackbone(config=lowerCAmelCase_	)
      model.to(lowerCAmelCase_	)
      model.eval()
      _A:    Tuple						     =			model(lowerCAmelCase_	)

      # verify feature maps
      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
      _A:    Union[str, Any]						     =			None
      _A:    Dict						     =			ResNetBackbone(config=lowerCAmelCase_	)
      model.to(lowerCAmelCase_	)
      model.eval()
      _A:    Union[str, Any]						     =			model(lowerCAmelCase_	)

      # 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 					__magic_name__							(   self	:				List[Any]	):

      """simple docstring"""
      _A:    str						     =			self.prepare_config_and_inputs()
      _A     ,    _A     ,    _A:    List[str]						     =			config_and_inputs
      _A:    Optional[int]						     =			{'''pixel_values''': pixel_values}
      return config, inputs_dict






@require_torch
class UpperCAmelCase  (		SCREAMING_SNAKE_CASE__				,				SCREAMING_SNAKE_CASE__				,				unittest.TestCase  ):





   '''simple docstring'''
   __UpperCamelCase						:       Tuple												=       (
       (
           ResNetModel,
           ResNetForImageClassification,
           ResNetBackbone,
       )
       if is_torch_available()
       else ()
   )
   __UpperCamelCase						:       int												=       (
       {'''feature-extraction''': ResNetModel, '''image-classification''': ResNetForImageClassification}
       if is_torch_available()
       else {}
   )

   __UpperCamelCase						:       List[str]												=       True
   __UpperCamelCase						:       Dict												=       False
   __UpperCamelCase						:       List[Any]												=       False
   __UpperCamelCase						:       List[Any]												=       False
   __UpperCamelCase						:       Any												=       False


   def 					__magic_name__							(   self	:				Any	):

      """simple docstring"""
      _A:    List[Any]						     =			ResNetModelTester(self	)
      _A:    int						     =			ConfigTester(self     ,     config_class=lowerCAmelCase_     ,     has_text_modality=lowerCAmelCase_	)


   def 					__magic_name__							(   self	:				Optional[int]	):

      """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 					__magic_name__							(   self	:				Union[str, Any]	):

      """simple docstring"""
      return


   @unittest.skip(reason='''ResNet does not use inputs_embeds'''	)
   def 					__magic_name__							(   self	:				List[str]	):

      """simple docstring"""
      pass


   @unittest.skip(reason='''ResNet does not support input and output embeddings'''	)
   def 					__magic_name__							(   self	:				Optional[int]	):

      """simple docstring"""
      pass


   def 					__magic_name__							(   self	:				Dict	):

      """simple docstring"""
      _A     ,    _A:    int						     =			self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
         _A:    str						     =			model_class(lowerCAmelCase_	)
         _A:    Union[str, Any]						     =			inspect.signature(model.forward	)
         # signature.parameters is an OrderedDict => so arg_names order is deterministic
         _A:    Any						     =			[*signature.parameters.keys()]

         _A:    Optional[Any]						     =			['''pixel_values''']
         self.assertListEqual(arg_names[:1]     ,     lowerCAmelCase_	)


   def 					__magic_name__							(   self	:				Tuple	):

      """simple docstring"""
      _A:    Dict						     =			self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_model(*lowerCAmelCase_	)


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

      """simple docstring"""
      _A:    Optional[Any]						     =			self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_backbone(*lowerCAmelCase_	)


   def 					__magic_name__							(   self	:				Optional[int]	):

      """simple docstring"""
      _A     ,    _A:    Tuple						     =			self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
         _A:    Optional[Any]						     =			model_class(config=lowerCAmelCase_	)
         for name, module in model.named_modules():
            if isinstance(lowerCAmelCase_     ,     (nn.BatchNormad, nn.GroupNorm)	):
               self.assertTrue(
                   torch.all(module.weight == 1	)     ,     msg=F"""Parameter {name} of model {model_class} seems not properly initialized"""     ,     )
               self.assertTrue(
                   torch.all(module.bias == 0	)     ,     msg=F"""Parameter {name} of model {model_class} seems not properly initialized"""     ,     )


   def 					__magic_name__							(   self	:				Dict	):

      """simple docstring"""
      def check_hidden_states_output(lowerCAmelCase_	:				str     ,     lowerCAmelCase_	:				int     ,     lowerCAmelCase_	:				List[Any]	):
         _A:    str						     =			model_class(lowerCAmelCase_	)
         model.to(lowerCAmelCase_	)
         model.eval()

         with torch.no_grad():
            _A:    int						     =			model(**self._prepare_for_class(lowerCAmelCase_     ,     lowerCAmelCase_	)	)

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

         _A:    Optional[Any]						     =			self.model_tester.num_stages
         self.assertEqual(len(lowerCAmelCase_	)     ,     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]     ,     )

      _A     ,    _A:    Tuple						     =			self.model_tester.prepare_config_and_inputs_for_common()
      _A:    int						     =			['''basic''', '''bottleneck''']
      for model_class in self.all_model_classes:
         for layer_type in layers_type:
            _A:    Tuple						     =			layer_type
            _A:    str						     =			True
            check_hidden_states_output(lowerCAmelCase_     ,     lowerCAmelCase_     ,     lowerCAmelCase_	)

            # check that output_hidden_states also work using config
            del inputs_dict["output_hidden_states"]
            _A:    Union[str, Any]						     =			True

            check_hidden_states_output(lowerCAmelCase_     ,     lowerCAmelCase_     ,     lowerCAmelCase_	)


   @unittest.skip(reason='''ResNet does not use feedforward chunking'''	)
   def 					__magic_name__							(   self	:				str	):

      """simple docstring"""
      pass


   def 					__magic_name__							(   self	:				Tuple	):

      """simple docstring"""
      _A:    Any						     =			self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_image_classification(*lowerCAmelCase_	)


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

      """simple docstring"""
      for model_name in RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
         _A:    Dict						     =			ResNetModel.from_pretrained(lowerCAmelCase_	)
         self.assertIsNotNone(lowerCAmelCase_	)






def     lowerCamelCase__				(   ) ->  Union[str, Any]:
   _A:    int						     =			Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png''' )
   return image






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





   '''simple docstring'''


   @cached_property
   def 					__magic_name__							(   self	:				Any	):

      """simple docstring"""
      return (
          AutoImageProcessor.from_pretrained(RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]	)
          if is_vision_available()
          else None
      )


   @slow
   def 					__magic_name__							(   self	:				Tuple	):

      """simple docstring"""
      _A:    int						     =			ResNetForImageClassification.from_pretrained(RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]	).to(lowerCAmelCase_	)

      _A:    Optional[int]						     =			self.default_image_processor
      _A:    Optional[Any]						     =			prepare_img()
      _A:    Tuple						     =			image_processor(images=lowerCAmelCase_     ,     return_tensors='''pt'''	).to(lowerCAmelCase_	)

      # forward pass
      with torch.no_grad():
         _A:    Dict						     =			model(**lowerCAmelCase_	)

      # verify the logits
      _A:    List[Any]						     =			torch.Size((1, 1_0_0_0)	)
      self.assertEqual(outputs.logits.shape     ,     lowerCAmelCase_	)

      _A:    Any						     =			torch.tensor([-11.1069, -9.7877, -8.3777]	).to(lowerCAmelCase_	)

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






@require_torch
class UpperCAmelCase  (		SCREAMING_SNAKE_CASE__				,				unittest.TestCase  ):





   '''simple docstring'''
   __UpperCamelCase						:       Optional[int]												=       (ResNetBackbone,) if is_torch_available() else ()
   __UpperCamelCase						:       Optional[int]												=       False
   __UpperCamelCase						:       List[Any]												=       ResNetConfig


   def 					__magic_name__							(   self	:				str	):

      """simple docstring"""
      _A:    Optional[Any]						     =			ResNetModelTester(self	)





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

from tokenizers import pre_tokenizers

from ...tokenization_utils_base import AddedToken, BatchEncoding
from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import logging
from .tokenization_deberta import DebertaTokenizer


if TYPE_CHECKING:
   from transformers.pipelines.conversational import Conversation


UpperCAmelCase__						:	str	     = logging.get_logger(__name__)

UpperCAmelCase__						:	int	     = {'vocab_file': 'vocab.json', 'merges_file': 'merges.txt', 'tokenizer_file': 'tokenizer.json'}

UpperCAmelCase__						:	int	     = {
    'vocab_file': {
        'microsoft/deberta-base': 'https://huggingface.co/microsoft/deberta-base/resolve/main/vocab.json',
        'microsoft/deberta-large': 'https://huggingface.co/microsoft/deberta-large/resolve/main/vocab.json',
        'microsoft/deberta-xlarge': 'https://huggingface.co/microsoft/deberta-xlarge/resolve/main/vocab.json',
        'microsoft/deberta-base-mnli': 'https://huggingface.co/microsoft/deberta-base-mnli/resolve/main/vocab.json',
        'microsoft/deberta-large-mnli': 'https://huggingface.co/microsoft/deberta-large-mnli/resolve/main/vocab.json',
        'microsoft/deberta-xlarge-mnli': (
            'https://huggingface.co/microsoft/deberta-xlarge-mnli/resolve/main/vocab.json'
        ),
    },
    'merges_file': {
        'microsoft/deberta-base': 'https://huggingface.co/microsoft/deberta-base/resolve/main/merges.txt',
        'microsoft/deberta-large': 'https://huggingface.co/microsoft/deberta-large/resolve/main/merges.txt',
        'microsoft/deberta-xlarge': 'https://huggingface.co/microsoft/deberta-xlarge/resolve/main/merges.txt',
        'microsoft/deberta-base-mnli': 'https://huggingface.co/microsoft/deberta-base-mnli/resolve/main/merges.txt',
        'microsoft/deberta-large-mnli': 'https://huggingface.co/microsoft/deberta-large-mnli/resolve/main/merges.txt',
        'microsoft/deberta-xlarge-mnli': (
            'https://huggingface.co/microsoft/deberta-xlarge-mnli/resolve/main/merges.txt'
        ),
    },
}

UpperCAmelCase__						:	List[str]	     = {
    'microsoft/deberta-base': 512,
    'microsoft/deberta-large': 512,
    'microsoft/deberta-xlarge': 512,
    'microsoft/deberta-base-mnli': 512,
    'microsoft/deberta-large-mnli': 512,
    'microsoft/deberta-xlarge-mnli': 512,
}

UpperCAmelCase__						:	Optional[Any]	     = {
    'microsoft/deberta-base': {'do_lower_case': False},
    'microsoft/deberta-large': {'do_lower_case': False},
}






class UpperCAmelCase  (		SCREAMING_SNAKE_CASE__  ):





   '''simple docstring'''
   __UpperCamelCase						:       Union[str, Any]												=       VOCAB_FILES_NAMES
   __UpperCamelCase						:       Union[str, Any]												=       PRETRAINED_VOCAB_FILES_MAP
   __UpperCamelCase						:       Union[str, Any]												=       PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
   __UpperCamelCase						:       str												=       ['''input_ids''', '''attention_mask''', '''token_type_ids''']
   __UpperCamelCase						:       Any												=       DebertaTokenizer


   def __init__(   self	:				Union[str, Any]     ,     lowerCAmelCase_	:				Optional[Any]=None     ,     lowerCAmelCase_	:				int=None     ,     lowerCAmelCase_	:				Dict=None     ,     lowerCAmelCase_	:				int="replace"     ,     lowerCAmelCase_	:				List[str]="[CLS]"     ,     lowerCAmelCase_	:				str="[SEP]"     ,     lowerCAmelCase_	:				int="[SEP]"     ,     lowerCAmelCase_	:				Any="[CLS]"     ,     lowerCAmelCase_	:				Dict="[UNK]"     ,     lowerCAmelCase_	:				Optional[int]="[PAD]"     ,     lowerCAmelCase_	:				List[str]="[MASK]"     ,     lowerCAmelCase_	:				Optional[Any]=False     ,     **lowerCAmelCase_	:				List[Any]     ,     ):

      """simple docstring"""
      super().__init__(
          lowerCAmelCase_     ,     lowerCAmelCase_     ,     tokenizer_file=lowerCAmelCase_     ,     errors=lowerCAmelCase_     ,     bos_token=lowerCAmelCase_     ,     eos_token=lowerCAmelCase_     ,     unk_token=lowerCAmelCase_     ,     sep_token=lowerCAmelCase_     ,     cls_token=lowerCAmelCase_     ,     pad_token=lowerCAmelCase_     ,     mask_token=lowerCAmelCase_     ,     add_prefix_space=lowerCAmelCase_     ,     **lowerCAmelCase_     ,     )
      _A:    List[str]						     =			kwargs.pop('''add_bos_token'''     ,     lowerCAmelCase_	)

      _A:    Optional[int]						     =			json.loads(self.backend_tokenizer.pre_tokenizer.__getstate__()	)
      if pre_tok_state.get('''add_prefix_space'''     ,     lowerCAmelCase_	) != add_prefix_space:
         _A:    Dict						     =			getattr(lowerCAmelCase_     ,     pre_tok_state.pop('''type'''	)	)
         _A:    List[Any]						     =			add_prefix_space
         _A:    Optional[int]						     =			pre_tok_class(**lowerCAmelCase_	)

      _A:    Optional[Any]						     =			add_prefix_space


   @property
   def 					__magic_name__							(   self	:				Optional[Any]	):

      """simple docstring"""
      if self._mask_token is None:
         if self.verbose:
            logger.error('''Using mask_token, but it is not set yet.'''	)
         return None
      return str(self._mask_token	)


   @mask_token.setter
   def 					__magic_name__							(   self	:				str     ,     lowerCAmelCase_	:				str	):

      """simple docstring"""
      _A:    Dict						     =			AddedToken(lowerCAmelCase_     ,     lstrip=lowerCAmelCase_     ,     rstrip=lowerCAmelCase_	) if isinstance(lowerCAmelCase_     ,     lowerCAmelCase_	) else value
      _A:    str						     =			value


   def 					__magic_name__							(   self	:				Optional[Any]     ,     lowerCAmelCase_	:				List[int]     ,     lowerCAmelCase_	:				Optional[List[int]] = None	):

      """simple docstring"""
      if token_ids_a is None:
         return [self.cls_token_id] + token_ids_a + [self.sep_token_id]
      _A:    str						     =			[self.cls_token_id]
      _A:    Any						     =			[self.sep_token_id]
      return cls + token_ids_a + sep + token_ids_a + sep


   def 					__magic_name__							(   self	:				Optional[int]     ,     lowerCAmelCase_	:				List[int]     ,     lowerCAmelCase_	:				Optional[List[int]] = None	):

      """simple docstring"""
      _A:    Dict						     =			[self.sep_token_id]
      _A:    Any						     =			[self.cls_token_id]

      if token_ids_a is None:
         return len(cls + token_ids_a + sep	) * [0]
      return len(cls + token_ids_a + sep	) * [0] + len(token_ids_a + sep	) * [1]


   def 					__magic_name__							(   self	:				Tuple     ,     *lowerCAmelCase_	:				Dict     ,     **lowerCAmelCase_	:				Tuple	):

      """simple docstring"""
      _A:    Any						     =			kwargs.get('''is_split_into_words'''     ,     lowerCAmelCase_	)
      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(*lowerCAmelCase_     ,     **lowerCAmelCase_	)


   def 					__magic_name__							(   self	:				List[Any]     ,     *lowerCAmelCase_	:				Optional[Any]     ,     **lowerCAmelCase_	:				Any	):

      """simple docstring"""
      _A:    Optional[Any]						     =			kwargs.get('''is_split_into_words'''     ,     lowerCAmelCase_	)

      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(*lowerCAmelCase_     ,     **lowerCAmelCase_	)


   def 					__magic_name__							(   self	:				Optional[int]     ,     lowerCAmelCase_	:				str     ,     lowerCAmelCase_	:				Optional[str] = None	):

      """simple docstring"""
      _A:    Union[str, Any]						     =			self._tokenizer.model.save(lowerCAmelCase_     ,     name=lowerCAmelCase_	)
      return tuple(lowerCAmelCase_	)


   def 					__magic_name__							(   self	:				Union[str, Any]     ,     lowerCAmelCase_	:				"Conversation"	):

      """simple docstring"""
      _A:    List[Any]						     =			[]
      for is_user, text in conversation.iter_texts():
         input_ids.extend(self.encode(lowerCAmelCase_     ,     add_special_tokens=lowerCAmelCase_	) + [self.eos_token_id]	)

      if len(lowerCAmelCase_	) > self.model_max_length:
         _A:    Union[str, Any]						     =			input_ids[-self.model_max_length :]
      return input_ids



