





import os
import re
import shutil
import sys
import tempfile
import unittest

import black


UpperCAmelCase_  							=				os.path.abspath(os.path.dirname(os.path.dirname(os.path.dirname(__file__))))
sys.path.append(os.path.join(git_repo_path, 'utils'))

import check_copies  # noqa: E402


# This is the reference code that will be used in the tests.
# If BertLMPredictionHead is changed in modeling_bert.py, this code needs to be manually updated.
UpperCAmelCase_  							=				'    def __init__(self, config):\n        super().__init__()\n        self.transform = BertPredictionHeadTransform(config)\n\n        # The output weights are the same as the input embeddings, but there is\n        # an output-only bias for each token.\n        self.decoder = nn.Linear(config.hidden_size, config.vocab_size, bias=False)\n\n        self.bias = nn.Parameter(torch.zeros(config.vocab_size))\n\n        # Need a link between the two variables so that the bias is correctly resized with `resize_token_embeddings`\n        self.decoder.bias = self.bias\n\n    def forward(self, hidden_states):\n        hidden_states = self.transform(hidden_states)\n        hidden_states = self.decoder(hidden_states)\n        return hidden_states\n'






class 					lowercase__ (			unittest.TestCase       ):

     '''simple docstring'''


     def    UpperCamelCase__						(					self							)				->   Optional[Any]:






         """simple docstring"""
         UpperCamelCase__							:       Optional[Any]      =   tempfile.mkdtemp()
         os.makedirs(os.path.join(self.transformer_dir,	'''models/bert/'''							)							)
         UpperCamelCase__							:       Optional[Any]      =   self.transformer_dir
         shutil.copy(
             os.path.join(__magic_name__,	'''src/transformers/models/bert/modeling_bert.py'''							),	os.path.join(self.transformer_dir,	'''models/bert/modeling_bert.py'''							),	)




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






         """simple docstring"""
         UpperCamelCase__							:       List[Any]      =   '''src/transformers'''
         shutil.rmtree(self.transformer_dir							)




     def    UpperCamelCase__						(					self,	__magic_name__,	__magic_name__,	__magic_name__,	__magic_name__=None							)				->   Tuple:






         """simple docstring"""
         UpperCamelCase__							:       int      =   comment + f"\nclass {class_name}(nn.Module):\n" + class_code
         if overwrite_result is not None:
             UpperCamelCase__							:       str      =   comment + f"\nclass {class_name}(nn.Module):\n" + overwrite_result
         UpperCamelCase__							:       int      =   black.Mode(target_versions={black.TargetVersion.PYaa},	line_length=119							)
         UpperCamelCase__							:       str      =   black.format_str(__magic_name__,	mode=__magic_name__							)
         UpperCamelCase__							:       Any      =   os.path.join(self.transformer_dir,	'''new_code.py'''							)
         with open(__magic_name__,	'''w''',	newline='''\n'''							) as f:
             f.write(__magic_name__							)
         if overwrite_result is None:
             self.assertTrue(len(check_copies.is_copy_consistent(__magic_name__							)							) == 0							)
         else:
             check_copies.is_copy_consistent(f.name,	overwrite=__magic_name__							)
             with open(__magic_name__,	'''r'''							) as f:
                 self.assertTrue(f.read(),	__magic_name__							)




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






         """simple docstring"""
         UpperCamelCase__							:       Optional[int]      =   check_copies.find_code_in_transformers('''models.bert.modeling_bert.BertLMPredictionHead'''							)
         self.assertEqual(__magic_name__,	__magic_name__							)




     def    UpperCamelCase__						(					self							)				->   str:






         """simple docstring"""
         self.check_copy_consistency(
             '''# Copied from transformers.models.bert.modeling_bert.BertLMPredictionHead''',	'''BertLMPredictionHead''',	REFERENCE_CODE + '''\n''',	)

         # With no empty line at the end
         self.check_copy_consistency(
             '''# Copied from transformers.models.bert.modeling_bert.BertLMPredictionHead''',	'''BertLMPredictionHead''',	__magic_name__,	)

         # Copy consistency with rename
         self.check_copy_consistency(
             '''# Copied from transformers.models.bert.modeling_bert.BertLMPredictionHead with Bert->TestModel''',	'''TestModelLMPredictionHead''',	re.sub('''Bert''',	'''TestModel''',	__magic_name__							),	)

         # Copy consistency with a really long name
         UpperCamelCase__							:       List[str]      =   '''TestModelWithAReallyLongNameBecauseSomePeopleLikeThatForSomeReason'''
         self.check_copy_consistency(
             f"# Copied from transformers.models.bert.modeling_bert.BertLMPredictionHead with Bert->{long_class_name}",	f"{long_class_name}LMPredictionHead",	re.sub('''Bert''',	__magic_name__,	__magic_name__							),	)

         # Copy consistency with overwrite
         self.check_copy_consistency(
             '''# Copied from transformers.models.bert.modeling_bert.BertLMPredictionHead with Bert->TestModel''',	'''TestModelLMPredictionHead''',	__magic_name__,	overwrite_result=re.sub('''Bert''',	'''TestModel''',	__magic_name__							),	)




     def    UpperCamelCase__						(					self							)				->   Any:






         """simple docstring"""
         UpperCamelCase__							:       Tuple      =   check_copies.LOCALIZED_READMES['''README_zh-hans.md''']

         UpperCamelCase__							:       Optional[int]      =   (
             '''1. **[ALBERT](https://huggingface.co/transformers/model_doc/albert.html)** (from Google Research and the'''
             ''' Toyota Technological Institute at Chicago) released with the paper [ALBERT: A Lite BERT for'''
             ''' Self-supervised Learning of Language Representations](https://arxiv.org/abs/1909.11942), by Zhenzhong'''
             ''' Lan, Mingda Chen, Sebastian Goodman, Kevin Gimpel, Piyush Sharma, Radu Soricut.\n1.'''
             ''' **[DistilBERT](https://huggingface.co/transformers/model_doc/distilbert.html)** (from HuggingFace),'''
             ''' released together with the paper [DistilBERT, a distilled version of BERT: smaller, faster, cheaper and'''
             ''' lighter](https://arxiv.org/abs/1910.01108) by Victor Sanh, Lysandre Debut and Thomas Wolf. The same'''
             ''' method has been applied to compress GPT2 into'''
             ''' [DistilGPT2](https://github.com/huggingface/transformers/tree/main/examples/distillation), RoBERTa into'''
             ''' [DistilRoBERTa](https://github.com/huggingface/transformers/tree/main/examples/distillation),'''
             ''' Multilingual BERT into'''
             ''' [DistilmBERT](https://github.com/huggingface/transformers/tree/main/examples/distillation) and a German'''
             ''' version of DistilBERT.\n1. **[ELECTRA](https://huggingface.co/transformers/model_doc/electra.html)**'''
             ''' (from Google Research/Stanford University) released with the paper [ELECTRA: Pre-training text encoders'''
             ''' as discriminators rather than generators](https://arxiv.org/abs/2003.10555) by Kevin Clark, Minh-Thang'''
             ''' Luong, Quoc V. Le, Christopher D. Manning.'''
         )
         UpperCamelCase__							:       Optional[Any]      =   (
             '''1. **[ALBERT](https://huggingface.co/transformers/model_doc/albert.html)** (来自 Google Research and the'''
             ''' Toyota Technological Institute at Chicago) 伴随论文 [ALBERT: A Lite BERT for Self-supervised Learning of'''
             ''' Language Representations](https://arxiv.org/abs/1909.11942), 由 Zhenzhong Lan, Mingda Chen, Sebastian'''
             ''' Goodman, Kevin Gimpel, Piyush Sharma, Radu Soricut 发布。\n'''
         )
         UpperCamelCase__							:       List[str]      =   (
             '''1. **[ALBERT](https://huggingface.co/transformers/model_doc/albert.html)** (来自 Google Research and the'''
             ''' Toyota Technological Institute at Chicago) 伴随论文 [ALBERT: A Lite BERT for Self-supervised Learning of'''
             ''' Language Representations](https://arxiv.org/abs/1909.11942), 由 Zhenzhong Lan, Mingda Chen, Sebastian'''
             ''' Goodman, Kevin Gimpel, Piyush Sharma, Radu Soricut 发布。\n1.'''
             ''' **[DistilBERT](https://huggingface.co/transformers/model_doc/distilbert.html)** (来自 HuggingFace) 伴随论文'''
             ''' [DistilBERT, a distilled version of BERT: smaller, faster, cheaper and'''
             ''' lighter](https://arxiv.org/abs/1910.01108) 由 Victor Sanh, Lysandre Debut and Thomas Wolf 发布。 The same'''
             ''' method has been applied to compress GPT2 into'''
             ''' [DistilGPT2](https://github.com/huggingface/transformers/tree/main/examples/distillation), RoBERTa into'''
             ''' [DistilRoBERTa](https://github.com/huggingface/transformers/tree/main/examples/distillation),'''
             ''' Multilingual BERT into'''
             ''' [DistilmBERT](https://github.com/huggingface/transformers/tree/main/examples/distillation) and a German'''
             ''' version of DistilBERT.\n1. **[ELECTRA](https://huggingface.co/transformers/model_doc/electra.html)** (来自'''
             ''' Google Research/Stanford University) 伴随论文 [ELECTRA: Pre-training text encoders as discriminators rather'''
             ''' than generators](https://arxiv.org/abs/2003.10555) 由 Kevin Clark, Minh-Thang Luong, Quoc V. Le,'''
             ''' Christopher D. Manning 发布。\n'''
         )

         UpperCamelCase__							:       Any      =   check_copies.convert_to_localized_md(
             __magic_name__,	__magic_name__,	localized_readme['''format_model_list''']							)

         self.assertFalse(__magic_name__							)
         self.assertEqual(__magic_name__,	__magic_name__							)

         UpperCamelCase__							:       Any      =   check_copies.convert_to_localized_md(
             __magic_name__,	__magic_name__,	localized_readme['''format_model_list''']							)

         # Check whether the number of models is equal to README.md after conversion.
         self.assertTrue(__magic_name__							)

         UpperCamelCase__							:       Any      =   (
             '''1. **[ALBERT](https://huggingface.co/transformers/model_doc/albert.html)** (from Google Research and the'''
             ''' Toyota Technological Institute at Chicago) released with the paper [ALBERT: A Lite BERT for'''
             ''' Self-supervised Learning of Language Representations](https://arxiv.org/abs/1909.11942), by Zhenzhong'''
             ''' Lan, Mingda Chen, Sebastian Goodman, Kevin Gimpel, Piyush Sharma, Radu Soricut.'''
         )
         UpperCamelCase__							:       List[str]      =   (
             '''1. **[ALBERT](https://huggingface.co/transformers/main/model_doc/albert.html)** (来自 Google Research and'''
             ''' the Toyota Technological Institute at Chicago) 伴随论文 [ALBERT: A Lite BERT for Self-supervised Learning of'''
             ''' Language Representations](https://arxiv.org/abs/1909.11942), 由 Zhenzhong Lan, Mingda Chen, Sebastian'''
             ''' Goodman, Kevin Gimpel, Piyush Sharma, Radu Soricut 发布。\n'''
         )
         UpperCamelCase__							:       List[str]      =   (
             '''1. **[ALBERT](https://huggingface.co/transformers/model_doc/albert.html)** (来自 Google Research and the'''
             ''' Toyota Technological Institute at Chicago) 伴随论文 [ALBERT: A Lite BERT for Self-supervised Learning of'''
             ''' Language Representations](https://arxiv.org/abs/1909.11942), 由 Zhenzhong Lan, Mingda Chen, Sebastian'''
             ''' Goodman, Kevin Gimpel, Piyush Sharma, Radu Soricut 发布。\n'''
         )

         UpperCamelCase__							:       Any      =   check_copies.convert_to_localized_md(
             __magic_name__,	__magic_name__,	localized_readme['''format_model_list''']							)

         # Check if the model link is synchronized.
         self.assertEqual(__magic_name__,	__magic_name__							)








import inspect
import unittest
from math import floor

from transformers import CvtConfig
from transformers.file_utils import cached_property, is_torch_available, is_vision_available
from transformers.testing_utils import require_torch, require_vision, slow, torch_device

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 transformers import CvtForImageClassification, CvtModel
  from transformers.models.cvt.modeling_cvt import CVT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
  from PIL import Image

  from transformers import AutoImageProcessor






class 					lowercase__ (			__lowerCamelCase       ):

   '''simple docstring'''


   def    UpperCamelCase__						(					self							)				->   Optional[Any]:






       """simple docstring"""
       UpperCamelCase__							:       Optional[Any]      =   self.config_class(**self.inputs_dict							)
       self.parent.assertTrue(hasattr(__magic_name__,	'''embed_dim'''							)							)
       self.parent.assertTrue(hasattr(__magic_name__,	'''num_heads'''							)							)






class 					lowercase__ :

   '''simple docstring'''


   def __init__(					self,	__magic_name__,	__magic_name__=13,	__magic_name__=64,	__magic_name__=3,	__magic_name__=[16, 48, 96],	__magic_name__=[1, 3, 6],	__magic_name__=[1, 2, 10],	__magic_name__=[7, 3, 3],	__magic_name__=[4, 2, 2],	__magic_name__=[2, 1, 1],	__magic_name__=[2, 2, 2],	__magic_name__=[False, False, True],	__magic_name__=[0.0, 0.0, 0.0],	__magic_name__=0.02,	__magic_name__=1E-12,	__magic_name__=True,	__magic_name__=True,	__magic_name__=2,	)				->   int:






       """simple docstring"""
       UpperCamelCase__							:       Optional[int]      =   parent
       UpperCamelCase__							:       Optional[Any]      =   batch_size
       UpperCamelCase__							:       Dict      =   image_size
       UpperCamelCase__							:       Optional[Any]      =   patch_sizes
       UpperCamelCase__							:       List[str]      =   patch_stride
       UpperCamelCase__							:       Tuple      =   patch_padding
       UpperCamelCase__							:       Dict      =   is_training
       UpperCamelCase__							:       Optional[int]      =   use_labels
       UpperCamelCase__							:       Union[str, Any]      =   num_labels
       UpperCamelCase__							:       List[Any]      =   num_channels
       UpperCamelCase__							:       Optional[Any]      =   embed_dim
       UpperCamelCase__							:       List[str]      =   num_heads
       UpperCamelCase__							:       Any      =   stride_kv
       UpperCamelCase__							:       Any      =   depth
       UpperCamelCase__							:       Tuple      =   cls_token
       UpperCamelCase__							:       List[Any]      =   attention_drop_rate
       UpperCamelCase__							:       Any      =   initializer_range
       UpperCamelCase__							:       str      =   layer_norm_eps




   def    UpperCamelCase__						(					self							)				->   Any:






       """simple docstring"""
       UpperCamelCase__							:       Optional[int]      =   floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]							)

       UpperCamelCase__							:       int      =   None
       if self.use_labels:
           UpperCamelCase__							:       Optional[int]      =   ids_tensor([self.batch_size],	self.num_labels							)

       UpperCamelCase__							:       str      =   self.get_config()
       return config, pixel_values, labels




   def    UpperCamelCase__						(					self							)				->   int:






       """simple docstring"""
       return CvtConfig(
           image_size=self.image_size,	num_labels=self.num_labels,	num_channels=self.num_channels,	embed_dim=self.embed_dim,	num_heads=self.num_heads,	patch_sizes=self.patch_sizes,	patch_padding=self.patch_padding,	patch_stride=self.patch_stride,	stride_kv=self.stride_kv,	depth=self.depth,	cls_token=self.cls_token,	attention_drop_rate=self.attention_drop_rate,	initializer_range=self.initializer_range,	)




   def    UpperCamelCase__						(					self,	__magic_name__,	__magic_name__,	__magic_name__							)				->   Optional[Any]:






       """simple docstring"""
       UpperCamelCase__							:       Optional[Any]      =   CvtModel(config=__magic_name__							)
       model.to(__magic_name__							)
       model.eval()
       UpperCamelCase__							:       Optional[int]      =   model(__magic_name__							)
       UpperCamelCase__							:       List[str]      =   (self.image_size, self.image_size)
       UpperCamelCase__     ,UpperCamelCase__							:       Tuple      =   image_size[0], image_size[1]
       for i in range(len(self.depth							)							):
           UpperCamelCase__							:       Optional[int]      =   floor(((height + 2 * self.patch_padding[i] - self.patch_sizes[i]) / self.patch_stride[i]) + 1							)
           UpperCamelCase__							:       int      =   floor(((width + 2 * self.patch_padding[i] - self.patch_sizes[i]) / self.patch_stride[i]) + 1							)
       self.parent.assertEqual(result.last_hidden_state.shape,	(self.batch_size, self.embed_dim[-1], height, width)							)




   def    UpperCamelCase__						(					self,	__magic_name__,	__magic_name__,	__magic_name__							)				->   List[str]:






       """simple docstring"""
       UpperCamelCase__							:       Tuple      =   self.num_labels
       UpperCamelCase__							:       str      =   CvtForImageClassification(__magic_name__							)
       model.to(__magic_name__							)
       model.eval()
       UpperCamelCase__							:       Any      =   model(__magic_name__,	labels=__magic_name__							)
       self.parent.assertEqual(result.logits.shape,	(self.batch_size, self.num_labels)							)




   def    UpperCamelCase__						(					self							)				->   Optional[Any]:






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






@require_torch
class 					lowercase__ (			__lowerCamelCase    ,       __lowerCamelCase    ,       unittest.TestCase       ):

   '''simple docstring'''


   a		:							List[Any]     	=	(CvtModel, CvtForImageClassification) if is_torch_available() else ()
   a		:							Any     	=	(
       {"feature-extraction": CvtModel, "image-classification": CvtForImageClassification}
       if is_torch_available()
       else {}
   )

   a		:							List[str]     	=	False
   a		:							int     	=	False
   a		:							Tuple     	=	False
   a		:							int     	=	False
   a		:							Tuple     	=	False




   def    UpperCamelCase__						(					self							)				->   str:






       """simple docstring"""
       UpperCamelCase__							:       Dict      =   CvtModelTester(self							)
       UpperCamelCase__							:       List[Any]      =   ConfigTester(self,	config_class=__magic_name__,	has_text_modality=__magic_name__,	hidden_size=37							)




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






       """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    UpperCamelCase__						(					self							)				->   List[str]:






       """simple docstring"""
       return




   @unittest.skip(reason='''Cvt does not output attentions'''							)
   def    UpperCamelCase__						(					self							)				->   Dict:






       """simple docstring"""
       pass




   @unittest.skip(reason='''Cvt does not use inputs_embeds'''							)
   def    UpperCamelCase__						(					self							)				->   Tuple:






       """simple docstring"""
       pass




   @unittest.skip(reason='''Cvt does not support input and output embeddings'''							)
   def    UpperCamelCase__						(					self							)				->   Dict:






       """simple docstring"""
       pass




   def    UpperCamelCase__						(					self							)				->   Optional[Any]:






       """simple docstring"""
       UpperCamelCase__     ,UpperCamelCase__							:       Optional[int]      =   self.model_tester.prepare_config_and_inputs_for_common()

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

           UpperCamelCase__							:       Tuple      =   ['''pixel_values''']
           self.assertListEqual(arg_names[:1],	__magic_name__							)




   def    UpperCamelCase__						(					self							)				->   Tuple:






       """simple docstring"""
       UpperCamelCase__							:       Union[str, Any]      =   self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_model(*__magic_name__							)




   def    UpperCamelCase__						(					self							)				->   Dict:






       """simple docstring"""
       def check_hidden_states_output(__magic_name__,	__magic_name__,	__magic_name__							):
           UpperCamelCase__							:       str      =   model_class(__magic_name__							)
           model.to(__magic_name__							)
           model.eval()

           with torch.no_grad():
               UpperCamelCase__							:       List[Any]      =   model(**self._prepare_for_class(__magic_name__,	__magic_name__							)							)

           UpperCamelCase__							:       str      =   outputs.hidden_states

           UpperCamelCase__							:       Dict      =   len(self.model_tester.depth							)
           self.assertEqual(len(__magic_name__							),	__magic_name__							)

           # verify the first hidden states (first block)
           self.assertListEqual(
               list(hidden_states[0].shape[-3:]							),	[
                   self.model_tester.embed_dim[0],
                   self.model_tester.image_size // 4,
                   self.model_tester.image_size // 4,
               ],	)

       UpperCamelCase__     ,UpperCamelCase__							:       List[str]      =   self.model_tester.prepare_config_and_inputs_for_common()

       for model_class in self.all_model_classes:
           UpperCamelCase__							:       Optional[int]      =   True
           check_hidden_states_output(__magic_name__,	__magic_name__,	__magic_name__							)

           # check that output_hidden_states also work using config
           del inputs_dict["output_hidden_states"]
           UpperCamelCase__							:       int      =   True

           check_hidden_states_output(__magic_name__,	__magic_name__,	__magic_name__							)




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






       """simple docstring"""
       UpperCamelCase__							:       Optional[int]      =   self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_image_classification(*__magic_name__							)




   @unittest.skip('''Will be fixed soon by reducing the size of the model used for common tests.'''							)
   def    UpperCamelCase__						(					self							)				->   Optional[Any]:






       """simple docstring"""
       pass




   @slow
   def    UpperCamelCase__						(					self							)				->   Tuple:






       """simple docstring"""
       for model_name in CVT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
           UpperCamelCase__							:       Union[str, Any]      =   CvtModel.from_pretrained(__magic_name__							)
           self.assertIsNotNone(__magic_name__							)




def 	lowerCAmelCase_					(						)   ->			int:
    UpperCamelCase__							:       Tuple      =   Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''   )
    return image






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

   '''simple docstring'''


   @cached_property
   def    UpperCamelCase__						(					self							)				->   Any:






       """simple docstring"""
       return AutoImageProcessor.from_pretrained(CVT_PRETRAINED_MODEL_ARCHIVE_LIST[0]							)




   @slow
   def    UpperCamelCase__						(					self							)				->   Dict:






       """simple docstring"""
       UpperCamelCase__							:       Optional[Any]      =   CvtForImageClassification.from_pretrained(CVT_PRETRAINED_MODEL_ARCHIVE_LIST[0]							).to(__magic_name__							)

       UpperCamelCase__							:       Union[str, Any]      =   self.default_image_processor
       UpperCamelCase__							:       Any      =   prepare_img()
       UpperCamelCase__							:       List[str]      =   image_processor(images=__magic_name__,	return_tensors='''pt'''							).to(__magic_name__							)

       # forward pass
       with torch.no_grad():
           UpperCamelCase__							:       Tuple      =   model(**__magic_name__							)

       # verify the logits
       UpperCamelCase__							:       Tuple      =   torch.Size((1, 1000)							)
       self.assertEqual(outputs.logits.shape,	__magic_name__							)

       UpperCamelCase__							:       List[Any]      =   torch.tensor([0.9285, 0.9015, -0.3150]							).to(__magic_name__							)

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

