






import os
from shutil import copyfile
from typing import List, Optional, Tuple

from tokenizers import processors

from ...tokenization_utils import AddedToken, BatchEncoding
from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import is_sentencepiece_available, logging


if is_sentencepiece_available():
							from .tokenization_mbart import MBartTokenizer
else:
							A_       :int       =						None


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


A_       :Tuple       =						{'''vocab_file''': '''sentencepiece.bpe.model''', '''tokenizer_file''': '''tokenizer.json'''}

A_       :int       =						{
    '''vocab_file''': {
        '''facebook/mbart-large-en-ro''': (
            '''https://huggingface.co/facebook/mbart-large-en-ro/resolve/main/sentencepiece.bpe.model'''
        ),
        '''facebook/mbart-large-cc25''': (
            '''https://huggingface.co/facebook/mbart-large-cc25/resolve/main/sentencepiece.bpe.model'''
        ),
    },
    '''tokenizer_file''': {
        '''facebook/mbart-large-en-ro''': '''https://huggingface.co/facebook/mbart-large-en-ro/resolve/main/tokenizer.json''',
        '''facebook/mbart-large-cc25''': '''https://huggingface.co/facebook/mbart-large-cc25/resolve/main/tokenizer.json''',
    },
}

A_       :Union[str, Any]       =						{
    '''facebook/mbart-large-en-ro''': 1024,
    '''facebook/mbart-large-cc25''': 1024,
}

# fmt: off
A_       :int       =						['''ar_AR''', '''cs_CZ''', '''de_DE''', '''en_XX''', '''es_XX''', '''et_EE''', '''fi_FI''', '''fr_XX''', '''gu_IN''', '''hi_IN''', '''it_IT''', '''ja_XX''', '''kk_KZ''', '''ko_KR''', '''lt_LT''', '''lv_LV''', '''my_MM''', '''ne_NP''', '''nl_XX''', '''ro_RO''', '''ru_RU''', '''si_LK''', '''tr_TR''', '''vi_VN''', '''zh_CN''']




class 				__A     (			a ):





				"""simple docstring"""







				UpperCamelCase__ :      List[str]			 =VOCAB_FILES_NAMES
				UpperCamelCase__ :      Union[str, Any]			 =PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
				UpperCamelCase__ :      Tuple			 =PRETRAINED_VOCAB_FILES_MAP
				UpperCamelCase__ :      str			 =["""input_ids""", """attention_mask"""]
				UpperCamelCase__ :      Any			 =MBartTokenizer

				UpperCamelCase__ :      List[int]			 =[]
				UpperCamelCase__ :      List[int]			 =[]


				def __init__( self							,  lowerCamelCase__=None							,  lowerCamelCase__=None							,  lowerCamelCase__="<s>"							,  lowerCamelCase__="</s>"							,  lowerCamelCase__="</s>"							,  lowerCamelCase__="<s>"							,  lowerCamelCase__="<unk>"							,  lowerCamelCase__="<pad>"							,  lowerCamelCase__="<mask>"							,  lowerCamelCase__=None							,  lowerCamelCase__=None							,  lowerCamelCase__=None							,  **lowerCamelCase__							,  ):




									"""simple docstring"""

									__UpperCamelCase      :					Union[str, Any]       		=AddedToken(lowerCamelCase__							,  lstrip=lowerCamelCase__							,  rstrip=lowerCamelCase__    ) if isinstance(lowerCamelCase__							,  lowerCamelCase__    ) else mask_token

									super().__init__(
									    vocab_file=lowerCamelCase__							,  tokenizer_file=lowerCamelCase__							,  bos_token=lowerCamelCase__							,  eos_token=lowerCamelCase__							,  sep_token=lowerCamelCase__							,  cls_token=lowerCamelCase__							,  unk_token=lowerCamelCase__							,  pad_token=lowerCamelCase__							,  mask_token=lowerCamelCase__							,  src_lang=lowerCamelCase__							,  tgt_lang=lowerCamelCase__							,  additional_special_tokens=lowerCamelCase__							,  **lowerCamelCase__							,  )

									__UpperCamelCase      :					int       		=vocab_file
									__UpperCamelCase      :					Tuple       		=False if not self.vocab_file else True

									__UpperCamelCase      :					Dict       		=FAIRSEQ_LANGUAGE_CODES.copy()

									if additional_special_tokens is not None:
														# Only add those special tokens if they are not already there.
														_additional_special_tokens.extend(
														    [t for t in additional_special_tokens if t not in _additional_special_tokens]    )

									self.add_special_tokens({'additional_special_tokens': _additional_special_tokens}    )
									__UpperCamelCase      :					List[str]       		={
									    lang_code: self.convert_tokens_to_ids(lowerCamelCase__    ) for lang_code in FAIRSEQ_LANGUAGE_CODES
									}

									__UpperCamelCase      :					Optional[Any]       		=src_lang if src_lang is not None else 'en_XX'
									__UpperCamelCase      :					str       		=self.convert_tokens_to_ids(self._src_lang    )
									__UpperCamelCase      :					str       		=tgt_lang
									self.set_src_lang_special_tokens(self._src_lang    )


				@property
				def       __lowercase							( self    ):




									"""simple docstring"""

									return self._src_lang


				@src_lang.setter
				def       __lowercase							( self							,  lowerCamelCase__    ):




									"""simple docstring"""

									__UpperCamelCase      :					Union[str, Any]       		=new_src_lang
									self.set_src_lang_special_tokens(self._src_lang    )


				def       __lowercase							( self							,  lowerCamelCase__							,  lowerCamelCase__ = None    ):




									"""simple docstring"""

									if token_ids_a is None:
														return self.prefix_tokens + token_ids_a + self.suffix_tokens
									# We don't expect to process pairs, but leave the pair logic for API consistency
									return self.prefix_tokens + token_ids_a + token_ids_a + self.suffix_tokens


				def       __lowercase							( self							,  lowerCamelCase__							,  lowerCamelCase__ = None    ):




									"""simple docstring"""

									__UpperCamelCase      :					List[Any]       		=[self.sep_token_id]
									__UpperCamelCase      :					Tuple       		=[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 + sep + token_ids_a + sep    ) * [0]


				def       __lowercase							( self							,  lowerCamelCase__							,  lowerCamelCase__							,  lowerCamelCase__							,  lowerCamelCase__							,  **lowerCamelCase__    ):




									"""simple docstring"""

									if src_lang is None or tgt_lang is None:
														raise ValueError('Translation requires a `src_lang` and a `tgt_lang` for this model'    )
									__UpperCamelCase      :					List[str]       		=src_lang
									__UpperCamelCase      :					List[str]       		=self(lowerCamelCase__							,  add_special_tokens=lowerCamelCase__							,  return_tensors=lowerCamelCase__							,  **lowerCamelCase__    )
									__UpperCamelCase      :					Optional[Any]       		=self.convert_tokens_to_ids(lowerCamelCase__    )
									__UpperCamelCase      :					Optional[int]       		=tgt_lang_id
									return inputs


				def       __lowercase							( self							,  lowerCamelCase__							,  lowerCamelCase__ = "en_XX"							,  lowerCamelCase__ = None							,  lowerCamelCase__ = "ro_RO"							,  **lowerCamelCase__							,  ):




									"""simple docstring"""

									__UpperCamelCase      :					Dict       		=src_lang
									__UpperCamelCase      :					Optional[Any]       		=tgt_lang
									return super().prepare_seqaseq_batch(lowerCamelCase__							,  lowerCamelCase__							,  **lowerCamelCase__    )


				def       __lowercase							( self    ):




									"""simple docstring"""

									return self.set_src_lang_special_tokens(self.src_lang    )


				def       __lowercase							( self    ):




									"""simple docstring"""

									return self.set_tgt_lang_special_tokens(self.tgt_lang    )


				def       __lowercase							( self							,  lowerCamelCase__    ):




									"""simple docstring"""

									__UpperCamelCase      :					Optional[Any]       		=self.convert_tokens_to_ids(lowerCamelCase__    )
									__UpperCamelCase      :					Tuple       		=[]
									__UpperCamelCase      :					Optional[Any]       		=[self.eos_token_id, self.cur_lang_code]

									__UpperCamelCase      :					Optional[Any]       		=self.convert_ids_to_tokens(self.prefix_tokens    )
									__UpperCamelCase      :					List[Any]       		=self.convert_ids_to_tokens(self.suffix_tokens    )

									__UpperCamelCase      :					Union[str, Any]       		=processors.TemplateProcessing(
									    single=prefix_tokens_str + ['$A'] + suffix_tokens_str							,  pair=prefix_tokens_str + ['$A', '$B'] + suffix_tokens_str							,  special_tokens=list(zip(prefix_tokens_str + suffix_tokens_str							,  self.prefix_tokens + self.suffix_tokens    )    )							,  )


				def       __lowercase							( self							,  lowerCamelCase__    ):




									"""simple docstring"""

									__UpperCamelCase      :					Union[str, Any]       		=self.convert_tokens_to_ids(lowerCamelCase__    )
									__UpperCamelCase      :					int       		=[]
									__UpperCamelCase      :					List[str]       		=[self.eos_token_id, self.cur_lang_code]

									__UpperCamelCase      :					Optional[int]       		=self.convert_ids_to_tokens(self.prefix_tokens    )
									__UpperCamelCase      :					Dict       		=self.convert_ids_to_tokens(self.suffix_tokens    )

									__UpperCamelCase      :					List[str]       		=processors.TemplateProcessing(
									    single=prefix_tokens_str + ['$A'] + suffix_tokens_str							,  pair=prefix_tokens_str + ['$A', '$B'] + suffix_tokens_str							,  special_tokens=list(zip(prefix_tokens_str + suffix_tokens_str							,  self.prefix_tokens + self.suffix_tokens    )    )							,  )







				def       __lowercase							( self							,  lowerCamelCase__							,  lowerCamelCase__ = None    ):




									"""simple docstring"""

									if not self.can_save_slow_tokenizer:
														raise ValueError(
														    'Your fast tokenizer does not have the necessary information to save the vocabulary for a slow '
														    'tokenizer.'    )

									if not os.path.isdir(lowerCamelCase__    ):
														logger.error(f'Vocabulary path ({save_directory}) should be a directory.'    )
														return
									__UpperCamelCase      :					List[Any]       		=os.path.join(
									    lowerCamelCase__							,  (filename_prefix + '-' if filename_prefix else '') + VOCAB_FILES_NAMES['vocab_file']    )

									if os.path.abspath(self.vocab_file    ) != os.path.abspath(lowerCamelCase__    ):
														copyfile(self.vocab_file							,  lowerCamelCase__    )

									return (out_vocab_file,)





import unittest

from transformers import SqueezeBertConfig, is_torch_available
from transformers.testing_utils import require_sentencepiece, require_tokenizers, require_torch, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
 import torch

 from transformers import (
     SQUEEZEBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
     SqueezeBertForMaskedLM,
     SqueezeBertForMultipleChoice,
     SqueezeBertForQuestionAnswering,
     SqueezeBertForSequenceClassification,
     SqueezeBertForTokenClassification,
     SqueezeBertModel,
 )






class _lowerCamelCase(						_a   ):
       def __init__(					self,      lowerCamelCase,      lowerCamelCase=13,      lowerCamelCase=7,      lowerCamelCase=True,      lowerCamelCase=True,      lowerCamelCase=False,      lowerCamelCase=True,      lowerCamelCase=99,      lowerCamelCase=32,      lowerCamelCase=5,      lowerCamelCase=4,      lowerCamelCase=64,      lowerCamelCase="gelu",      lowerCamelCase=0.1,      lowerCamelCase=0.1,      lowerCamelCase=5_12,      lowerCamelCase=16,      lowerCamelCase=2,      lowerCamelCase=0.0_2,      lowerCamelCase=3,      lowerCamelCase=4,      lowerCamelCase=None,      lowerCamelCase=2,      lowerCamelCase=2,      lowerCamelCase=2,      lowerCamelCase=2,      lowerCamelCase=4,      lowerCamelCase=1,      )       ->   Union[str, Any]:




           """simple docstring"""

           _lowercase       :							Dict      		=		parent
           _lowercase       :							Optional[Any]      		=		batch_size
           _lowercase       :							Any      		=		seq_length
           _lowercase       :							Optional[Any]      		=		is_training
           _lowercase       :							Optional[Any]      		=		use_input_mask
           _lowercase       :							List[Any]      		=		use_token_type_ids
           _lowercase       :							List[str]      		=		use_labels
           _lowercase       :							str      		=		vocab_size
           _lowercase       :							List[str]      		=		hidden_size
           _lowercase       :							Dict      		=		num_hidden_layers
           _lowercase       :							List[str]      		=		num_attention_heads
           _lowercase       :							int      		=		intermediate_size
           _lowercase       :							Union[str, Any]      		=		hidden_act
           _lowercase       :							int      		=		hidden_dropout_prob
           _lowercase       :							List[Any]      		=		attention_probs_dropout_prob
           _lowercase       :							Dict      		=		max_position_embeddings
           _lowercase       :							Union[str, Any]      		=		type_vocab_size
           _lowercase       :							List[Any]      		=		type_sequence_label_size
           _lowercase       :							Any      		=		initializer_range
           _lowercase       :							List[str]      		=		num_labels
           _lowercase       :							Any      		=		num_choices
           _lowercase       :							Tuple      		=		scope
           _lowercase       :							Optional[Any]      		=		q_groups
           _lowercase       :							List[str]      		=		k_groups
           _lowercase       :							Optional[int]      		=		v_groups
           _lowercase       :							List[str]      		=		post_attention_groups
           _lowercase       :							Union[str, Any]      		=		intermediate_groups
           _lowercase       :							int      		=		output_groups
       def 			UpperCamelCase     (					self)       ->   Optional[int]:




           """simple docstring"""

           _lowercase       :							int      		=		ids_tensor([self.batch_size, self.seq_length],      self.vocab_size)

           _lowercase       :							Any      		=		None
           if self.use_input_mask:
               _lowercase       :							Tuple      		=		random_attention_mask([self.batch_size, self.seq_length])

           _lowercase       :							Dict      		=		None
           _lowercase       :							int      		=		None
           _lowercase       :							List[Any]      		=		None
           if self.use_labels:
               _lowercase       :							List[Any]      		=		ids_tensor([self.batch_size],      self.type_sequence_label_size)
               _lowercase       :							int      		=		ids_tensor([self.batch_size, self.seq_length],      self.num_labels)
               _lowercase       :							Dict      		=		ids_tensor([self.batch_size],      self.num_choices)

           _lowercase       :							Optional[Any]      		=		self.get_config()

           return config, input_ids, input_mask, sequence_labels, token_labels, choice_labels
       def 			UpperCamelCase     (					self)       ->   Optional[int]:




           """simple docstring"""

           return SqueezeBertConfig(
               embedding_size=self.hidden_size,      vocab_size=self.vocab_size,      hidden_size=self.hidden_size,      num_hidden_layers=self.num_hidden_layers,      num_attention_heads=self.num_attention_heads,      intermediate_size=self.intermediate_size,      hidden_act=self.hidden_act,      attention_probs_dropout_prob=self.hidden_dropout_prob,      attention_dropout=self.attention_probs_dropout_prob,      max_position_embeddings=self.max_position_embeddings,      initializer_range=self.initializer_range,      q_groups=self.q_groups,      k_groups=self.k_groups,      v_groups=self.v_groups,      post_attention_groups=self.post_attention_groups,      intermediate_groups=self.intermediate_groups,      output_groups=self.output_groups,      )
       def 			UpperCamelCase     (					self,      lowerCamelCase,      lowerCamelCase,      lowerCamelCase,      lowerCamelCase,      lowerCamelCase,      lowerCamelCase)       ->   Union[str, Any]:




           """simple docstring"""

           _lowercase       :							List[str]      		=		SqueezeBertModel(config=lowerCamelCase)
           model.to(lowerCamelCase)
           model.eval()
           _lowercase       :							Dict      		=		model(lowerCamelCase,      lowerCamelCase)
           _lowercase       :							Any      		=		model(lowerCamelCase)
           self.parent.assertEqual(result.last_hidden_state.shape,      (self.batch_size, self.seq_length, self.hidden_size))
       def 			UpperCamelCase     (					self,      lowerCamelCase,      lowerCamelCase,      lowerCamelCase,      lowerCamelCase,      lowerCamelCase,      lowerCamelCase)       ->   int:




           """simple docstring"""

           _lowercase       :							Dict      		=		SqueezeBertForMaskedLM(config=lowerCamelCase)
           model.to(lowerCamelCase)
           model.eval()
           _lowercase       :							Optional[Any]      		=		model(lowerCamelCase,      attention_mask=lowerCamelCase,      labels=lowerCamelCase)
           self.parent.assertEqual(result.logits.shape,      (self.batch_size, self.seq_length, self.vocab_size))
       def 			UpperCamelCase     (					self,      lowerCamelCase,      lowerCamelCase,      lowerCamelCase,      lowerCamelCase,      lowerCamelCase,      lowerCamelCase)       ->   Union[str, Any]:




           """simple docstring"""

           _lowercase       :							Union[str, Any]      		=		SqueezeBertForQuestionAnswering(config=lowerCamelCase)
           model.to(lowerCamelCase)
           model.eval()
           _lowercase       :							List[Any]      		=		model(
               lowerCamelCase,      attention_mask=lowerCamelCase,      start_positions=lowerCamelCase,      end_positions=lowerCamelCase)
           self.parent.assertEqual(result.start_logits.shape,      (self.batch_size, self.seq_length))
           self.parent.assertEqual(result.end_logits.shape,      (self.batch_size, self.seq_length))
       def 			UpperCamelCase     (					self,      lowerCamelCase,      lowerCamelCase,      lowerCamelCase,      lowerCamelCase,      lowerCamelCase,      lowerCamelCase)       ->   str:




           """simple docstring"""

           _lowercase       :							Optional[Any]      		=		self.num_labels
           _lowercase       :							int      		=		SqueezeBertForSequenceClassification(lowerCamelCase)
           model.to(lowerCamelCase)
           model.eval()
           _lowercase       :							Any      		=		model(lowerCamelCase,      attention_mask=lowerCamelCase,      labels=lowerCamelCase)
           self.parent.assertEqual(result.logits.shape,      (self.batch_size, self.num_labels))
       def 			UpperCamelCase     (					self,      lowerCamelCase,      lowerCamelCase,      lowerCamelCase,      lowerCamelCase,      lowerCamelCase,      lowerCamelCase)       ->   List[Any]:




           """simple docstring"""

           _lowercase       :							Union[str, Any]      		=		self.num_labels
           _lowercase       :							List[str]      		=		SqueezeBertForTokenClassification(config=lowerCamelCase)
           model.to(lowerCamelCase)
           model.eval()

           _lowercase       :							Union[str, Any]      		=		model(lowerCamelCase,      attention_mask=lowerCamelCase,      labels=lowerCamelCase)
           self.parent.assertEqual(result.logits.shape,      (self.batch_size, self.seq_length, self.num_labels))
       def 			UpperCamelCase     (					self,      lowerCamelCase,      lowerCamelCase,      lowerCamelCase,      lowerCamelCase,      lowerCamelCase,      lowerCamelCase)       ->   Dict:




           """simple docstring"""

           _lowercase       :							str      		=		self.num_choices
           _lowercase       :							str      		=		SqueezeBertForMultipleChoice(config=lowerCamelCase)
           model.to(lowerCamelCase)
           model.eval()
           _lowercase       :							Dict      		=		input_ids.unsqueeze(1).expand(-1,      self.num_choices,      -1).contiguous()
           _lowercase       :							int      		=		input_mask.unsqueeze(1).expand(-1,      self.num_choices,      -1).contiguous()
           _lowercase       :							Optional[Any]      		=		model(
               lowerCamelCase,      attention_mask=lowerCamelCase,      labels=lowerCamelCase,      )
           self.parent.assertEqual(result.logits.shape,      (self.batch_size, self.num_choices))




       def 			UpperCamelCase     (					self)       ->   List[str]:




           """simple docstring"""

           _lowercase       :							Optional[int]      		=		self.prepare_config_and_inputs()
           ((_lowercase)		,				(_lowercase)		,				(_lowercase)		,				(_lowercase)		,				(_lowercase)		,				(_lowercase))       :							Dict      		=		config_and_inputs
           _lowercase       :							Tuple      		=		{'input_ids': input_ids, 'attention_mask': input_mask}
           return config, inputs_dict






@require_torch
class _lowerCamelCase(						_a, _a, unittest.TestCase   ):
       lowercase_ :	Union[str, Any]     =			(
           (
               SqueezeBertModel,
               SqueezeBertForMaskedLM,
               SqueezeBertForMultipleChoice,
               SqueezeBertForQuestionAnswering,
               SqueezeBertForSequenceClassification,
               SqueezeBertForTokenClassification,
           )
           if is_torch_available()
           else None
       )
       lowercase_ :	Optional[int]     =			(
           {
               """feature-extraction""": SqueezeBertModel,
               """fill-mask""": SqueezeBertForMaskedLM,
               """question-answering""": SqueezeBertForQuestionAnswering,
               """text-classification""": SqueezeBertForSequenceClassification,
               """token-classification""": SqueezeBertForTokenClassification,
               """zero-shot""": SqueezeBertForSequenceClassification,
           }
           if is_torch_available()
           else {}
       )
       lowercase_ :	Tuple     =			False
       lowercase_ :	List[str]     =			True
       lowercase_ :	int     =			False
       def 			UpperCamelCase     (					self)       ->   int:




           """simple docstring"""

           _lowercase       :							str      		=		SqueezeBertModelTester(self)
           _lowercase       :							Dict      		=		ConfigTester(self,      config_class=lowerCamelCase,      dim=37)
       def 			UpperCamelCase     (					self)       ->   List[str]:




           """simple docstring"""

           self.config_tester.run_common_tests()
       def 			UpperCamelCase     (					self)       ->   Tuple:




           """simple docstring"""

           _lowercase       :							Optional[Any]      		=		self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_squeezebert_model(*lowerCamelCase)
       def 			UpperCamelCase     (					self)       ->   List[str]:




           """simple docstring"""

           _lowercase       :							Any      		=		self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_squeezebert_for_masked_lm(*lowerCamelCase)
       def 			UpperCamelCase     (					self)       ->   Any:




           """simple docstring"""

           _lowercase       :							List[Any]      		=		self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_squeezebert_for_question_answering(*lowerCamelCase)
       def 			UpperCamelCase     (					self)       ->   Union[str, Any]:




           """simple docstring"""

           _lowercase       :							Union[str, Any]      		=		self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_squeezebert_for_sequence_classification(*lowerCamelCase)
       def 			UpperCamelCase     (					self)       ->   Any:




           """simple docstring"""

           _lowercase       :							List[Any]      		=		self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_squeezebert_for_token_classification(*lowerCamelCase)
       def 			UpperCamelCase     (					self)       ->   Optional[int]:




           """simple docstring"""

           _lowercase       :							Optional[Any]      		=		self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_squeezebert_for_multiple_choice(*lowerCamelCase)




       @slow
       def 			UpperCamelCase     (					self)       ->   Dict:




           """simple docstring"""

           for model_name in SQUEEZEBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
               _lowercase       :							List[Any]      		=		SqueezeBertModel.from_pretrained(lowerCamelCase)
               self.assertIsNotNone(lowerCamelCase)






@require_sentencepiece
@require_tokenizers
@require_torch
class _lowerCamelCase(						unittest.TestCase   ):
       @slow
       def 			UpperCamelCase     (					self)       ->   Optional[Any]:




           """simple docstring"""

           _lowercase       :							Union[str, Any]      		=		SqueezeBertForSequenceClassification.from_pretrained('squeezebert/squeezebert-mnli')

           _lowercase       :							Optional[int]      		=		torch.tensor([[1, 2_94_14, 2_32, 3_28, 7_40, 11_40, 1_26_95, 69, 13, 15_88, 2]])
           _lowercase       :							List[str]      		=		model(lowerCamelCase)[0]
           _lowercase       :							Union[str, Any]      		=		torch.Size((1, 3))
           self.assertEqual(output.shape,      lowerCamelCase)
           _lowercase       :							Tuple      		=		torch.tensor([[0.6_4_0_1, -0.0_3_4_9, -0.6_0_4_1]])
           self.assertTrue(torch.allclose(lowerCamelCase,      lowerCamelCase,      atol=1E-4))


