






'''simple docstring'''






import argparse
import gc
import json
import os
import shutil
import warnings

import torch

from transformers import LlamaConfig, LlamaForCausalLM, LlamaTokenizer


try:
      from transformers import LlamaTokenizerFast
except ImportError as e:
      warnings.warn(e)
      warnings.warn(
          '''The converted tokenizer will be the `slow` tokenizer. To use the fast, update your `tokenizers` library and re-run the tokenizer conversion'''
      )
      __A    	=   None
__A    	=   {
    '''7B''': 1_1_0_0_8,
    '''13B''': 1_3_8_2_4,
    '''30B''': 1_7_9_2_0,
    '''65B''': 2_2_0_1_6,
    '''70B''': 2_8_6_7_2,
}
__A    	=   {
    '''7B''': 1,
    '''7Bf''': 1,
    '''13B''': 2,
    '''13Bf''': 2,
    '''30B''': 4,
    '''65B''': 8,
    '''70B''': 8,
    '''70Bf''': 8,
}




def        _SCREAMING_SNAKE_CASE  (				A  :       Optional[int]  ,		A  :       Tuple=1  ,		A  :       Union[str, Any]=2_56  )    -> int:







   """simple docstring"""
   return multiple_of * ((int(ffn_dim_multiplier * int(8 * n / 3  )  ) + multiple_of - 1) // multiple_of)




def        _SCREAMING_SNAKE_CASE  (				A  :       int  )    -> List[str]:







   """simple docstring"""
   with open(A  ,		'r'  ) as f:
      return json.load(A  )




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







   """simple docstring"""
   with open(A  ,		'w'  ) as f:
      json.dump(A  ,		A  )




def        _SCREAMING_SNAKE_CASE  (				A  :       Union[str, Any]  ,		A  :       Union[str, Any]  ,		A  :       Union[str, Any]  ,		A  :       Optional[int]=True  )    -> List[str]:







   """simple docstring"""
   os.makedirs(A  ,		exist_ok=A  )
   __snake_case				:      str     							= os.path.join(A  ,		'tmp'  )
   os.makedirs(A  ,		exist_ok=A  )

   __snake_case				:      int     							= read_json(os.path.join(A  ,		'params.json'  )  )
   __snake_case				:      int     							= NUM_SHARDS[model_size]
   __snake_case				:      Any     							= params['n_layers']
   __snake_case				:      Any     							= params['n_heads']
   __snake_case				:      int     							= n_heads // num_shards
   __snake_case				:      Optional[int]     							= params['dim']
   __snake_case				:      str     							= dim // n_heads
   __snake_case				:      Dict     							= 10000.0
   __snake_case				:      List[Any]     							= 1.0 / (base ** (torch.arange(0  ,		A  ,		2  ).float() / dims_per_head))

   if "n_kv_heads" in params:
      __snake_case				:      Tuple     							= params['n_kv_heads']  # for GQA / MQA
      __snake_case				:      Any     							= n_heads_per_shard // num_key_value_heads
      __snake_case				:      Any     							= dim // num_key_value_heads
   else:  # compatibility with other checkpoints
      __snake_case				:      Any     							= n_heads
      __snake_case				:      Union[str, Any]     							= n_heads_per_shard
      __snake_case				:      Union[str, Any]     							= dim

   # permute for sliced rotary
   def permute(A  :       Tuple  ,		A  :       List[str]=n_heads  ,		A  :       Dict=dim  ,		A  :       Union[str, Any]=dim  ):
      return w.view(A  ,		dima // n_heads // 2  ,		2  ,		A  ).transpose(1  ,		2  ).reshape(A  ,		A  )

   print(F"""Fetching all parameters from the checkpoint at {input_base_path}."""  )
   # Load weights
   if model_size == "7B":
      # Not sharded
      # (The sharded implementation would also work, but this is simpler.)
      __snake_case				:      str     							= torch.load(os.path.join(A  ,		'consolidated.00.pth'  )  ,		map_location='cpu'  )
   else:
      # Sharded
      __snake_case				:      int     							= [
          torch.load(os.path.join(A  ,		F"""consolidated.{i:02d}.pth"""  )  ,		map_location='cpu'  )
          for i in range(A  )
      ]
   __snake_case				:      Dict     							= 0
   __snake_case				:      Any     							= {'weight_map': {}}
   for layer_i in range(A  ):
      __snake_case				:      str     							= F"""pytorch_model-{layer_i + 1}-of-{n_layers + 1}.bin"""
      if model_size == "7B":
         # Unsharded
         __snake_case				:      List[str]     							= {
             F"""model.layers.{layer_i}.self_attn.q_proj.weight""": permute(
                 loaded[F"""layers.{layer_i}.attention.wq.weight"""]  ),
             F"""model.layers.{layer_i}.self_attn.k_proj.weight""": permute(
                 loaded[F"""layers.{layer_i}.attention.wk.weight"""]  ),
             F"""model.layers.{layer_i}.self_attn.v_proj.weight""": loaded[F"""layers.{layer_i}.attention.wv.weight"""],
             F"""model.layers.{layer_i}.self_attn.o_proj.weight""": loaded[F"""layers.{layer_i}.attention.wo.weight"""],
             F"""model.layers.{layer_i}.mlp.gate_proj.weight""": loaded[F"""layers.{layer_i}.feed_forward.w1.weight"""],
             F"""model.layers.{layer_i}.mlp.down_proj.weight""": loaded[F"""layers.{layer_i}.feed_forward.w2.weight"""],
             F"""model.layers.{layer_i}.mlp.up_proj.weight""": loaded[F"""layers.{layer_i}.feed_forward.w3.weight"""],
             F"""model.layers.{layer_i}.input_layernorm.weight""": loaded[F"""layers.{layer_i}.attention_norm.weight"""],
             F"""model.layers.{layer_i}.post_attention_layernorm.weight""": loaded[F"""layers.{layer_i}.ffn_norm.weight"""],
         }
      else:
         # Sharded
         # Note that attention.w{q,k,v,o}, feed_fordward.w[1,2,3], attention_norm.weight and ffn_norm.weight share
         # the same storage object, saving attention_norm and ffn_norm will save other weights too, which is
         # redundant as other weights will be stitched from multiple shards. To avoid that, they are cloned.

         __snake_case				:      Optional[int]     							= {
             F"""model.layers.{layer_i}.input_layernorm.weight""": loaded[0][
                 F"""layers.{layer_i}.attention_norm.weight"""
             ].clone(),
             F"""model.layers.{layer_i}.post_attention_layernorm.weight""": loaded[0][
                 F"""layers.{layer_i}.ffn_norm.weight"""
             ].clone(),
         }
         __snake_case				:      Optional[int]     							= permute(
             torch.cat(
                 [
                     loaded[i][F"""layers.{layer_i}.attention.wq.weight"""].view(A  ,		A  ,		A  )
                     for i in range(A  )
                 ]  ,		dim=0  ,		).reshape(A  ,		A  )  )
         __snake_case				:      Any     							= permute(
             torch.cat(
                 [
                     loaded[i][F"""layers.{layer_i}.attention.wk.weight"""].view(
                         A  ,		A  ,		A  )
                     for i in range(A  )
                 ]  ,		dim=0  ,		).reshape(A  ,		A  )  ,		A  ,		A  ,		A  ,		)
         __snake_case				:      Tuple     							= torch.cat(
             [
                 loaded[i][F"""layers.{layer_i}.attention.wv.weight"""].view(
                     A  ,		A  ,		A  )
                 for i in range(A  )
             ]  ,		dim=0  ,		).reshape(A  ,		A  )

         __snake_case				:      Tuple     							= torch.cat(
             [loaded[i][F"""layers.{layer_i}.attention.wo.weight"""] for i in range(A  )]  ,		dim=1  )
         __snake_case				:      Union[str, Any]     							= torch.cat(
             [loaded[i][F"""layers.{layer_i}.feed_forward.w1.weight"""] for i in range(A  )]  ,		dim=0  )
         __snake_case				:      int     							= torch.cat(
             [loaded[i][F"""layers.{layer_i}.feed_forward.w2.weight"""] for i in range(A  )]  ,		dim=1  )
         __snake_case				:      Any     							= torch.cat(
             [loaded[i][F"""layers.{layer_i}.feed_forward.w3.weight"""] for i in range(A  )]  ,		dim=0  )

      __snake_case				:      str     							= inv_freq
      for k, v in state_dict.items():
         __snake_case				:      Union[str, Any]     							= filename
         param_count += v.numel()
      torch.save(A  ,		os.path.join(A  ,		A  )  )

   __snake_case				:      Optional[int]     							= F"""pytorch_model-{n_layers + 1}-of-{n_layers + 1}.bin"""
   if model_size == "7B":
      # Unsharded
      __snake_case				:      List[str]     							= {
          'model.embed_tokens.weight': loaded['tok_embeddings.weight'],
          'model.norm.weight': loaded['norm.weight'],
          'lm_head.weight': loaded['output.weight'],
      }
   else:
      __snake_case				:      str     							= {
          'model.norm.weight': loaded[0]['norm.weight'],
          'model.embed_tokens.weight': torch.cat(
              [loaded[i]['tok_embeddings.weight'] for i in range(A  )]  ,		dim=1  ),
          'lm_head.weight': torch.cat([loaded[i]['output.weight'] for i in range(A  )]  ,		dim=0  ),
      }

   for k, v in state_dict.items():
      __snake_case				:      Union[str, Any]     							= filename
      param_count += v.numel()
   torch.save(A  ,		os.path.join(A  ,		A  )  )

   # Write configs
   __snake_case				:      Optional[int]     							= {'total_size': param_count * 2}
   write_json(A  ,		os.path.join(A  ,		'pytorch_model.bin.index.json'  )  )
   __snake_case				:      List[str]     							= params['ffn_dim_multiplier'] if 'ffn_dim_multiplier' in params else 1
   __snake_case				:      Tuple     							= params['multiple_of'] if 'multiple_of' in params else 2_56
   __snake_case				:      Optional[Any]     							= LlamaConfig(
       hidden_size=A  ,		intermediate_size=compute_intermediate_size(A  ,		A  ,		A  )  ,		num_attention_heads=params['n_heads']  ,		num_hidden_layers=params['n_layers']  ,		rms_norm_eps=params['norm_eps']  ,		num_key_value_heads=A  ,		)
   config.save_pretrained(A  )

   # Make space so we can load the model properly now.
   del state_dict
   del loaded
   gc.collect()

   print('Loading the checkpoint in a Llama model.'  )
   __snake_case				:      List[str]     							= LlamaForCausalLM.from_pretrained(A  ,		torch_dtype=torch.floataa  ,		low_cpu_mem_usage=A  )
   # Avoid saving this as part of the config.
   del model.config._name_or_path

   print('Saving in the Transformers format.'  )
   model.save_pretrained(A  ,		safe_serialization=A  )
   shutil.rmtree(A  )




def        _SCREAMING_SNAKE_CASE  (				A  :       Dict  ,		A  :       Dict  )    -> Dict:







   """simple docstring"""
   # Initialize the tokenizer based on the `spm` model
   __snake_case				:      Tuple     							= LlamaTokenizer if LlamaTokenizerFast is None else LlamaTokenizerFast
   print(F"""Saving a {tokenizer_class.__name__} to {tokenizer_path}."""  )
   __snake_case				:      str     							= tokenizer_class(A  )
   tokenizer.save_pretrained(A  )




def        _SCREAMING_SNAKE_CASE  (				)    -> int:







   """simple docstring"""
   __snake_case				:      Optional[Any]     							= argparse.ArgumentParser()
   parser.add_argument(
       '--input_dir'  ,		help='Location of LLaMA weights, which contains tokenizer.model and model folders'  ,		)
   parser.add_argument(
       '--model_size'  ,		choices=['7B', '7Bf', '13B', '13Bf', '30B', '65B', '70B', '70Bf', 'tokenizer_only']  ,		)
   parser.add_argument(
       '--output_dir'  ,		help='Location to write HF model and tokenizer'  ,		)
   parser.add_argument('--safe_serialization'  ,		type=A  ,		help='Whether or not to save using `safetensors`.'  )
   __snake_case				:      Tuple     							= parser.parse_args()
   if args.model_size != "tokenizer_only":
      write_model(
          model_path=args.output_dir  ,		input_base_path=os.path.join(args.input_dir  ,		args.model_size  )  ,		model_size=args.model_size  ,		safe_serialization=args.safe_serialization  ,		)
   __snake_case				:      Optional[int]     							= os.path.join(args.input_dir  ,		'tokenizer.model'  )
   write_tokenizer(args.output_dir  ,		A  )


if __name__ == "__main__":
      main()







'''simple docstring'''






import inspect
import unittest
from typing import List

import numpy as np

from transformers import EfficientFormerConfig
from transformers.testing_utils import require_tf, require_vision, slow
from transformers.utils import cached_property, is_tf_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
      import tensorflow as tf

      from transformers import (
          TFEfficientFormerForImageClassification,
          TFEfficientFormerForImageClassificationWithTeacher,
          TFEfficientFormerModel,
      )
      from transformers.models.efficientformer.modeling_tf_efficientformer import (
          TF_EFFICIENTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
      )


if is_vision_available():
      from PIL import Image

      from transformers import EfficientFormerImageProcessor




class a_    :







   def __init__(self					,   __a					,   __a = 1_3					,   __a = 6_4					,   __a = 2					,   __a = 3					,   __a = 3					,   __a = True					,   __a = True					,   __a = 1_2_8					,   __a=[1_6, 3_2, 6_4, 1_2_8]					,   __a = 7					,   __a = 4					,   __a = 3_7					,   __a = "gelu"					,   __a = 0.1					,   __a = 0.1					,   __a = 1_0					,   __a = 0.02					,   __a = 2					,   __a = 1					,   __a = 1_2_8					,   __a = [2, 2, 2, 2]					,   __a = 2					,   __a = 2					,   )			->      str:
      """simple docstring"""






      __snake_case				:      Optional[Any]     							= parent
      __snake_case				:      Optional[int]     							= batch_size
      __snake_case				:      Optional[Any]     							= image_size
      __snake_case				:      Optional[int]     							= patch_size
      __snake_case				:      Optional[Any]     							= num_channels
      __snake_case				:      Optional[Any]     							= is_training
      __snake_case				:      Tuple     							= use_labels
      __snake_case				:      Optional[int]     							= hidden_size
      __snake_case				:      Any     							= num_hidden_layers
      __snake_case				:      List[str]     							= num_attention_heads
      __snake_case				:      Tuple     							= intermediate_size
      __snake_case				:      List[str]     							= hidden_act
      __snake_case				:      Dict     							= hidden_dropout_prob
      __snake_case				:      Any     							= attention_probs_dropout_prob
      __snake_case				:      Dict     							= type_sequence_label_size
      __snake_case				:      str     							= initializer_range
      __snake_case				:      int     							= encoder_stride
      __snake_case				:      List[str]     							= num_attention_outputs
      __snake_case				:      Optional[Any]     							= embed_dim
      __snake_case				:      Optional[Any]     							= embed_dim + 1
      __snake_case				:      List[str]     							= resolution
      __snake_case				:      Optional[int]     							= depths
      __snake_case				:      List[Any]     							= hidden_sizes
      __snake_case				:      List[str]     							= dim
      __snake_case				:      Union[str, Any]     							= mlp_expansion_ratio







   def     SCREAMING_SNAKE_CASE__					(self)			->      List[Any]:
      """simple docstring"""






      __snake_case				:      Optional[Any]     							= floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size])

      __snake_case				:      List[str]     							= None
      if self.use_labels:
         __snake_case				:      Optional[int]     							= ids_tensor([self.batch_size]					,   self.type_sequence_label_size)

      __snake_case				:      Tuple     							= self.get_config()

      return config, pixel_values, labels







   def     SCREAMING_SNAKE_CASE__					(self)			->      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=__a					,   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     SCREAMING_SNAKE_CASE__					(self					,   __a					,   __a					,   __a)			->      Optional[int]:
      """simple docstring"""






      __snake_case				:      Union[str, Any]     							= TFEfficientFormerModel(config=__a)
      __snake_case				:      int     							= model(__a					,   training=__a)
      self.parent.assertEqual(result.last_hidden_state.shape					,   (self.batch_size, self.seq_length, self.hidden_size))







   def     SCREAMING_SNAKE_CASE__					(self					,   __a					,   __a					,   __a)			->      Tuple:
      """simple docstring"""






      __snake_case				:      Dict     							= self.type_sequence_label_size
      __snake_case				:      List[Any]     							= TFEfficientFormerForImageClassification(__a)
      __snake_case				:      Optional[int]     							= model(__a					,   labels=__a					,   training=__a)
      self.parent.assertEqual(result.logits.shape					,   (self.batch_size, self.type_sequence_label_size))

      # test greyscale images
      __snake_case				:      List[Any]     							= 1
      __snake_case				:      List[Any]     							= TFEfficientFormerForImageClassification(__a)

      __snake_case				:      List[str]     							= floats_tensor([self.batch_size, 1, self.image_size, self.image_size])
      __snake_case				:      str     							= model(__a					,   labels=__a)
      self.parent.assertEqual(result.logits.shape					,   (self.batch_size, self.type_sequence_label_size))







   def     SCREAMING_SNAKE_CASE__					(self)			->      Any:
      """simple docstring"""






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




@require_tf
class a_    (    UpperCamelCase_		,      UpperCamelCase_		,      unittest.TestCase							):
   _snake_case        =							(
       (
           TFEfficientFormerModel,
           TFEfficientFormerForImageClassificationWithTeacher,
           TFEfficientFormerForImageClassification,
       )
       if is_tf_available()
       else ()
   )
   _snake_case        =							(
       {
           """feature-extraction""": TFEfficientFormerModel,
           """image-classification""": (
               TFEfficientFormerForImageClassification,
               TFEfficientFormerForImageClassificationWithTeacher,
           ),
       }
       if is_tf_available()
       else {}
   )

   _snake_case        =							False

   _snake_case        =							False
   _snake_case        =							False
   _snake_case        =							False
   _snake_case        =							False







   def     SCREAMING_SNAKE_CASE__					(self)			->      Dict:
      """simple docstring"""






      __snake_case				:      Dict     							= TFEfficientFormerModelTester(self)
      __snake_case				:      List[Any]     							= ConfigTester(
          self					,   config_class=__a					,   has_text_modality=__a					,   hidden_size=3_7)







   def     SCREAMING_SNAKE_CASE__					(self)			->      str:
      """simple docstring"""






      self.config_tester.run_common_tests()







   @unittest.skip(reason='EfficientFormer does not use inputs_embeds')
   def     SCREAMING_SNAKE_CASE__					(self)			->      Union[str, Any]:
      """simple docstring"""






      pass







   @unittest.skip(reason='EfficientFormer does not support input and output embeddings')
   def     SCREAMING_SNAKE_CASE__					(self)			->      Optional[Any]:
      """simple docstring"""






      pass







   def     SCREAMING_SNAKE_CASE__					(self)			->      Any:
      """simple docstring"""






      __snake_case							,__snake_case				:      str     							= self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
         __snake_case				:      Optional[int]     							= model_class(__a)
         __snake_case				:      Union[str, Any]     							= inspect.signature(model.call)
         # signature.parameters is an OrderedDict => so arg_names order is deterministic
         __snake_case				:      Optional[int]     							= [*signature.parameters.keys()]

         __snake_case				:      Dict     							= ['pixel_values']
         self.assertListEqual(arg_names[:1]					,   __a)







   def     SCREAMING_SNAKE_CASE__					(self)			->      Optional[int]:
      """simple docstring"""






      def check_hidden_states_output(__a					,   __a					,   __a):
         __snake_case				:      str     							= model_class(__a)

         __snake_case				:      List[Any]     							= model(**self._prepare_for_class(__a					,   __a)					,   training=__a)
         __snake_case				:      str     							= outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

         __snake_case				:      Optional[Any]     							= getattr(
             self.model_tester					,   'expected_num_hidden_layers'					,   self.model_tester.num_hidden_layers + 1)
         self.assertEqual(len(__a)					,   __a)

         if hasattr(self.model_tester					,   'encoder_seq_length'):
            __snake_case				:      List[Any]     							= self.model_tester.encoder_seq_length
            if hasattr(self.model_tester					,   'chunk_length') and self.model_tester.chunk_length > 1:
               __snake_case				:      str     							= seq_length * self.model_tester.chunk_length
         else:
            __snake_case				:      Optional[int]     							= 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:
            __snake_case				:      List[Any]     							= outputs.decoder_hidden_states

            self.asseretIsInstance(__a					,   (list, tuple))
            self.assertEqual(len(__a)					,   __a)
            __snake_case				:      List[str]     							= getattr(self.model_tester					,   'seq_length'					,   __a)
            __snake_case				:      Tuple     							= getattr(self.model_tester					,   'decoder_seq_length'					,   __a)

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

      __snake_case							,__snake_case				:      Optional[int]     							= self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
         __snake_case				:      List[str]     							= True
         check_hidden_states_output(__a					,   __a					,   __a)

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

         check_hidden_states_output(__a					,   __a					,   __a)







   def     SCREAMING_SNAKE_CASE__					(self					,   __a					,   __a					,   __a=False)			->      int:
      """simple docstring"""






      __snake_case				:      Optional[int]     							= super()._prepare_for_class(__a					,   __a					,   return_labels=__a)

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

      return inputs_dict







   def     SCREAMING_SNAKE_CASE__					(self)			->      Union[str, Any]:
      """simple docstring"""






      __snake_case				:      Any     							= self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_model(*__a)







   @unittest.skip(reason='EfficientFormer does not implement masked image modeling yet')
   def     SCREAMING_SNAKE_CASE__					(self)			->      Tuple:
      """simple docstring"""






      __snake_case				:      int     							= self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_masked_image_modeling(*__a)







   def     SCREAMING_SNAKE_CASE__					(self)			->      int:
      """simple docstring"""






      __snake_case				:      Any     							= self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_image_classification(*__a)







   @slow
   def     SCREAMING_SNAKE_CASE__					(self)			->      List[str]:
      """simple docstring"""






      for model_name in TF_EFFICIENTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
         __snake_case				:      Any     							= TFEfficientFormerModel.from_pretrained(__a)
         self.assertIsNotNone(__a)







   def     SCREAMING_SNAKE_CASE__					(self)			->      Tuple:
      """simple docstring"""






      __snake_case							,__snake_case				:      Optional[int]     							= self.model_tester.prepare_config_and_inputs_for_common()
      __snake_case				:      Tuple     							= True

      __snake_case				:      Optional[Any]     							= getattr(self.model_tester					,   'seq_length'					,   __a)
      __snake_case				:      List[Any]     							= getattr(self.model_tester					,   'encoder_seq_length'					,   __a)
      __snake_case				:      Tuple     							= getattr(self.model_tester					,   'key_length'					,   __a)
      __snake_case				:      Optional[Any]     							= getattr(self.model_tester					,   'chunk_length'					,   __a)

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

      for model_class in self.all_model_classes:
         __snake_case				:      Optional[Any]     							= True
         __snake_case				:      Dict     							= False
         __snake_case				:      Optional[int]     							= True
         __snake_case				:      Dict     							= model_class(__a)

         __snake_case				:      Tuple     							= model(**self._prepare_for_class(__a					,   __a)					,   training=__a)
         __snake_case				:      Union[str, Any]     							= outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions
         self.assertEqual(len(__a)					,   self.model_tester.num_attention_outputs)

         # check that output_attentions also work using config
         del inputs_dict["output_attentions"]
         __snake_case				:      Dict     							= True
         __snake_case				:      str     							= model_class(__a)
         __snake_case				:      str     							= model(**self._prepare_for_class(__a					,   __a)					,   training=__a)

         __snake_case				:      Tuple     							= outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions
         self.assertEqual(len(__a)					,   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     SCREAMING_SNAKE_CASE__					(self)			->      int:
      """simple docstring"""






      __snake_case							,__snake_case				:      Dict     							= self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
         # Prepare our model
         __snake_case				:      Tuple     							= model_class(__a)
         # These are maximally general inputs for the model, with multiple None dimensions
         # Hopefully this will catch any conditionals that fail for flexible shapes
         __snake_case				:      Optional[Any]     							= {
             key: tf.keras.Input(shape=val.shape[1:]					,   dtype=val.dtype					,   name=__a)
             for key, val in model.input_signature.items()
             if key in model.dummy_inputs
         }
         __snake_case				:      Tuple     							= model(__a)
         self.assertTrue(outputs_dict is not None)




def        _SCREAMING_SNAKE_CASE  (				)    -> int:







   """simple docstring"""
   __snake_case				:      Tuple     							= Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'  )
   return image





@require_tf
@require_vision
class a_    (    unittest.TestCase							):







   @cached_property
   def     SCREAMING_SNAKE_CASE__					(self)			->      int:
      """simple docstring"""






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







   @slow
   def     SCREAMING_SNAKE_CASE__					(self)			->      Union[str, Any]:
      """simple docstring"""






      __snake_case				:      List[str]     							= TFEfficientFormerForImageClassification.from_pretrained('snap-research/efficientformer-l1-300')
      __snake_case				:      Optional[int]     							= self.default_image_processor
      __snake_case				:      List[Any]     							= prepare_img()
      __snake_case				:      List[Any]     							= image_processor(images=__a					,   return_tensors='tf')
      # forward pass
      __snake_case				:      List[str]     							= model(**__a					,   training=__a)
      # verify the logits
      __snake_case				:      str     							= tf.TensorShape((1, 1_0_0_0))
      self.assertEqual(outputs.logits.shape					,   __a)
      __snake_case				:      Any     							= tf.constant([-0.0_555, 0.4_825, -0.0_852])
      self.assertTrue(np.allclose(outputs.logits[0, :3]					,   __a					,   atol=1E-4))







   @slow
   def     SCREAMING_SNAKE_CASE__					(self)			->      List[Any]:
      """simple docstring"""






      __snake_case				:      List[Any]     							= TFEfficientFormerForImageClassificationWithTeacher.from_pretrained(
          'snap-research/efficientformer-l1-300')
      __snake_case				:      List[Any]     							= self.default_image_processor
      __snake_case				:      Union[str, Any]     							= prepare_img()
      __snake_case				:      List[Any]     							= image_processor(images=__a					,   return_tensors='tf')
      # forward pass
      __snake_case				:      Optional[int]     							= model(**__a					,   training=__a)
      # verify the logits
      __snake_case				:      Optional[int]     							= tf.TensorShape((1, 1_0_0_0))
      self.assertEqual(outputs.logits.shape					,   __a)
      __snake_case				:      List[str]     							= tf.constant([-0.1_312, 0.4_353, -1.0_499])
      self.assertTrue(np.allclose(outputs.logits[0, :3]					,   __a					,   atol=1E-4))