

'''simple docstring'''




from typing import List, Union

from ...configuration_utils import PretrainedConfig
from ...utils import logging


_a				: int 							=						logging.get_logger(__name__)

_a				: List[Any] 							=						{
    'allenai/led-base-16384': 'https://huggingface.co/allenai/led-base-16384/resolve/main/config.json',
    # See all LED models at https://huggingface.co/models?filter=led
}



class        lowercase_	(		a ):

  '''simple docstring'''





  __lowerCAmelCase					: Dict      =   "led"
  __lowerCAmelCase					: Union[str, Any]      =   {
      "num_attention_heads": "encoder_attention_heads",
      "hidden_size": "d_model",
      "attention_probs_dropout_prob": "attention_dropout",
      "initializer_range": "init_std",
  }
  def __init__(     self   , a_=5_0_2_6_5   , a_=1_6_3_8_4   , a_=1_0_2_4   , a_=1_2   , a_=4_0_9_6   , a_=1_6   , a_=1_2   , a_=4_0_9_6   , a_=1_6   , a_=0.0   , a_=0.0   , a_=True   , a_=True   , a_="gelu"   , a_=1_0_2_4   , a_=0.1   , a_=0.0   , a_=0.0   , a_=0.02   , a_=2   , a_=0.0   , a_=1   , a_=0   , a_=2   , a_ = 5_1_2   , **a_   , )							->				Dict:


    """simple docstring"""
    UpperCAmelCase													=	vocab_size
    UpperCAmelCase													=	max_encoder_position_embeddings
    UpperCAmelCase													=	max_decoder_position_embeddings
    UpperCAmelCase													=	d_model
    UpperCAmelCase													=	encoder_ffn_dim
    UpperCAmelCase													=	encoder_layers
    UpperCAmelCase													=	encoder_attention_heads
    UpperCAmelCase													=	decoder_ffn_dim
    UpperCAmelCase													=	decoder_layers
    UpperCAmelCase													=	decoder_attention_heads
    UpperCAmelCase													=	dropout
    UpperCAmelCase													=	attention_dropout
    UpperCAmelCase													=	activation_dropout
    UpperCAmelCase													=	activation_function
    UpperCAmelCase													=	init_std
    UpperCAmelCase													=	encoder_layerdrop
    UpperCAmelCase													=	decoder_layerdrop
    UpperCAmelCase													=	classifier_dropout
    UpperCAmelCase													=	use_cache
    UpperCAmelCase													=	encoder_layers
    UpperCAmelCase													=	attention_window

    super().__init__(
        pad_token_id=a_   , bos_token_id=a_   , eos_token_id=a_   , is_encoder_decoder=a_   , decoder_start_token_id=a_   , **a_   , )





'''simple docstring'''




from __future__ import annotations

import unittest

from transformers import AutoTokenizer, GPTJConfig, is_tf_available
from transformers.testing_utils import require_tf, slow, tooslow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin
from ...utils.test_modeling_tf_core import TFCoreModelTesterMixin


if is_tf_available():
  import tensorflow as tf

  from transformers.models.gptj.modeling_tf_gptj import (
      TFGPTJForCausalLM,
      TFGPTJForQuestionAnswering,
      TFGPTJForSequenceClassification,
      TFGPTJModel,
      shape_list,
  )



class        lowercase_	:

  '''simple docstring'''





  def __init__(     self   , a_     )							->				Any:


    """simple docstring"""
    UpperCAmelCase													=	parent
    UpperCAmelCase													=	1_3
    UpperCAmelCase													=	7
    UpperCAmelCase													=	True
    UpperCAmelCase													=	True
    UpperCAmelCase													=	True
    UpperCAmelCase													=	True
    UpperCAmelCase													=	True
    UpperCAmelCase													=	9_9
    UpperCAmelCase													=	3_2
    UpperCAmelCase													=	4
    UpperCAmelCase													=	2
    UpperCAmelCase													=	4
    UpperCAmelCase													=	3_7
    UpperCAmelCase													=	'gelu'
    UpperCAmelCase													=	0.1
    UpperCAmelCase													=	0.1
    UpperCAmelCase													=	5_1_2
    UpperCAmelCase													=	1_6
    UpperCAmelCase													=	2
    UpperCAmelCase													=	0.02
    UpperCAmelCase													=	3
    UpperCAmelCase													=	4
    UpperCAmelCase													=	None
    UpperCAmelCase													=	self.vocab_size - 1
    UpperCAmelCase													=	self.vocab_size - 1
    UpperCAmelCase													=	self.vocab_size - 1
  def 						snake_case_			(     self     )							->				List[str]:


    """simple docstring"""
    UpperCAmelCase													=	ids_tensor([self.batch_size, self.seq_length]   , self.vocab_size     )

    UpperCAmelCase													=	None
    if self.use_input_mask:
      UpperCAmelCase													=	random_attention_mask([self.batch_size, self.seq_length]     )

    UpperCAmelCase													=	None
    if self.use_token_type_ids:
      UpperCAmelCase													=	ids_tensor([self.batch_size, self.seq_length]   , self.type_vocab_size     )

    UpperCAmelCase													=	None
    if self.use_mc_token_ids:
      UpperCAmelCase													=	ids_tensor([self.batch_size, self.num_choices]   , self.seq_length     )

    UpperCAmelCase													=	None
    UpperCAmelCase													=	None
    UpperCAmelCase													=	None
    if self.use_labels:
      UpperCAmelCase													=	ids_tensor([self.batch_size]   , self.type_sequence_label_size     )
      UpperCAmelCase													=	ids_tensor([self.batch_size, self.seq_length]   , self.num_labels     )
      UpperCAmelCase													=	ids_tensor([self.batch_size]   , self.num_choices     )

    UpperCAmelCase													=	GPTJConfig(
        vocab_size=self.vocab_size   , n_embd=self.hidden_size   , n_layer=self.num_hidden_layers   , n_head=self.num_attention_heads   , intermediate_size=self.intermediate_size   , hidden_act=self.hidden_act   , hidden_dropout_prob=self.hidden_dropout_prob   , attention_probs_dropout_prob=self.attention_probs_dropout_prob   , n_positions=self.max_position_embeddings   , type_vocab_size=self.type_vocab_size   , initializer_range=self.initializer_range   , bos_token_id=self.bos_token_id   , eos_token_id=self.eos_token_id   , pad_token_id=self.pad_token_id   , rotary_dim=self.rotary_dim   , return_dict=a_   , )

    UpperCAmelCase													=	ids_tensor([self.num_hidden_layers, self.num_attention_heads]   , 2     )

    return (
        config,
        input_ids,
        input_mask,
        head_mask,
        token_type_ids,
        mc_token_ids,
        sequence_labels,
        token_labels,
        choice_labels,
    )
  def 						snake_case_			(     self   , a_   , a_   , a_   , a_   , a_   , *a_     )							->				Dict:


    """simple docstring"""
    UpperCAmelCase													=	TFGPTJModel(config=a_     )
    UpperCAmelCase													=	{
        'input_ids': input_ids,
        'attention_mask': input_mask,
        'token_type_ids': token_type_ids,
    }
    UpperCAmelCase													=	model(a_     )

    UpperCAmelCase													=	[input_ids, None, input_mask]  # None is the input for 'past'
    UpperCAmelCase													=	model(a_     )

    UpperCAmelCase													=	model(a_     )

    self.parent.assertEqual(result.last_hidden_state.shape   , (self.batch_size, self.seq_length, self.hidden_size)     )
  def 						snake_case_			(     self   , a_   , a_   , a_   , a_   , a_   , *a_     )							->				Tuple:


    """simple docstring"""
    UpperCAmelCase													=	TFGPTJModel(config=a_     )

    # first forward pass
    UpperCAmelCase													=	model(a_   , token_type_ids=a_   , use_cache=a_     )
    UpperCAmelCase													=	model(a_   , token_type_ids=a_     )
    UpperCAmelCase													=	model(a_   , token_type_ids=a_   , use_cache=a_     )

    self.parent.assertTrue(len(a_     ) == len(a_     )     )
    self.parent.assertTrue(len(a_     ) == len(a_     ) + 1     )

    UpperCAmelCase							,      UpperCAmelCase													=	outputs.to_tuple()

    # create hypothetical next token and extent to next_input_ids
    UpperCAmelCase													=	ids_tensor((self.batch_size, 1)   , config.vocab_size     )
    UpperCAmelCase													=	ids_tensor([self.batch_size, 1]   , self.type_vocab_size     )

    # append to next input_ids and token_type_ids
    UpperCAmelCase													=	tf.concat([input_ids, next_tokens]   , axis=-1     )
    UpperCAmelCase													=	tf.concat([token_type_ids, next_token_types]   , axis=-1     )

    UpperCAmelCase													=	model(a_   , token_type_ids=a_     )['last_hidden_state']
    UpperCAmelCase													=	model(a_   , token_type_ids=a_   , past_key_values=a_     )[
        'last_hidden_state'
    ]

    # select random slice
    UpperCAmelCase													=	int(ids_tensor((1,)   , shape_list(a_     )[-1]     )     )
    UpperCAmelCase													=	output_from_no_past[:, -1, random_slice_idx]
    UpperCAmelCase													=	output_from_past[:, 0, random_slice_idx]

    # test that outputs are equal for slice
    tf.debugging.assert_near(a_   , a_   , rtol=1E-6     )
  def 						snake_case_			(     self   , a_   , a_   , a_   , a_   , a_   , *a_     )							->				Tuple:


    """simple docstring"""
    UpperCAmelCase													=	TFGPTJModel(config=a_     )

    # create attention mask
    UpperCAmelCase													=	self.seq_length // 2
    UpperCAmelCase													=	tf.ones((self.batch_size, half_seq_length)   , dtype=tf.intaa     )
    UpperCAmelCase													=	tf.zeros((self.batch_size, self.seq_length - half_seq_length)   , dtype=tf.intaa     )
    UpperCAmelCase													=	tf.concat([attn_mask_begin, attn_mask_end]   , axis=1     )

    # first forward pass
    UpperCAmelCase							,      UpperCAmelCase													=	model(a_   , attention_mask=a_     ).to_tuple()

    # create hypothetical next token and extent to next_input_ids
    UpperCAmelCase													=	ids_tensor((self.batch_size, 1)   , config.vocab_size     )

    # change a random masked slice from input_ids
    UpperCAmelCase													=	ids_tensor((1,)   , a_     ).numpy() + 1
    UpperCAmelCase													=	ids_tensor((self.batch_size, self.seq_length)   , config.vocab_size     )
    UpperCAmelCase													=	tf.range(self.seq_length     ) == (self.seq_length - random_seq_idx_to_change)
    UpperCAmelCase													=	tf.transpose(
        tf.broadcast_to(tf.expand_dims(a_   , -1     )   , (self.seq_length, self.batch_size)     )     )
    UpperCAmelCase													=	tf.where(a_   , a_   , a_     )

    # append to next input_ids and attn_mask
    UpperCAmelCase													=	tf.concat([input_ids, next_tokens]   , axis=-1     )
    UpperCAmelCase													=	tf.concat([attn_mask, tf.ones((shape_list(a_     )[0], 1)   , dtype=tf.intaa     )]   , axis=1     )

    # get two different outputs
    UpperCAmelCase													=	model(a_   , attention_mask=a_     )['last_hidden_state']
    UpperCAmelCase													=	model(a_   , past_key_values=a_   , attention_mask=a_     )[
        'last_hidden_state'
    ]

    # select random slice
    UpperCAmelCase													=	int(ids_tensor((1,)   , shape_list(a_     )[-1]     )     )
    UpperCAmelCase													=	output_from_no_past[:, -1, random_slice_idx]
    UpperCAmelCase													=	output_from_past[:, 0, random_slice_idx]

    # test that outputs are equal for slice
    tf.debugging.assert_near(a_   , a_   , rtol=1E-12     )
  def 						snake_case_			(     self   , a_   , a_   , a_   , a_   , a_   , *a_     )							->				Any:


    """simple docstring"""
    UpperCAmelCase													=	TFGPTJModel(config=a_     )

    UpperCAmelCase													=	input_ids[:1, :]
    UpperCAmelCase													=	input_mask[:1, :]
    UpperCAmelCase													=	token_type_ids[:1, :]
    UpperCAmelCase													=	1

    # first forward pass
    UpperCAmelCase													=	model(a_   , attention_mask=a_   , token_type_ids=a_   , use_cache=a_     )

    UpperCAmelCase							,      UpperCAmelCase													=	outputs.to_tuple()

    # create hypothetical next token and extent to next_input_ids
    UpperCAmelCase													=	ids_tensor((self.batch_size, 3)   , config.vocab_size     )
    UpperCAmelCase													=	ids_tensor((self.batch_size, 3)   , 2     )
    UpperCAmelCase													=	ids_tensor((self.batch_size, 3)   , self.type_vocab_size     )

    # append to next input_ids and token_type_ids
    UpperCAmelCase													=	tf.concat([input_ids, next_tokens]   , axis=-1     )
    UpperCAmelCase													=	tf.concat([input_mask, next_attn_mask]   , axis=-1     )
    UpperCAmelCase													=	tf.concat([token_type_ids, next_token_types]   , axis=-1     )

    UpperCAmelCase													=	model(
        a_   , token_type_ids=a_   , attention_mask=a_     )['last_hidden_state']
    UpperCAmelCase													=	model(
        a_   , token_type_ids=a_   , attention_mask=a_   , past_key_values=a_   , )['last_hidden_state']
    self.parent.assertTrue(output_from_past.shape[1] == next_tokens.shape[1]     )

    # select random slice
    UpperCAmelCase													=	int(ids_tensor((1,)   , shape_list(a_     )[-1]     )     )
    UpperCAmelCase													=	output_from_no_past[:, -3:, random_slice_idx]
    UpperCAmelCase													=	output_from_past[:, :, random_slice_idx]

    # test that outputs are equal for slice
    tf.debugging.assert_near(a_   , a_   , rtol=1E-3     )
  def 						snake_case_			(     self   , a_   , a_   , a_   , a_   , a_   , *a_     )							->				Union[str, Any]:


    """simple docstring"""
    UpperCAmelCase													=	TFGPTJForCausalLM(config=a_     )
    UpperCAmelCase													=	{
        'input_ids': input_ids,
        'attention_mask': input_mask,
        'token_type_ids': token_type_ids,
    }
    UpperCAmelCase													=	model(a_     )
    self.parent.assertEqual(result.logits.shape   , (self.batch_size, self.seq_length, self.vocab_size)     )





  def 						snake_case_			(     self     )							->				Dict:


    """simple docstring"""
    UpperCAmelCase													=	self.prepare_config_and_inputs()

    (
        (
        UpperCAmelCase
    )							,      (
        UpperCAmelCase
    )							,      (
        UpperCAmelCase
    )							,      (
        UpperCAmelCase
    )							,      (
        UpperCAmelCase
    )							,      (
        UpperCAmelCase
    )							,      (
        UpperCAmelCase
    )							,      (
        UpperCAmelCase
    )							,      (
        UpperCAmelCase
    )							,      
    )													=	config_and_inputs

    UpperCAmelCase													=	{
        'input_ids': input_ids,
        'token_type_ids': token_type_ids,
        'attention_mask': input_mask,
    }
    return config, inputs_dict




@require_tf
class        lowercase_	(		a ,       a ,       a ,       unittest.TestCase ):

  '''simple docstring'''





  __lowerCAmelCase					: Any      =   (
      (TFGPTJForCausalLM, TFGPTJForSequenceClassification, TFGPTJForQuestionAnswering, TFGPTJModel)
      if is_tf_available()
      else ()
  )

  __lowerCAmelCase					: Optional[int]      =   (TFGPTJForCausalLM,) if is_tf_available() else ()
  __lowerCAmelCase					: Union[str, Any]      =   (
      {
          "feature-extraction": TFGPTJModel,
          "question-answering": TFGPTJForQuestionAnswering,
          "text-classification": TFGPTJForSequenceClassification,
          "text-generation": TFGPTJForCausalLM,
          "zero-shot": TFGPTJForSequenceClassification,
      }
      if is_tf_available()
      else {}
  )
  __lowerCAmelCase					: int      =   False
  __lowerCAmelCase					: List[Any]      =   False
  __lowerCAmelCase					: Any      =   False
  __lowerCAmelCase					: Tuple      =   False
  def 						snake_case_			(     self   , a_   , a_   , a_   , a_   , a_     )							->				int:


    """simple docstring"""
    if (
        pipeline_test_casse_name == "QAPipelineTests"
        and tokenizer_name is not None
        and not tokenizer_name.endswith('Fast'     )
    ):
      # `QAPipelineTests` fails for a few models when the slower tokenizer are used.
      # (The slower tokenizers were never used for pipeline tests before the pipeline testing rework)
      # TODO: check (and possibly fix) the `QAPipelineTests` with slower tokenizer
      return True

    return False
  def 						snake_case_			(     self     )							->				List[Any]:


    """simple docstring"""
    UpperCAmelCase													=	TFGPTJModelTester(self     )
    UpperCAmelCase													=	ConfigTester(self   , config_class=a_   , n_embd=3_7     )
  def 						snake_case_			(     self     )							->				Any:


    """simple docstring"""
    self.config_tester.run_common_tests()
  def 						snake_case_			(     self     )							->				Union[str, Any]:


    """simple docstring"""
    UpperCAmelCase													=	self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_gptj_model(*a_     )
  def 						snake_case_			(     self     )							->				List[Any]:


    """simple docstring"""
    UpperCAmelCase													=	self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_gptj_model_past(*a_     )
  def 						snake_case_			(     self     )							->				Optional[int]:


    """simple docstring"""
    UpperCAmelCase													=	self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_gptj_model_attention_mask_past(*a_     )
  def 						snake_case_			(     self     )							->				List[Any]:


    """simple docstring"""
    UpperCAmelCase													=	self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_gptj_model_past_large_inputs(*a_     )
  def 						snake_case_			(     self     )							->				List[Any]:


    """simple docstring"""
    UpperCAmelCase													=	self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_gptj_lm_head_model(*a_     )
  @slow
  @unittest.skipIf(
      not is_tf_available() or len(tf.config.list_physical_devices('GPU'     )     ) > 0   , 'skip testing on GPU for now to avoid GPU OOM.'   , )
  def 						snake_case_			(     self     )							->				int:


    """simple docstring"""
    UpperCAmelCase													=	TFGPTJModel.from_pretrained('EleutherAI/gpt-j-6B'   , from_pt=a_     )
    self.assertIsNotNone(a_     )





  @unittest.skip(reason='Currently, model embeddings are going to undergo a major refactor.'     )
  def 						snake_case_			(     self     )							->				List[Any]:


    """simple docstring"""
    super().test_resize_token_embeddings()




@require_tf
@tooslow
# Marked as @tooslow due to GPU OOM -- but still useful to run locally. Requires ~39GB of RAM.
class        lowercase_	(		unittest.TestCase ):

  '''simple docstring'''





  def 						snake_case_			(     self     )							->				Any:


    """simple docstring"""
    UpperCAmelCase													=	TFGPTJForCausalLM.from_pretrained('EleutherAI/gpt-j-6B'   , from_pt=a_     )
    UpperCAmelCase													=	tf.convert_to_tensor([[4_6_4, 3_2_9_0]]   , dtype=tf.intaa     )  # The dog
    # fmt: off
    # The dog is a man's best friend. It is a loyal companion, and it is a friend
    UpperCAmelCase													=	[4_6_4, 3_2_9_0, 3_1_8, 2_5_7, 5_8_2, 3_3_8, 1_2_6_6, 1_5_4_5, 1_3, 6_3_2, 3_1_8, 2_5_7, 9_1_1_2, 1_5_1_8_5, 1_1, 2_9_0, 3_4_0, 3_1_8, 2_5_7, 1_5_4_5]
    # fmt: on
    UpperCAmelCase													=	model.generate(a_   , do_sample=a_     )
    self.assertListEqual(output_ids[0].numpy().tolist()   , a_     )
  def 						snake_case_			(     self     )							->				List[str]:


    """simple docstring"""
    UpperCAmelCase													=	AutoTokenizer.from_pretrained('EleutherAI/gpt-j-6B'   , revision='float16'     )
    UpperCAmelCase													=	TFGPTJForCausalLM.from_pretrained('EleutherAI/gpt-j-6B'   , revision='float16'   , from_pt=a_     )

    UpperCAmelCase													=	tokenizer('Today is a nice day and'   , return_tensors='tf'     )
    # forces the generation to happen on CPU, to avoid GPU-related quirks
    with tf.device(':/CPU:0'     ):
      UpperCAmelCase													=	model.generate(**a_   , do_sample=a_   , seed=[4_2, 0]     )
    UpperCAmelCase													=	tokenizer.decode(output_ids[0]   , skip_special_tokens=a_     )

    UpperCAmelCase													=	'Today is a nice day and I’m going to go for a walk. I’'
    self.assertEqual(a_   , a_     )
  def 						snake_case_			(     self     )							->				Dict:


    """simple docstring"""
    UpperCAmelCase													=	TFGPTJForCausalLM.from_pretrained('EleutherAI/gpt-j-6B'   , revision='float16'   , from_pt=a_     )
    UpperCAmelCase													=	AutoTokenizer.from_pretrained('EleutherAI/gpt-j-6B'   , revision='float16'     )

    UpperCAmelCase													=	'left'

    # Define PAD Token = EOS Token = 50256
    UpperCAmelCase													=	tokenizer.eos_token
    UpperCAmelCase													=	model.config.eos_token_id

    # use different length sentences to test batching
    UpperCAmelCase													=	[
        'Hello, my dog is a little',
        'Today, I',
    ]
    UpperCAmelCase													=	[
        'Hello, my dog is a little over a year old and has been diagnosed with hip dysplasia',
        'Today, I’m going to be talking about a topic that’',
    ]
    return model, tokenizer, sentences, expected_output_sentences
  def 						snake_case_			(     self     )							->				int:


    """simple docstring"""
    # Confirms that we get the expected results with left-padded beam search
    UpperCAmelCase							,      UpperCAmelCase							,      UpperCAmelCase							,      UpperCAmelCase													=	self._get_beam_search_test_objects()

    UpperCAmelCase													=	tokenizer(a_   , return_tensors='tf'   , padding=a_     )
    UpperCAmelCase													=	model.generate(**a_   , do_sample=a_   , num_beams=2     )
    UpperCAmelCase													=	tokenizer.batch_decode(a_   , skip_special_tokens=a_     )
    self.assertListEqual(a_   , a_     )
  def 						snake_case_			(     self     )							->				List[str]:


    """simple docstring"""
    # Confirms that left-padding is working properly
    UpperCAmelCase							,      UpperCAmelCase							,      UpperCAmelCase							,      UpperCAmelCase													=	self._get_beam_search_test_objects()

    UpperCAmelCase													=	tokenizer(a_   , return_tensors='tf'   , padding=a_     )
    UpperCAmelCase													=	tokenizer(sentences[0]   , return_tensors='tf'     )
    UpperCAmelCase													=	model.generate(**a_   , do_sample=a_   , num_beams=2     )
    UpperCAmelCase													=	(
        shape_list(inputs_non_padded['input_ids']     )[-1]
        - tf.reduce_sum(tf.cast(inputs['attention_mask'][-1]   , tf.intaa     )     ).numpy()
    )
    UpperCAmelCase													=	tokenizer(sentences[1]   , return_tensors='tf'     )
    UpperCAmelCase													=	model.generate(
        **a_   , do_sample=a_   , num_beams=2   , max_length=model.config.max_length - num_paddings     )
    UpperCAmelCase													=	tokenizer.decode(output_non_padded[0]   , skip_special_tokens=a_     )
    UpperCAmelCase													=	tokenizer.decode(output_padded[0]   , skip_special_tokens=a_     )
    self.assertListEqual(a_   , [non_padded_sentence, padded_sentence]     )





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


    """simple docstring"""
    # Confirms that XLA is working properly
    UpperCAmelCase							,      UpperCAmelCase							,      UpperCAmelCase							,      UpperCAmelCase													=	self._get_beam_search_test_objects()

    UpperCAmelCase													=	tokenizer(a_   , return_tensors='tf'   , padding=a_     )
    UpperCAmelCase													=	tf.function(model.generate   , jit_compile=a_     )
    UpperCAmelCase													=	xla_generate(**a_   , do_sample=a_   , num_beams=2     )
    UpperCAmelCase													=	tokenizer.batch_decode(a_   , skip_special_tokens=a_     )
    self.assertListEqual(a_   , a_     )


