






import inspect
import unittest
import warnings
from typing import List

from transformers import EfficientFormerConfig
from transformers.models.auto import get_values
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 (
          MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING,
          MODEL_MAPPING,
          EfficientFormerForImageClassification,
          EfficientFormerForImageClassificationWithTeacher,
          EfficientFormerModel,
      )
      from transformers.models.efficientformer.modeling_efficientformer import (
          EFFICIENTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
      )


if is_vision_available():
      from PIL import Image

      from transformers import EfficientFormerImageProcessor
class 	a_:



     """simple docstring"""



     def __init__(		self					:	List[str]  ,  lowerCAmelCase__					:	Dict  ,  lowerCAmelCase__					:	int = 1_3  ,  lowerCAmelCase__					:	int = 6_4  ,  lowerCAmelCase__					:	int = 2  ,  lowerCAmelCase__					:	int = 3  ,  lowerCAmelCase__					:	int = 3  ,  lowerCAmelCase__					:	bool = True  ,  lowerCAmelCase__					:	bool = True  ,  lowerCAmelCase__					:	int = 1_2_8  ,  lowerCAmelCase__					:	Tuple=[1_6, 3_2, 6_4, 1_2_8]  ,  lowerCAmelCase__					:	int = 7  ,  lowerCAmelCase__					:	int = 4  ,  lowerCAmelCase__					:	int = 3_7  ,  lowerCAmelCase__					:	str = "gelu"  ,  lowerCAmelCase__					:	float = 0.1  ,  lowerCAmelCase__					:	float = 0.1  ,  lowerCAmelCase__					:	int = 1_0  ,  lowerCAmelCase__					:	float = 0.02  ,  lowerCAmelCase__					:	int = 2  ,  lowerCAmelCase__					:	int = 1  ,  lowerCAmelCase__					:	int = 1_2_8  ,  lowerCAmelCase__					:	List[int] = [2, 2, 2, 2]  ,  lowerCAmelCase__					:	int = 2  ,  lowerCAmelCase__					:	int = 2  ,  )							->	Union[str, Any]:

      """simple docstring"""
      SCREAMING_SNAKE_CASE				    =		parent
      SCREAMING_SNAKE_CASE				    =		batch_size
      SCREAMING_SNAKE_CASE				    =		image_size
      SCREAMING_SNAKE_CASE				    =		patch_size
      SCREAMING_SNAKE_CASE				    =		num_channels
      SCREAMING_SNAKE_CASE				    =		is_training
      SCREAMING_SNAKE_CASE				    =		use_labels
      SCREAMING_SNAKE_CASE				    =		hidden_size
      SCREAMING_SNAKE_CASE				    =		num_hidden_layers
      SCREAMING_SNAKE_CASE				    =		num_attention_heads
      SCREAMING_SNAKE_CASE				    =		intermediate_size
      SCREAMING_SNAKE_CASE				    =		hidden_act
      SCREAMING_SNAKE_CASE				    =		hidden_dropout_prob
      SCREAMING_SNAKE_CASE				    =		attention_probs_dropout_prob
      SCREAMING_SNAKE_CASE				    =		type_sequence_label_size
      SCREAMING_SNAKE_CASE				    =		initializer_range
      SCREAMING_SNAKE_CASE				    =		encoder_stride
      SCREAMING_SNAKE_CASE				    =		num_attention_outputs
      SCREAMING_SNAKE_CASE				    =		embed_dim
      SCREAMING_SNAKE_CASE				    =		embed_dim + 1
      SCREAMING_SNAKE_CASE				    =		resolution
      SCREAMING_SNAKE_CASE				    =		depths
      SCREAMING_SNAKE_CASE				    =		hidden_sizes
      SCREAMING_SNAKE_CASE				    =		dim
      SCREAMING_SNAKE_CASE				    =		mlp_expansion_ratio





     def     __UpperCamelCase						(		self					:	List[str])							->	int:

      """simple docstring"""
      SCREAMING_SNAKE_CASE				    =		floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size])

      SCREAMING_SNAKE_CASE				    =		None
      if self.use_labels:
       SCREAMING_SNAKE_CASE				    =		ids_tensor([self.batch_size]  ,  self.type_sequence_label_size)

      SCREAMING_SNAKE_CASE				    =		self.get_config()
      return config, pixel_values, labels





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

      """simple docstring"""
      return EfficientFormerConfig(
          image_size=self.image_size  ,  patch_size=self.patch_size  ,  num_channels=self.num_channels  ,  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  ,  hidden_dropout_prob=self.hidden_dropout_prob  ,  attention_probs_dropout_prob=self.attention_probs_dropout_prob  ,  is_decoder=lowerCAmelCase__  ,  initializer_range=self.initializer_range  ,  encoder_stride=self.encoder_stride  ,  resolution=self.resolution  ,  depths=self.depths  ,  hidden_sizes=self.hidden_sizes  ,  dim=self.dim  ,  mlp_expansion_ratio=self.mlp_expansion_ratio  ,  )





     def     __UpperCamelCase						(		self					:	List[str]  ,  lowerCAmelCase__					:	str  ,  lowerCAmelCase__					:	Optional[int]  ,  lowerCAmelCase__					:	List[str])							->	Optional[Any]:

      """simple docstring"""
      SCREAMING_SNAKE_CASE				    =		EfficientFormerModel(config=lowerCAmelCase__)
      model.to(lowerCAmelCase__)
      model.eval()
      SCREAMING_SNAKE_CASE				    =		model(lowerCAmelCase__)
      self.parent.assertEqual(result.last_hidden_state.shape  ,  (self.batch_size, self.seq_length, self.hidden_size))





     def     __UpperCamelCase						(		self					:	Optional[Any]  ,  lowerCAmelCase__					:	Optional[int]  ,  lowerCAmelCase__					:	Tuple  ,  lowerCAmelCase__					:	Union[str, Any])							->	Tuple:

      """simple docstring"""
      SCREAMING_SNAKE_CASE				    =		self.type_sequence_label_size
      SCREAMING_SNAKE_CASE				    =		EfficientFormerForImageClassification(lowerCAmelCase__)
      model.to(lowerCAmelCase__)
      model.eval()
      SCREAMING_SNAKE_CASE				    =		model(lowerCAmelCase__  ,  labels=lowerCAmelCase__)
      self.parent.assertEqual(result.logits.shape  ,  (self.batch_size, self.type_sequence_label_size))

      # test greyscale images
      SCREAMING_SNAKE_CASE				    =		1
      SCREAMING_SNAKE_CASE				    =		EfficientFormerForImageClassification(lowerCAmelCase__)
      model.to(lowerCAmelCase__)
      model.eval()

      SCREAMING_SNAKE_CASE				    =		floats_tensor([self.batch_size, 1, self.image_size, self.image_size])
      SCREAMING_SNAKE_CASE				    =		model(lowerCAmelCase__)
      self.parent.assertEqual(result.logits.shape  ,  (self.batch_size, self.type_sequence_label_size))





     def     __UpperCamelCase						(		self					:	Optional[Any])							->	Tuple:

      """simple docstring"""
      SCREAMING_SNAKE_CASE				    =		self.prepare_config_and_inputs()
      (
          (
          SCREAMING_SNAKE_CASE
      )    ,   (
          SCREAMING_SNAKE_CASE
      )    ,   (
          SCREAMING_SNAKE_CASE
      )    ,   
      )				    =		config_and_inputs
      SCREAMING_SNAKE_CASE				    =		{'pixel_values': pixel_values}
      return config, inputs_dict

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



     """simple docstring"""



     __snake_case		:				str  					=(
         (
             EfficientFormerModel,
             EfficientFormerForImageClassificationWithTeacher,
             EfficientFormerForImageClassification,
         )
         if is_torch_available()
         else ()
     )
     __snake_case		:				Dict  					=(
         {
             '''feature-extraction''': EfficientFormerModel,
             '''image-classification''': (
                 EfficientFormerForImageClassification,
                 EfficientFormerForImageClassificationWithTeacher,
             ),
         }
         if is_torch_available()
         else {}
     )
     __snake_case		:				Tuple  					=False

     __snake_case		:				str  					=False
     __snake_case		:				Tuple  					=False
     __snake_case		:				str  					=False





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

      """simple docstring"""
      SCREAMING_SNAKE_CASE				    =		EfficientFormerModelTester(self)
      SCREAMING_SNAKE_CASE				    =		ConfigTester(
          self  ,  config_class=lowerCAmelCase__  ,  has_text_modality=lowerCAmelCase__  ,  hidden_size=3_7)





     def     __UpperCamelCase						(		self					:	str)							->	Dict:

      """simple docstring"""
      self.config_tester.run_common_tests()





     @unittest.skip(reason='EfficientFormer does not use inputs_embeds')
     def     __UpperCamelCase						(		self					:	str)							->	List[str]:

      """simple docstring"""
      pass





     @unittest.skip(reason='EfficientFormer does not support input and output embeddings')
     def     __UpperCamelCase						(		self					:	List[Any])							->	Optional[int]:

      """simple docstring"""
      pass





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

      """simple docstring"""
      SCREAMING_SNAKE_CASE    ,   SCREAMING_SNAKE_CASE				    =		self.model_tester.prepare_config_and_inputs_for_common()

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

       SCREAMING_SNAKE_CASE				    =		['pixel_values']
       self.assertListEqual(arg_names[:1]  ,  lowerCAmelCase__)





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

      """simple docstring"""
      def check_hidden_states_output(lowerCAmelCase__					:	int  ,  lowerCAmelCase__					:	Union[str, Any]  ,  lowerCAmelCase__					:	str):
       SCREAMING_SNAKE_CASE				    =		model_class(lowerCAmelCase__)
       model.to(lowerCAmelCase__)
       model.eval()

       with torch.no_grad():
        SCREAMING_SNAKE_CASE				    =		model(**self._prepare_for_class(lowerCAmelCase__  ,  lowerCAmelCase__))

       SCREAMING_SNAKE_CASE				    =		outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

       SCREAMING_SNAKE_CASE				    =		getattr(
           self.model_tester  ,  'expected_num_hidden_layers'  ,  self.model_tester.num_hidden_layers + 1)
       self.assertEqual(len(lowerCAmelCase__)  ,  lowerCAmelCase__)

       if hasattr(self.model_tester  ,  'encoder_seq_length'):
        SCREAMING_SNAKE_CASE				    =		self.model_tester.encoder_seq_length
        if hasattr(self.model_tester  ,  'chunk_length') and self.model_tester.chunk_length > 1:
         SCREAMING_SNAKE_CASE				    =		seq_length * self.model_tester.chunk_length
       else:
        SCREAMING_SNAKE_CASE				    =		self.model_tester.seq_length

       self.assertListEqual(
           list(hidden_states[-1].shape[-2:])  ,  [seq_length, self.model_tester.hidden_size]  ,  )

       if config.is_encoder_decoder:
        SCREAMING_SNAKE_CASE				    =		outputs.decoder_hidden_states

        self.assertIsInstance(lowerCAmelCase__  ,  (list, tuple))
        self.assertEqual(len(lowerCAmelCase__)  ,  lowerCAmelCase__)
        SCREAMING_SNAKE_CASE				    =		getattr(self.model_tester  ,  'seq_length'  ,  lowerCAmelCase__)
        SCREAMING_SNAKE_CASE				    =		getattr(self.model_tester  ,  'decoder_seq_length'  ,  lowerCAmelCase__)

        self.assertListEqual(
            list(hidden_states[-1].shape[-2:])  ,  [decoder_seq_length, self.model_tester.hidden_size]  ,  )

      SCREAMING_SNAKE_CASE    ,   SCREAMING_SNAKE_CASE				    =		self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
       SCREAMING_SNAKE_CASE				    =		True
       check_hidden_states_output(lowerCAmelCase__  ,  lowerCAmelCase__  ,  lowerCAmelCase__)

       # check that output_hidden_states also work using config
       del inputs_dict["output_hidden_states"]
       SCREAMING_SNAKE_CASE				    =		True

       check_hidden_states_output(lowerCAmelCase__  ,  lowerCAmelCase__  ,  lowerCAmelCase__)





     def     __UpperCamelCase						(		self					:	Any  ,  lowerCAmelCase__					:	Union[str, Any]  ,  lowerCAmelCase__					:	List[str]  ,  lowerCAmelCase__					:	Optional[Any]=False)							->	Optional[int]:

      """simple docstring"""
      SCREAMING_SNAKE_CASE				    =		super()._prepare_for_class(lowerCAmelCase__  ,  lowerCAmelCase__  ,  return_labels=lowerCAmelCase__)

      if return_labels:
       if model_class.__name__ == "EfficientFormerForImageClassificationWithTeacher":
        del inputs_dict["labels"]

      return inputs_dict





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

      """simple docstring"""
      SCREAMING_SNAKE_CASE				    =		self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_model(*lowerCAmelCase__)





     @unittest.skip(reason='EfficientFormer does not implement masked image modeling yet')
     def     __UpperCamelCase						(		self					:	Optional[Any])							->	Tuple:

      """simple docstring"""
      SCREAMING_SNAKE_CASE				    =		self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_masked_image_modeling(*lowerCAmelCase__)





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

      """simple docstring"""
      SCREAMING_SNAKE_CASE				    =		self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_image_classification(*lowerCAmelCase__)





     def     __UpperCamelCase						(		self					:	Optional[Any])							->	List[Any]:

      """simple docstring"""
      if not self.model_tester.is_training:
       return

      SCREAMING_SNAKE_CASE    ,   SCREAMING_SNAKE_CASE				    =		self.model_tester.prepare_config_and_inputs_for_common()
      SCREAMING_SNAKE_CASE				    =		True

      for model_class in self.all_model_classes:
       # EfficientFormerForImageClassificationWithTeacher supports inference-only
       if (
           model_class in get_values(lowerCAmelCase__)
           or model_class.__name__ == "EfficientFormerForImageClassificationWithTeacher"
       ):
        continue
       SCREAMING_SNAKE_CASE				    =		model_class(lowerCAmelCase__)
       model.to(lowerCAmelCase__)
       model.train()
       SCREAMING_SNAKE_CASE				    =		self._prepare_for_class(lowerCAmelCase__  ,  lowerCAmelCase__  ,  return_labels=lowerCAmelCase__)
       SCREAMING_SNAKE_CASE				    =		model(**lowerCAmelCase__).loss
       loss.backward()





     def     __UpperCamelCase						(		self					:	Optional[Any])							->	List[Any]:

      """simple docstring"""
      SCREAMING_SNAKE_CASE    ,   SCREAMING_SNAKE_CASE				    =		self.model_tester.prepare_config_and_inputs_for_common()

      SCREAMING_SNAKE_CASE				    =		[
          {'title': 'multi_label_classification', 'num_labels': 2, 'dtype': torch.float},
          {'title': 'single_label_classification', 'num_labels': 1, 'dtype': torch.long},
          {'title': 'regression', 'num_labels': 1, 'dtype': torch.float},
      ]

      for model_class in self.all_model_classes:
       if (
           model_class
           not in [
               *get_values(lowerCAmelCase__),
           ]
           or model_class.__name__ == "EfficientFormerForImageClassificationWithTeacher"
       ):
        continue

       for problem_type in problem_types:
        with self.subTest(msg=f'''Testing {model_class} with {problem_type['title']}'''):
         SCREAMING_SNAKE_CASE				    =		problem_type['title']
         SCREAMING_SNAKE_CASE				    =		problem_type['num_labels']

         SCREAMING_SNAKE_CASE				    =		model_class(lowerCAmelCase__)
         model.to(lowerCAmelCase__)
         model.train()

         SCREAMING_SNAKE_CASE				    =		self._prepare_for_class(lowerCAmelCase__  ,  lowerCAmelCase__  ,  return_labels=lowerCAmelCase__)

         if problem_type["num_labels"] > 1:
          SCREAMING_SNAKE_CASE				    =		inputs['labels'].unsqueeze(1).repeat(1  ,  problem_type['num_labels'])

         SCREAMING_SNAKE_CASE				    =		inputs['labels'].to(problem_type['dtype'])

         # This tests that we do not trigger the warning form PyTorch "Using a target size that is different
         # to the input size. This will likely lead to incorrect results due to broadcasting. Please ensure
         # they have the same size." which is a symptom something in wrong for the regression problem.
         # See https://github.com/huggingface/transformers/issues/11780
         with warnings.catch_warnings(record=lowerCAmelCase__) as warning_list:
          SCREAMING_SNAKE_CASE				    =		model(**lowerCAmelCase__).loss
         for w in warning_list:
          if "Using a target size that is different to the input size" in str(w.message):
           raise ValueError(
               f'''Something is going wrong in the regression problem: intercepted {w.message}''')

         loss.backward()





     @slow
     def     __UpperCamelCase						(		self					:	Any)							->	Optional[int]:

      """simple docstring"""
      for model_name in EFFICIENTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
       SCREAMING_SNAKE_CASE				    =		EfficientFormerModel.from_pretrained(lowerCAmelCase__)
       self.assertIsNotNone(lowerCAmelCase__)





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

      """simple docstring"""
      SCREAMING_SNAKE_CASE    ,   SCREAMING_SNAKE_CASE				    =		self.model_tester.prepare_config_and_inputs_for_common()
      SCREAMING_SNAKE_CASE				    =		True

      SCREAMING_SNAKE_CASE				    =		getattr(self.model_tester  ,  'seq_length'  ,  lowerCAmelCase__)
      SCREAMING_SNAKE_CASE				    =		getattr(self.model_tester  ,  'encoder_seq_length'  ,  lowerCAmelCase__)
      SCREAMING_SNAKE_CASE				    =		getattr(self.model_tester  ,  'key_length'  ,  lowerCAmelCase__)
      SCREAMING_SNAKE_CASE				    =		getattr(self.model_tester  ,  'chunk_length'  ,  lowerCAmelCase__)

      if chunk_length is not None and hasattr(self.model_tester  ,  'num_hashes'):
       SCREAMING_SNAKE_CASE				    =		encoder_seq_length * self.model_tester.num_hashes

      for model_class in self.all_model_classes:
       SCREAMING_SNAKE_CASE				    =		True
       SCREAMING_SNAKE_CASE				    =		False
       SCREAMING_SNAKE_CASE				    =		True
       SCREAMING_SNAKE_CASE				    =		model_class(lowerCAmelCase__)
       model.to(lowerCAmelCase__)
       model.eval()
       with torch.no_grad():
        SCREAMING_SNAKE_CASE				    =		model(**self._prepare_for_class(lowerCAmelCase__  ,  lowerCAmelCase__))
       SCREAMING_SNAKE_CASE				    =		outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions
       self.assertEqual(len(lowerCAmelCase__)  ,  self.model_tester.num_attention_outputs)

       # check that output_attentions also work using config
       del inputs_dict["output_attentions"]
       SCREAMING_SNAKE_CASE				    =		True
       SCREAMING_SNAKE_CASE				    =		model_class(lowerCAmelCase__)
       model.to(lowerCAmelCase__)
       model.eval()
       with torch.no_grad():
        SCREAMING_SNAKE_CASE				    =		model(**self._prepare_for_class(lowerCAmelCase__  ,  lowerCAmelCase__))
       SCREAMING_SNAKE_CASE				    =		outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions
       self.assertEqual(len(lowerCAmelCase__)  ,  self.model_tester.num_attention_outputs)

       if chunk_length is not None:
        self.assertListEqual(
            list(attentions[0].shape[-4:])  ,  [self.model_tester.num_attention_heads, encoder_seq_length, chunk_length, encoder_key_length]  ,  )
       else:
        self.assertListEqual(
            list(attentions[0].shape[-3:])  ,  [self.model_tester.num_attention_heads, encoder_seq_length, encoder_key_length]  ,  )





def 						A_					(						)				->str:







 """simple docstring"""

 SCREAMING_SNAKE_CASE				    =		Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'			)
 return image
@require_torch
@require_vision
class 	a_(		unittest.TestCase	):



     """simple docstring"""



     @cached_property
     def     __UpperCamelCase						(		self					:	Union[str, Any])							->	str:

      """simple docstring"""
      return (
          EfficientFormerImageProcessor.from_pretrained('snap-research/efficientformer-l1-300')
          if is_vision_available()
          else None
      )





     @slow
     def     __UpperCamelCase						(		self					:	int)							->	Optional[int]:

      """simple docstring"""
      SCREAMING_SNAKE_CASE				    =		EfficientFormerForImageClassification.from_pretrained('snap-research/efficientformer-l1-300').to(
          lowerCAmelCase__)

      SCREAMING_SNAKE_CASE				    =		self.default_image_processor
      SCREAMING_SNAKE_CASE				    =		prepare_img()
      SCREAMING_SNAKE_CASE				    =		image_processor(images=lowerCAmelCase__  ,  return_tensors='pt').to(lowerCAmelCase__)

      # forward pass
      with torch.no_grad():
       SCREAMING_SNAKE_CASE				    =		model(**lowerCAmelCase__)

      # verify the logits
      SCREAMING_SNAKE_CASE				    =		(1, 1_0_0_0)
      self.assertEqual(outputs.logits.shape  ,  lowerCAmelCase__)

      SCREAMING_SNAKE_CASE				    =		torch.tensor([-0.05_55, 0.48_25, -0.08_52]).to(lowerCAmelCase__)
      self.assertTrue(torch.allclose(outputs.logits[0][:3]  ,  lowerCAmelCase__  ,  atol=1e-4))





     @slow
     def     __UpperCamelCase						(		self					:	Optional[int])							->	List[str]:

      """simple docstring"""
      SCREAMING_SNAKE_CASE				    =		EfficientFormerForImageClassificationWithTeacher.from_pretrained(
          'snap-research/efficientformer-l1-300').to(lowerCAmelCase__)

      SCREAMING_SNAKE_CASE				    =		self.default_image_processor
      SCREAMING_SNAKE_CASE				    =		prepare_img()
      SCREAMING_SNAKE_CASE				    =		image_processor(images=lowerCAmelCase__  ,  return_tensors='pt').to(lowerCAmelCase__)

      # forward pass
      with torch.no_grad():
       SCREAMING_SNAKE_CASE				    =		model(**lowerCAmelCase__)

      # verify the logits
      SCREAMING_SNAKE_CASE				    =		(1, 1_0_0_0)
      self.assertEqual(outputs.logits.shape  ,  lowerCAmelCase__)

      SCREAMING_SNAKE_CASE				    =		torch.tensor([-0.13_12, 0.43_53, -1.04_99]).to(lowerCAmelCase__)
      self.assertTrue(torch.allclose(outputs.logits[0][:3]  ,  lowerCAmelCase__  ,  atol=1e-4))












import json
import os
import tempfile
import unittest

from transformers.modelcard import ModelCard
class 	a_(		unittest.TestCase	):



     """simple docstring"""



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

      """simple docstring"""
      SCREAMING_SNAKE_CASE				    =		{
          'model_details': {
              'Organization': 'testing',
              'Model date': 'today',
              'Model version': 'v2.1, Developed by Test Corp in 2019.',
              'Architecture': 'Convolutional Neural Network.',
          },
          'metrics': 'BLEU and ROUGE-1',
          'evaluation_data': {
              'Datasets': {'BLEU': 'My-great-dataset-v1', 'ROUGE-1': 'My-short-dataset-v2.1'},
              'Preprocessing': 'See details on https://arxiv.org/pdf/1810.03993.pdf',
          },
          'training_data': {
              'Dataset': 'English Wikipedia dump dated 2018-12-01',
              'Preprocessing': (
                  'Using SentencePiece vocabulary of size 52k tokens. See details on'
                  ' https://arxiv.org/pdf/1810.03993.pdf'
              ),
          },
          'quantitative_analyses': {'BLEU': 55.1, 'ROUGE-1': 7_6},
      }





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

      """simple docstring"""
      SCREAMING_SNAKE_CASE				    =		ModelCard.from_dict(self.inputs_dict)
      self.assertTrue(hasattr(lowerCAmelCase__  ,  'model_details'))
      self.assertTrue(hasattr(lowerCAmelCase__  ,  'intended_use'))
      self.assertTrue(hasattr(lowerCAmelCase__  ,  'factors'))
      self.assertTrue(hasattr(lowerCAmelCase__  ,  'metrics'))
      self.assertTrue(hasattr(lowerCAmelCase__  ,  'evaluation_data'))
      self.assertTrue(hasattr(lowerCAmelCase__  ,  'training_data'))
      self.assertTrue(hasattr(lowerCAmelCase__  ,  'quantitative_analyses'))
      self.assertTrue(hasattr(lowerCAmelCase__  ,  'ethical_considerations'))
      self.assertTrue(hasattr(lowerCAmelCase__  ,  'caveats_and_recommendations'))





     def     __UpperCamelCase						(		self					:	Any)							->	Any:

      """simple docstring"""
      SCREAMING_SNAKE_CASE				    =		ModelCard.from_dict(self.inputs_dict)
      SCREAMING_SNAKE_CASE				    =		json.loads(modelcard.to_json_string())
      for key, value in self.inputs_dict.items():
       self.assertEqual(obj[key]  ,  lowerCAmelCase__)





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

      """simple docstring"""
      SCREAMING_SNAKE_CASE				    =		ModelCard.from_dict(self.inputs_dict)

      with tempfile.TemporaryDirectory() as tmpdirname:
       SCREAMING_SNAKE_CASE				    =		os.path.join(lowerCAmelCase__  ,  'modelcard.json')
       model_card_first.to_json_file(lowerCAmelCase__)
       SCREAMING_SNAKE_CASE				    =		ModelCard.from_json_file(lowerCAmelCase__)

      self.assertEqual(model_card_second.to_dict()  ,  model_card_first.to_dict())





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

      """simple docstring"""
      SCREAMING_SNAKE_CASE				    =		ModelCard.from_dict(self.inputs_dict)

      with tempfile.TemporaryDirectory() as tmpdirname:
       model_card_first.save_pretrained(lowerCAmelCase__)
       SCREAMING_SNAKE_CASE				    =		ModelCard.from_pretrained(lowerCAmelCase__)

      self.assertEqual(model_card_second.to_dict()  ,  model_card_first.to_dict())




