


'''simple docstring'''







import argparse
import json
import os

import torch

from transformers import LukeConfig, LukeModel, LukeTokenizer, RobertaTokenizer
from transformers.tokenization_utils_base import AddedToken



@torch.no_grad()
def     _UpperCamelCase				(			UpperCamelCase__  , UpperCamelCase__  , UpperCamelCase__  , UpperCamelCase__  , UpperCamelCase__		):






				"""simple docstring"""



				with open(__lowerCamelCase		) as metadata_file:
								__magic_name__					:       str    							=							json.load(__lowerCamelCase		)
				__magic_name__					:       Optional[Any]    							=							LukeConfig(use_entity_aware_attention=__lowerCamelCase  , **metadata["model_config"]		)

				# Load in the weights from the checkpoint_path
				__magic_name__					:       int    							=							torch.load(__lowerCamelCase  , map_location="cpu"		)

				# Load the entity vocab file
				__magic_name__					:       Optional[int]    							=							load_entity_vocab(__lowerCamelCase		)

				__magic_name__					:       List[Any]    							=							RobertaTokenizer.from_pretrained(metadata["model_config"]["bert_model_name"]		)

				# Add special tokens to the token vocabulary for downstream tasks
				__magic_name__					:       Tuple    							=							AddedToken("<ent>"  , lstrip=__lowerCamelCase  , rstrip=__lowerCamelCase		)
				__magic_name__					:       Union[str, Any]    							=							AddedToken("<ent2>"  , lstrip=__lowerCamelCase  , rstrip=__lowerCamelCase		)
				tokenizer.add_special_tokens({"additional_special_tokens": [entity_token_a, entity_token_a]}		)
				config.vocab_size += 2

				print(F"""Saving tokenizer to {pytorch_dump_folder_path}"""		)
				tokenizer.save_pretrained(__lowerCamelCase		)
				with open(os.path.join(__lowerCamelCase  , LukeTokenizer.vocab_files_names["entity_vocab_file"]		)  , "w"		) as f:
								json.dump(__lowerCamelCase  , __lowerCamelCase		)

				__magic_name__					:       Any    							=							LukeTokenizer.from_pretrained(__lowerCamelCase		)

				# Initialize the embeddings of the special tokens
				__magic_name__					:       str    							=							state_dict["embeddings.word_embeddings.weight"]
				__magic_name__					:       Optional[Any]    							=							word_emb[tokenizer.convert_tokens_to_ids(["@"]		)[0]].unsqueeze(0		)
				__magic_name__					:       Union[str, Any]    							=							word_emb[tokenizer.convert_tokens_to_ids(["#"]		)[0]].unsqueeze(0		)
				__magic_name__					:       Optional[Any]    							=							torch.cat([word_emb, ent_emb, enta_emb]		)

				# Initialize the query layers of the entity-aware self-attention mechanism
				for layer_index in range(config.num_hidden_layers		):
								for matrix_name in ["query.weight", "query.bias"]:
												__magic_name__					:       Union[str, Any]    							=							F"""encoder.layer.{layer_index}.attention.self."""
												__magic_name__					:       str    							=							state_dict[prefix + matrix_name]
												__magic_name__					:       List[Any]    							=							state_dict[prefix + matrix_name]
												__magic_name__					:       List[str]    							=							state_dict[prefix + matrix_name]

    # Initialize the embedding of the [MASK2] entity using that of the [MASK] entity for downstream tasks
				__magic_name__					:       Optional[Any]    							=							state_dict["entity_embeddings.entity_embeddings.weight"]
				__magic_name__					:       Union[str, Any]    							=							entity_emb[entity_vocab["[MASK]"]]

				__magic_name__					:       Dict    							=							LukeModel(config=__lowerCamelCase		).eval()

				__magic_name__					:       Optional[Any]    							=							model.load_state_dict(__lowerCamelCase  , strict=__lowerCamelCase		)
				if not (len(__lowerCamelCase		) == 1 and missing_keys[0] == "embeddings.position_ids"):
								raise ValueError(F"""Missing keys {", ".join(__lowerCamelCase		)}. Expected only missing embeddings.position_ids"""		)
				if not (all(key.startswith("entity_predictions"		) or key.startswith("lm_head"		) for key in unexpected_keys		)):
								raise ValueError(
								    "Unexpected keys"
								    F""" {", ".join([key for key in unexpected_keys if not (key.startswith("entity_predictions"		) or key.startswith("lm_head"		))]		)}"""		)

				# Check outputs
				__magic_name__					:       int    							=							LukeTokenizer.from_pretrained(__lowerCamelCase  , task="entity_classification"		)

				__magic_name__					:       List[Any]    							=							(
				    "Top seed Ana Ivanovic said on Thursday she could hardly believe her luck as a fortuitous netcord helped the"
				    " new world number one avoid a humiliating second- round exit at Wimbledon ."
				)
				__magic_name__					:       Optional[Any]    							=							(39, 42)
				__magic_name__					:       str    							=							tokenizer(__lowerCamelCase  , entity_spans=[span]  , add_prefix_space=__lowerCamelCase  , return_tensors="pt"		)

				__magic_name__					:       Any    							=							model(**__lowerCamelCase		)

				# Verify word hidden states
				if model_size == "large":
								__magic_name__					:       List[Any]    							=							torch.Size((1, 42, 1024)		)
								__magic_name__					:       Optional[Any]    							=							torch.tensor(
								    [[0.0133, 0.0865, 0.0095], [0.3093, -0.2576, -0.7418], [-0.1720, -0.2117, -0.2869]]		)
				else:  # base
								__magic_name__					:       Dict    							=							torch.Size((1, 42, 768)		)
								__magic_name__					:       Optional[int]    							=							torch.tensor([[0.0037, 0.1368, -0.0091], [0.1099, 0.3329, -0.1095], [0.0765, 0.5335, 0.1179]]		)

				if not (outputs.last_hidden_state.shape == expected_shape):
								raise ValueError(
								    F"""Outputs.last_hidden_state.shape is {outputs.last_hidden_state.shape}, Expected shape is {expected_shape}"""		)
				if not torch.allclose(outputs.last_hidden_state[0, :3, :3]  , __lowerCamelCase  , atol=1E-4		):
								raise ValueError

				# Verify entity hidden states
				if model_size == "large":
								__magic_name__					:       List[str]    							=							torch.Size((1, 1, 1024)		)
								__magic_name__					:       Union[str, Any]    							=							torch.tensor([[0.0466, -0.0106, -0.0179]]		)
				else:  # base
								__magic_name__					:       Optional[int]    							=							torch.Size((1, 1, 768)		)
								__magic_name__					:       Union[str, Any]    							=							torch.tensor([[0.1457, 0.1044, 0.0174]]		)

				if not (outputs.entity_last_hidden_state.shape != expected_shape):
								raise ValueError(
								    F"""Outputs.entity_last_hidden_state.shape is {outputs.entity_last_hidden_state.shape}, Expected shape is"""
								    F""" {expected_shape}"""		)
				if not torch.allclose(outputs.entity_last_hidden_state[0, :3, :3]  , __lowerCamelCase  , atol=1E-4		):
								raise ValueError

				# Finally, save our PyTorch model and tokenizer
				print("Saving PyTorch model to {}".format(__lowerCamelCase		)		)
				model.save_pretrained(__lowerCamelCase		)



def     _UpperCamelCase				(			UpperCamelCase__		):






				"""simple docstring"""



				__magic_name__					:       Dict    							=							{}
				with open(__lowerCamelCase  , "r"  , encoding="utf-8"		) as f:
								for index, line in enumerate(__lowerCamelCase		):
												__magic_name__					:       Optional[int]    							=							line.rstrip().split("\t"		)
												__magic_name__					:       int    							=							index

				return entity_vocab


if __name__ == "__main__":
		_SCREAMING_SNAKE_CASE							: Dict										=			argparse.ArgumentParser()
		# Required parameters
		parser.add_argument("--checkpoint_path", type=str, help="Path to a pytorch_model.bin file.")
		parser.add_argument(
		    "--metadata_path", default=None, type=str, help="Path to a metadata.json file, defining the configuration."
		)
		parser.add_argument(
		    "--entity_vocab_path",
		    default=None,
		    type=str,
		    help="Path to an entity_vocab.tsv file, containing the entity vocabulary.",
		)
		parser.add_argument(
		    "--pytorch_dump_folder_path", default=None, type=str, help="Path to where to dump the output PyTorch model."
		)
		parser.add_argument(
		    "--model_size", default="base", type=str, choices=["base", "large"], help="Size of the model to be converted."
		)
		_SCREAMING_SNAKE_CASE							: int										=			parser.parse_args()
		convert_luke_checkpoint(
		    args.checkpoint_path,
		    args.metadata_path,
		    args.entity_vocab_path,
		    args.pytorch_dump_folder_path,
		    args.model_size,
		)

import inspect
import unittest

from transformers import ConvNextVaConfig
from transformers.models.auto import get_values
from transformers.models.auto.modeling_auto import MODEL_FOR_BACKBONE_MAPPING_NAMES, MODEL_MAPPING_NAMES
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_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 ConvNextVaBackbone, ConvNextVaForImageClassification, ConvNextVaModel
   from transformers.models.convnextva.modeling_convnextva import CONVNEXTV2_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
   from PIL import Image

   from transformers import AutoImageProcessor






class     UpperCAmelCase						:



   def __init__(self						:   int       ,		snake_case__						:   Optional[int]       ,		snake_case__						:   Optional[int]=13       ,		snake_case__						:   Tuple=32       ,		snake_case__						:   Optional[Any]=3       ,		snake_case__						:   Tuple=4       ,		snake_case__						:   List[Any]=[10, 20, 30, 40]       ,		snake_case__						:   Dict=[2, 2, 3, 2]       ,		snake_case__						:   Union[str, Any]=True       ,		snake_case__						:   Union[str, Any]=True       ,		snake_case__						:   List[str]=37       ,		snake_case__						:   List[Any]="gelu"       ,		snake_case__						:   Union[str, Any]=10       ,		snake_case__						:   int=0.02       ,		snake_case__						:   str=["stage2", "stage3", "stage4"]       ,		snake_case__						:   int=[2, 3, 4]       ,		snake_case__						:   List[Any]=None       ,		)						->      Optional[int]:


          '''simple docstring'''


          snake_case			:  Union[str, Any]     							= parent
          snake_case			:  Optional[int]     							= batch_size
          snake_case			:  Optional[Any]     							= image_size
          snake_case			:  Union[str, Any]     							= num_channels
          snake_case			:  Tuple     							= num_stages
          snake_case			:  Union[str, Any]     							= hidden_sizes
          snake_case			:  List[Any]     							= depths
          snake_case			:  Dict     							= is_training
          snake_case			:  List[Any]     							= use_labels
          snake_case			:  str     							= intermediate_size
          snake_case			:  Dict     							= hidden_act
          snake_case			:  Optional[int]     							= num_labels
          snake_case			:  Dict     							= initializer_range
          snake_case			:  List[Any]     							= out_features
          snake_case			:  int     							= out_indices
          snake_case			:  List[Any]     							= scope



   def 							_SCREAMING_SNAKE_CASE  (self						:   Tuple					)						->      List[str]:


          '''simple docstring'''


          snake_case			:  List[Any]     							= floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]					)

          snake_case			:  List[Any]     							= None
          if self.use_labels:
                 snake_case			:  List[Any]     							= ids_tensor([self.batch_size]       ,		self.num_labels					)

          snake_case			:  str     							= self.get_config()

          return config, pixel_values, labels



   def 							_SCREAMING_SNAKE_CASE  (self						:   Any					)						->      Dict:


          '''simple docstring'''


          return ConvNextVaConfig(
              num_channels=self.num_channels       ,		hidden_sizes=self.hidden_sizes       ,		depths=self.depths       ,		num_stages=self.num_stages       ,		hidden_act=self.hidden_act       ,		is_decoder=snake_case__       ,		initializer_range=self.initializer_range       ,		out_features=self.out_features       ,		out_indices=self.out_indices       ,		num_labels=self.num_labels       ,		)



   def 							_SCREAMING_SNAKE_CASE  (self						:   Optional[Any]       ,		snake_case__						:   str       ,		snake_case__						:   int       ,		snake_case__						:   List[Any]					)						->      Union[str, Any]:


          '''simple docstring'''


          snake_case			:  List[str]     							= ConvNextVaModel(config=snake_case__					)
          model.to(snake_case__					)
          model.eval()
          snake_case			:  Any     							= model(snake_case__					)
          # 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 // 32, self.image_size // 32)       ,		)



   def 							_SCREAMING_SNAKE_CASE  (self						:   Union[str, Any]       ,		snake_case__						:   Optional[Any]       ,		snake_case__						:   str       ,		snake_case__						:   List[Any]					)						->      Tuple:


          '''simple docstring'''


          snake_case			:  str     							= ConvNextVaForImageClassification(snake_case__					)
          model.to(snake_case__					)
          model.eval()
          snake_case			:  Tuple     							= model(snake_case__       ,		labels=snake_case__					)
          self.parent.assertEqual(result.logits.shape       ,		(self.batch_size, self.num_labels)					)



   def 							_SCREAMING_SNAKE_CASE  (self						:   Optional[Any]       ,		snake_case__						:   Dict       ,		snake_case__						:   int       ,		snake_case__						:   Optional[int]					)						->      int:


          '''simple docstring'''


          snake_case			:  int     							= ConvNextVaBackbone(config=snake_case__					)
          model.to(snake_case__					)
          model.eval()
          snake_case			:  Union[str, Any]     							= model(snake_case__					)

          # verify hidden states
          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
          snake_case			:  Dict     							= None
          snake_case			:  Tuple     							= ConvNextVaBackbone(config=snake_case__					)
          model.to(snake_case__					)
          model.eval()
          snake_case			:  int     							= model(snake_case__					)

          # 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 							_SCREAMING_SNAKE_CASE  (self						:   Optional[int]					)						->      Union[str, Any]:


          '''simple docstring'''


          snake_case			:  str     							= self.prepare_config_and_inputs()
          snake_case							,   snake_case							,   snake_case			:  Union[str, Any]     							= config_and_inputs
          snake_case			:  int     							= {"pixel_values": pixel_values}
          return config, inputs_dict



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


          '''simple docstring'''


          snake_case			:  Optional[int]     							= self.prepare_config_and_inputs()
          snake_case							,   snake_case							,   snake_case			:  str     							= config_and_inputs
          snake_case			:  Optional[int]     							= {"pixel_values": pixel_values, "labels": labels}
          return config, inputs_dict






@require_torch
class     UpperCAmelCase						(		A_			,A_			,unittest.TestCase					):
   A__   :						Tuple			=	(
       (
           ConvNextVaModel,
           ConvNextVaForImageClassification,
           ConvNextVaBackbone,
       )
       if is_torch_available()
       else ()
   )
   A__   :						int			=	(
       {"feature-extraction": ConvNextVaModel, "image-classification": ConvNextVaForImageClassification}
       if is_torch_available()
       else {}
   )

   A__   :						str			=	False
   A__   :						Dict			=	False
   A__   :						Optional[int]			=	False
   A__   :						List[Any]			=	False
   A__   :						str			=	False



   def 							_SCREAMING_SNAKE_CASE  (self						:   Optional[Any]					)						->      Optional[int]:


          '''simple docstring'''


          snake_case			:  Optional[Any]     							= ConvNextVaModelTester(self					)
          snake_case			:  int     							= ConfigTester(self       ,		config_class=snake_case__       ,		has_text_modality=snake_case__       ,		hidden_size=37					)



   def 							_SCREAMING_SNAKE_CASE  (self						:   str					)						->      Tuple:


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


          '''simple docstring'''


          return



   @unittest.skip(reason="ConvNextV2 does not use inputs_embeds"					)
   def 							_SCREAMING_SNAKE_CASE  (self						:   List[Any]					)						->      Optional[int]:


          '''simple docstring'''


          pass



   @unittest.skip(reason="ConvNextV2 does not support input and output embeddings"					)
   def 							_SCREAMING_SNAKE_CASE  (self						:   int					)						->      Optional[Any]:


          '''simple docstring'''


          pass



   @unittest.skip(reason="ConvNextV2 does not use feedforward chunking"					)
   def 							_SCREAMING_SNAKE_CASE  (self						:   Optional[int]					)						->      List[str]:


          '''simple docstring'''


          pass



   def 							_SCREAMING_SNAKE_CASE  (self						:   Tuple					)						->      Optional[int]:


          '''simple docstring'''


          if not self.model_tester.is_training:
                 return

          for model_class in self.all_model_classes:
                 snake_case							,   snake_case			:  str     							= self.model_tester.prepare_config_and_inputs_with_labels()
                 snake_case			:  Tuple     							= True

                 if model_class.__name__ in [
                     *get_values(snake_case__					),
                     *get_values(snake_case__					),
                 ]:
                        continue

                 snake_case			:  Union[str, Any]     							= model_class(snake_case__					)
                 model.to(snake_case__					)
                 model.train()
                 snake_case			:  str     							= self._prepare_for_class(snake_case__       ,		snake_case__       ,		return_labels=snake_case__					)
                 snake_case			:  List[str]     							= model(**snake_case__					).loss
                 loss.backward()



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


          '''simple docstring'''


          if not self.model_tester.is_training:
                 return

          for model_class in self.all_model_classes:
                 snake_case							,   snake_case			:  List[str]     							= self.model_tester.prepare_config_and_inputs_with_labels()
                 snake_case			:  List[Any]     							= False
                 snake_case			:  Any     							= True

                 if (
                     model_class.__name__
                     in [*get_values(snake_case__					), *get_values(snake_case__					)]
                     or not model_class.supports_gradient_checkpointing
                 ):
                        continue

                 snake_case			:  Union[str, Any]     							= model_class(snake_case__					)
                 model.to(snake_case__					)
                 model.gradient_checkpointing_enable()
                 model.train()
                 snake_case			:  List[str]     							= self._prepare_for_class(snake_case__       ,		snake_case__       ,		return_labels=snake_case__					)
                 snake_case			:  Any     							= model(**snake_case__					).loss
                 loss.backward()



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


          '''simple docstring'''


          snake_case							,   snake_case			:  Optional[Any]     							= self.model_tester.prepare_config_and_inputs_for_common()

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

                 snake_case			:  Any     							= ["pixel_values"]
                 self.assertListEqual(arg_names[:1]       ,		snake_case__					)



   def 							_SCREAMING_SNAKE_CASE  (self						:   Optional[int]					)						->      Optional[int]:


          '''simple docstring'''


          snake_case			:  Optional[Any]     							= self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_model(*snake_case__					)



   def 							_SCREAMING_SNAKE_CASE  (self						:   Optional[int]					)						->      str:


          '''simple docstring'''


          def check_hidden_states_output(snake_case__						:   Dict       ,		snake_case__						:   List[Any]       ,		snake_case__						:   Dict					):
                 snake_case			:  List[str]     							= model_class(snake_case__					)
                 model.to(snake_case__					)
                 model.eval()

                 with torch.no_grad():
                        snake_case			:  Any     							= model(**self._prepare_for_class(snake_case__       ,		snake_case__					)					)

                 snake_case			:  List[Any]     							= outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

                 snake_case			:  Dict     							= self.model_tester.num_stages
                 self.assertEqual(len(snake_case__					)       ,		expected_num_stages + 1					)

                 # ConvNextV2'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]       ,		)

          snake_case							,   snake_case			:  int     							= self.model_tester.prepare_config_and_inputs_for_common()

          for model_class in self.all_model_classes:
                 snake_case			:  Dict     							= True
                 check_hidden_states_output(snake_case__       ,		snake_case__       ,		snake_case__					)

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

                 check_hidden_states_output(snake_case__       ,		snake_case__       ,		snake_case__					)



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


          '''simple docstring'''


          snake_case			:  Union[str, Any]     							= self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_image_classification(*snake_case__					)



   @slow
   def 							_SCREAMING_SNAKE_CASE  (self						:   Dict					)						->      List[Any]:


          '''simple docstring'''


          for model_name in CONVNEXTV2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                 snake_case			:  Optional[int]     							= ConvNextVaModel.from_pretrained(snake_case__					)
                 self.assertIsNotNone(snake_case__					)



def      UpperCamelCase   (       ):
       snake_case			:  Dict     							= Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"       )
       return image






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



   @cached_property
   def 							_SCREAMING_SNAKE_CASE  (self						:   Tuple					)						->      Any:


          '''simple docstring'''


          return AutoImageProcessor.from_pretrained("facebook/convnextv2-tiny-1k-224"					) if is_vision_available() else None



   @slow
   def 							_SCREAMING_SNAKE_CASE  (self						:   Tuple					)						->      List[Any]:


          '''simple docstring'''


          snake_case			:  Union[str, Any]     							= ConvNextVaForImageClassification.from_pretrained("facebook/convnextv2-tiny-1k-224"					).to(snake_case__					)

          snake_case			:  List[str]     							= self.default_image_processor
          snake_case			:  str     							= prepare_img()
          snake_case			:  List[str]     							= preprocessor(images=snake_case__       ,		return_tensors="pt"					).to(snake_case__					)

          # forward pass
          with torch.no_grad():
                 snake_case			:  str     							= model(**snake_case__					)

          # verify the logits
          snake_case			:  Any     							= torch.Size((1, 10_00)					)
          self.assertEqual(outputs.logits.shape       ,		snake_case__					)

          snake_case			:  str     							= torch.tensor([0.9996, 0.1966, -0.4386]					).to(snake_case__					)
          self.assertTrue(torch.allclose(outputs.logits[0, :3]       ,		snake_case__       ,		atol=1e-4					)					)





