
import unittest

from parameterized import parameterized

from transformers import LlamaConfig, is_torch_available, set_seed
from transformers.testing_utils import require_torch, slow, torch_device

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


if is_torch_available():
			import torch

			from transformers import LlamaForCausalLM, LlamaForSequenceClassification, LlamaModel, LlamaTokenizer




class        SCREAMING_SNAKE_CASE__					:





	'''simple docstring'''



	def __init__(  self     :   List[str]      ,  lowercase     :   int      ,  lowercase     :   Any=13      ,  lowercase     :   Dict=7      ,  lowercase     :   Any=True      ,  lowercase     :   Optional[int]=True      ,  lowercase     :   int=False      ,  lowercase     :   Any=True      ,  lowercase     :   Union[str, Any]=99      ,  lowercase     :   List[Any]=32      ,  lowercase     :   str=5      ,  lowercase     :   List[Any]=4      ,  lowercase     :   Union[str, Any]=37      ,  lowercase     :   List[Any]="gelu"      ,  lowercase     :   int=0.1      ,  lowercase     :   str=0.1      ,  lowercase     :   Dict=512      ,  lowercase     :   int=16      ,  lowercase     :   List[str]=2      ,  lowercase     :   List[str]=0.02      ,  lowercase     :   Tuple=3      ,  lowercase     :   Dict=4      ,  lowercase     :   Union[str, Any]=None      ,  ):


				'''simple docstring'''


				_snake_case          =      parent
				_snake_case          =      batch_size
				_snake_case          =      seq_length
				_snake_case          =      is_training
				_snake_case          =      use_input_mask
				_snake_case          =      use_token_type_ids
				_snake_case          =      use_labels
				_snake_case          =      vocab_size
				_snake_case          =      hidden_size
				_snake_case          =      num_hidden_layers
				_snake_case          =      num_attention_heads
				_snake_case          =      intermediate_size
				_snake_case          =      hidden_act
				_snake_case          =      hidden_dropout_prob
				_snake_case          =      attention_probs_dropout_prob
				_snake_case          =      max_position_embeddings
				_snake_case          =      type_vocab_size
				_snake_case          =      type_sequence_label_size
				_snake_case          =      initializer_range
				_snake_case          =      num_labels
				_snake_case          =      num_choices
				_snake_case          =      scope



	def 			A							(  self     :   Optional[Any]     ):


				'''simple docstring'''


				_snake_case          =      ids_tensor([self.batch_size, self.seq_length]      ,  self.vocab_size     )

				_snake_case          =      None
				if self.use_input_mask:
							_snake_case          =      random_attention_mask([self.batch_size, self.seq_length]     )

				_snake_case          =      None
				if self.use_token_type_ids:
							_snake_case          =      ids_tensor([self.batch_size, self.seq_length]      ,  self.type_vocab_size     )

				_snake_case          =      None
				_snake_case          =      None
				_snake_case          =      None
				if self.use_labels:
							_snake_case          =      ids_tensor([self.batch_size]      ,  self.type_sequence_label_size     )
							_snake_case          =      ids_tensor([self.batch_size, self.seq_length]      ,  self.num_labels     )
							_snake_case          =      ids_tensor([self.batch_size]      ,  self.num_choices     )

				_snake_case          =      self.get_config()

				return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels



	def 			A							(  self     :   Optional[int]     ):


				'''simple docstring'''


				return LlamaConfig(
				    vocab_size=self.vocab_size      ,  hidden_size=self.hidden_size      ,  num_hidden_layers=self.num_hidden_layers      ,  num_attention_heads=self.num_attention_heads      ,  intermediate_size=self.intermediate_size      ,  hidden_act=self.hidden_act      ,  hidden_dropout_prob=self.hidden_dropout_prob      ,  attention_probs_dropout_prob=self.attention_probs_dropout_prob      ,  max_position_embeddings=self.max_position_embeddings      ,  type_vocab_size=self.type_vocab_size      ,  is_decoder=lowercase      ,  initializer_range=self.initializer_range      ,  )



	def 			A							(  self     :   int      ,  lowercase     :   Optional[Any]      ,  lowercase     :   int      ,  lowercase     :   Any      ,  lowercase     :   Union[str, Any]      ,  lowercase     :   Optional[int]      ,  lowercase     :   Tuple      ,  lowercase     :   Any     ):


				'''simple docstring'''


				_snake_case          =      LlamaModel(config=lowercase     )
				model.to(lowercase     )
				model.eval()
				_snake_case          =      model(lowercase      ,  attention_mask=lowercase     )
				_snake_case          =      model(lowercase     )
				self.parent.assertEqual(result.last_hidden_state.shape      ,  (self.batch_size, self.seq_length, self.hidden_size)     )



	def 			A							(  self     :   int      ,  lowercase     :   Any      ,  lowercase     :   Optional[Any]      ,  lowercase     :   int      ,  lowercase     :   Union[str, Any]      ,  lowercase     :   List[Any]      ,  lowercase     :   int      ,  lowercase     :   Optional[int]      ,  lowercase     :   Union[str, Any]      ,  lowercase     :   str      ,  ):


				'''simple docstring'''


				_snake_case          =      True
				_snake_case          =      LlamaModel(lowercase     )
				model.to(lowercase     )
				model.eval()
				_snake_case          =      model(
				    lowercase      ,  attention_mask=lowercase      ,  encoder_hidden_states=lowercase      ,  encoder_attention_mask=lowercase      ,  )
				_snake_case          =      model(
				    lowercase      ,  attention_mask=lowercase      ,  encoder_hidden_states=lowercase      ,  )
				_snake_case          =      model(lowercase      ,  attention_mask=lowercase     )
				self.parent.assertEqual(result.last_hidden_state.shape      ,  (self.batch_size, self.seq_length, self.hidden_size)     )



	def 			A							(  self     :   List[str]      ,  lowercase     :   str      ,  lowercase     :   Optional[int]      ,  lowercase     :   List[Any]      ,  lowercase     :   Optional[Any]      ,  lowercase     :   Union[str, Any]      ,  lowercase     :   Tuple      ,  lowercase     :   Tuple      ,  lowercase     :   Optional[int]      ,  lowercase     :   Any      ,  ):


				'''simple docstring'''


				_snake_case          =      LlamaForCausalLM(config=lowercase     )
				model.to(lowercase     )
				model.eval()
				_snake_case          =      model(lowercase      ,  attention_mask=lowercase      ,  labels=lowercase     )
				self.parent.assertEqual(result.logits.shape      ,  (self.batch_size, self.seq_length, self.vocab_size)     )



	def 			A							(  self     :   str      ,  lowercase     :   Optional[int]      ,  lowercase     :   List[Any]      ,  lowercase     :   List[str]      ,  lowercase     :   Tuple      ,  lowercase     :   int      ,  lowercase     :   Optional[int]      ,  lowercase     :   Union[str, Any]      ,  lowercase     :   Optional[Any]      ,  lowercase     :   str      ,  ):


				'''simple docstring'''


				_snake_case          =      True
				_snake_case          =      True
				_snake_case          =      LlamaForCausalLM(config=lowercase     )
				model.to(lowercase     )
				model.eval()

				# first forward pass
				_snake_case          =      model(
				    lowercase      ,  attention_mask=lowercase      ,  encoder_hidden_states=lowercase      ,  encoder_attention_mask=lowercase      ,  use_cache=lowercase      ,  )
				_snake_case          =      outputs.past_key_values

				# create hypothetical multiple next token and extent to next_input_ids
				_snake_case          =      ids_tensor((self.batch_size, 3)      ,  config.vocab_size     )
				_snake_case          =      ids_tensor((self.batch_size, 3)      ,  vocab_size=2     )

				# append to next input_ids and
				_snake_case          =      torch.cat([input_ids, next_tokens]      ,  dim=-1     )
				_snake_case          =      torch.cat([input_mask, next_mask]      ,  dim=-1     )

				_snake_case          =      model(
				    lowercase      ,  attention_mask=lowercase      ,  encoder_hidden_states=lowercase      ,  encoder_attention_mask=lowercase      ,  output_hidden_states=lowercase      ,  )['hidden_states'][0]
				_snake_case          =      model(
				    lowercase      ,  attention_mask=lowercase      ,  encoder_hidden_states=lowercase      ,  encoder_attention_mask=lowercase      ,  past_key_values=lowercase      ,  output_hidden_states=lowercase      ,  )['hidden_states'][0]

				# select random slice
				_snake_case          =      ids_tensor((1,)      ,  output_from_past.shape[-1]     ).item()
				_snake_case          =      output_from_no_past[:, -3:, random_slice_idx].detach()
				_snake_case          =      output_from_past[:, :, random_slice_idx].detach()

				self.parent.assertTrue(output_from_past_slice.shape[1] == next_tokens.shape[1]     )

				# test that outputs are equal for slice
				self.parent.assertTrue(torch.allclose(lowercase      ,  lowercase      ,  atol=1E-3     )     )





	def 			A							(  self     :   Tuple     ):


				'''simple docstring'''


				_snake_case          =      self.prepare_config_and_inputs()
				(
				    (
				    _snake_case
				)     , (
				    _snake_case
				)     , (
				    _snake_case
				)     , (
				    _snake_case
				)     , (
				    _snake_case
				)     , (
				    _snake_case
				)     , (
				    _snake_case
				)     , 
				)          =      config_and_inputs
				_snake_case          =      {'input_ids': input_ids, 'attention_mask': input_mask}
				return config, inputs_dict




@require_torch
class        SCREAMING_SNAKE_CASE__					(     UpperCAmelCase							,UpperCAmelCase							,UpperCAmelCase							,unittest.TestCase ):





	'''simple docstring'''



	_UpperCAmelCase	:		Union[str, Any]          = (LlamaModel, LlamaForCausalLM, LlamaForSequenceClassification) if is_torch_available() else ()
	_UpperCAmelCase	:		List[Any]          = (LlamaForCausalLM,) if is_torch_available() else ()
	_UpperCAmelCase	:		str          = (
	    {
	        "feature-extraction": LlamaModel,
	        "text-classification": LlamaForSequenceClassification,
	        "text-generation": LlamaForCausalLM,
	        "zero-shot": LlamaForSequenceClassification,
	    }
	    if is_torch_available()
	    else {}
	)
	_UpperCAmelCase	:		Union[str, Any]          = False
	_UpperCAmelCase	:		Dict          = False



	def 			A							(  self     :   Dict     ):


				'''simple docstring'''


				_snake_case          =      LlamaModelTester(self     )
				_snake_case          =      ConfigTester(self      ,  config_class=lowercase      ,  hidden_size=37     )



	def 			A							(  self     :   List[str]     ):


				'''simple docstring'''


				self.config_tester.run_common_tests()



	def 			A							(  self     :   Optional[int]     ):


				'''simple docstring'''


				_snake_case          =      self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_model(*lowercase     )



	def 			A							(  self     :   Tuple     ):


				'''simple docstring'''


				_snake_case          =      self.model_tester.prepare_config_and_inputs()
				for type in ["absolute", "relative_key", "relative_key_query"]:
							_snake_case          =      type
							self.model_tester.create_and_check_model(*lowercase     )



	def 			A							(  self     :   Dict     ):


				'''simple docstring'''


				_snake_case     , _snake_case          =      self.model_tester.prepare_config_and_inputs_for_common()
				_snake_case          =      3
				_snake_case          =      input_dict['input_ids']
				_snake_case          =      input_ids.ne(1     ).to(lowercase     )
				_snake_case          =      ids_tensor([self.model_tester.batch_size]      ,  self.model_tester.type_sequence_label_size     )
				_snake_case          =      LlamaForSequenceClassification(lowercase     )
				model.to(lowercase     )
				model.eval()
				_snake_case          =      model(lowercase      ,  attention_mask=lowercase      ,  labels=lowercase     )
				self.assertEqual(result.logits.shape      ,  (self.model_tester.batch_size, self.model_tester.num_labels)     )



	def 			A							(  self     :   Union[str, Any]     ):


				'''simple docstring'''


				_snake_case     , _snake_case          =      self.model_tester.prepare_config_and_inputs_for_common()
				_snake_case          =      3
				_snake_case          =      'single_label_classification'
				_snake_case          =      input_dict['input_ids']
				_snake_case          =      input_ids.ne(1     ).to(lowercase     )
				_snake_case          =      ids_tensor([self.model_tester.batch_size]      ,  self.model_tester.type_sequence_label_size     )
				_snake_case          =      LlamaForSequenceClassification(lowercase     )
				model.to(lowercase     )
				model.eval()
				_snake_case          =      model(lowercase      ,  attention_mask=lowercase      ,  labels=lowercase     )
				self.assertEqual(result.logits.shape      ,  (self.model_tester.batch_size, self.model_tester.num_labels)     )



	def 			A							(  self     :   List[str]     ):


				'''simple docstring'''


				_snake_case     , _snake_case          =      self.model_tester.prepare_config_and_inputs_for_common()
				_snake_case          =      3
				_snake_case          =      'multi_label_classification'
				_snake_case          =      input_dict['input_ids']
				_snake_case          =      input_ids.ne(1     ).to(lowercase     )
				_snake_case          =      ids_tensor(
				    [self.model_tester.batch_size, config.num_labels]      ,  self.model_tester.type_sequence_label_size     ).to(torch.float     )
				_snake_case          =      LlamaForSequenceClassification(lowercase     )
				model.to(lowercase     )
				model.eval()
				_snake_case          =      model(lowercase      ,  attention_mask=lowercase      ,  labels=lowercase     )
				self.assertEqual(result.logits.shape      ,  (self.model_tester.batch_size, self.model_tester.num_labels)     )



	@unittest.skip('LLaMA buffers include complex numbers, which breaks this test'     )
	def 			A							(  self     :   Optional[int]     ):


				'''simple docstring'''


				pass





	@parameterized.expand([('linear',), ('dynamic',)]     )
	def 			A							(  self     :   Optional[int]      ,  lowercase     :   Optional[Any]     ):


				'''simple docstring'''


				_snake_case     , _snake_case          =      self.model_tester.prepare_config_and_inputs_for_common()
				_snake_case          =      ids_tensor([1, 10]      ,  config.vocab_size     )
				_snake_case          =      ids_tensor([1, int(config.max_position_embeddings * 1.5     )]      ,  config.vocab_size     )

				set_seed(42     )  # Fixed seed at init time so the two models get the same random weights
				_snake_case          =      LlamaModel(lowercase     )
				original_model.to(lowercase     )
				original_model.eval()
				_snake_case          =      original_model(lowercase     ).last_hidden_state
				_snake_case          =      original_model(lowercase     ).last_hidden_state

				set_seed(42     )  # Fixed seed at init time so the two models get the same random weights
				_snake_case          =      {'type': scaling_type, 'factor': 10.0}
				_snake_case          =      LlamaModel(lowercase     )
				scaled_model.to(lowercase     )
				scaled_model.eval()
				_snake_case          =      scaled_model(lowercase     ).last_hidden_state
				_snake_case          =      scaled_model(lowercase     ).last_hidden_state

				# Dynamic scaling does not change the RoPE embeddings until it receives an input longer than the original
				# maximum sequence length, so the outputs for the short input should match.
				if scaling_type == "dynamic":
							self.assertTrue(torch.allclose(lowercase      ,  lowercase      ,  atol=1E-5     )     )
				else:
							self.assertFalse(torch.allclose(lowercase      ,  lowercase      ,  atol=1E-5     )     )

				# The output should be different for long inputs
				self.assertFalse(torch.allclose(lowercase      ,  lowercase      ,  atol=1E-5     )     )




@require_torch
class        SCREAMING_SNAKE_CASE__					(     unittest.TestCase ):





	'''simple docstring'''



	@unittest.skip('Logits are not exactly the same, once we fix the instabalities somehow, will update!'     )
	@slow
	def 			A							(  self     :   int     ):


				'''simple docstring'''


				_snake_case          =      [1, 306, 4_658, 278, 6_593, 310, 2_834, 338]
				_snake_case          =      LlamaForCausalLM.from_pretrained('meta-llama/Llama-2-7b-hf'      ,  device_map='auto'     )
				_snake_case          =      model(torch.tensor([input_ids]     )     )
				# Expected mean on dim = -1
				_snake_case          =      torch.tensor([[-6.6550, -4.1227, -4.9859, -3.2406, 0.8262, -3.0033, 1.2964, -3.3699]]     )
				torch.testing.assert_close(out.mean(-1     )      ,  lowercase      ,  atol=1E-2      ,  rtol=1E-2     )
				# slicing logits[0, 0, 0:30]
				# fmt: off
				_snake_case          =      torch.tensor([-12.8281, -7.4453, -0.4639, -8.0625, -7.2500, -8.0000, -6.4883, -7.7695, -7.8438, -7.0312, -6.2188, -7.1328, -1.8496, 1.9961, -8.6250, -6.7227, -12.8281, -6.9492, -7.0742, -7.7852, -7.5820, -7.9062, -6.9375, -7.9805, -8.3438, -8.1562, -8.0469, -7.6250, -7.7422, -7.3398,]     )
				# fmt: on
				torch.testing.assert_close(out[0, 0, :30]      ,  lowercase      ,  atol=1E-5      ,  rtol=1E-5     )



	@unittest.skip('Logits are not exactly the same, once we fix the instabalities somehow, will update!'     )
	@slow
	def 			A							(  self     :   str     ):


				'''simple docstring'''


				_snake_case          =      [1, 306, 4_658, 278, 6_593, 310, 2_834, 338]
				_snake_case          =      LlamaForCausalLM.from_pretrained('meta-llama/Llama-2-13b-hf'      ,  device_map='auto'     )
				_snake_case          =      model(torch.tensor(lowercase     )     )
				# Expected mean on dim = -1
				_snake_case          =      torch.tensor([[-2.0622, -1.2794, -1.1638, -0.9788, -1.4603, -1.0238, -1.7893, -1.4411]]     )
				torch.testing.assert_close(out.mean(-1     )      ,  lowercase      ,  atol=1E-2      ,  rtol=1E-2     )
				# slicing logits[0, 0, 0:30]
				# fmt: off
				_snake_case          =      torch.tensor([-8.1406, -8.0547, 2.7461, -1.2344, -0.1448, -1.8262, -1.0020, -1.8154, -1.6895, -1.8516, -2.3574, -0.9277, 3.7598, 6.5742, -1.2998, -0.1177, -8.1406, -2.9688, -2.9199, -3.1699, -3.5254, -2.3555, -2.7988, -3.4141, -2.8262, -4.5195, -3.3379, -3.3164, -2.7832, -3.0273]     )
				# fmt: on
				torch.testing.assert_close(out[0, 0, :30]      ,  lowercase      ,  atol=1E-5      ,  rtol=1E-5     )



	@unittest.skip('Logits are not exactly the same, once we fix the instabalities somehow, will update!'     )
	@slow
	def 			A							(  self     :   Tuple     ):


				'''simple docstring'''


				_snake_case          =      [1, 306, 4_658, 278, 6_593, 310, 2_834, 338]
				_snake_case          =      LlamaForCausalLM.from_pretrained('meta-llama/Llama-2-13b-chat-hf'      ,  device_map='auto'     )
				_snake_case          =      model(torch.tensor(lowercase     )     )
				# Expected mean on dim = -1
				_snake_case          =      torch.tensor([[-0.8562, -1.8520, -0.7551, -0.4162, -1.5161, -1.2038, -2.4823, -2.3254]]     )
				torch.testing.assert_close(out.mean(-1     )      ,  lowercase      ,  atol=1E-2      ,  rtol=1E-2     )
				# slicing logits[0, 0, 0:30]
				# fmt: off
				_snake_case          =      torch.tensor([-2.2227, 4.8828, 0.9023, -0.4578, -0.7871, -0.1033, -0.6221, -0.5786, -0.7803, -1.0674, -1.2920, -0.1570, 0.8008, 2.0723, -0.9497, 0.2771, -2.2227, -0.7612, -1.4346, -1.2061, -1.6426, -0.3000, -0.7139, -1.1934, -1.8691, -1.6973, -1.5947, -1.2705, -0.3523, -0.5513]     )
				# fmt: on
				torch.testing.assert_close(out.mean(-1     )      ,  lowercase      ,  atol=1E-2      ,  rtol=1E-2     )



	@unittest.skip(
	    'Logits are not exactly the same, once we fix the instabalities somehow, will update! Also it is gonna be a `too_slow` test'     )
	@slow
	def 			A							(  self     :   Optional[Any]     ):


				'''simple docstring'''


				_snake_case          =      [1, 306, 4_658, 278, 6_593, 310, 2_834, 338]
				_snake_case          =      LlamaForCausalLM.from_pretrained('meta-llama/Llama-2-70b-hf'      ,  device_map='auto'     )
				_snake_case          =      model(torch.tensor(lowercase     )     )

				_snake_case          =      torch.tensor(
				    [[-4.2327, -3.3360, -4.6665, -4.7631, -1.8180, -3.4170, -1.4211, -3.1810]]      ,  dtype=torch.floataa     )
				torch.testing.assert_close(out.mean(-1     )      ,  lowercase      ,  atol=1E-2      ,  rtol=1E-2     )
				# fmt: off
				_snake_case          =      torch.tensor([-9.4922, -3.9551, 1.7998, -5.6758, -5.1055, -5.8984, -4.8320, -6.8086, -6.5391, -5.6172, -5.5820, -5.5352, 1.7881, 3.6289, -6.5117, -3.4785, -9.5000, -6.0352, -6.8125, -6.0195, -6.6836, -5.4727, -6.2812, -6.0391, -7.3398, -7.4297, -7.4844, -6.5820, -5.8789, -5.5312]     )
				# fmt: on
				torch.testing.assert_close(out[0, 0, :30]      ,  lowercase      ,  atol=1E-5      ,  rtol=1E-5     )





	@unittest.skip('Model is curently gated'     )
	@slow
	def 			A							(  self     :   Optional[int]     ):


				'''simple docstring'''


				_snake_case          =      'Simply put, the theory of relativity states that 1) the laws of physics are the same everywhere in the universe and 2) the passage of time and the length of objects can vary depending on the observer\'s frame of reference.\n\nThe first part of the theory, that the laws of physics are the same everywhere, is known as the "princi'
				_snake_case          =      'Simply put, the theory of relativity states that '
				_snake_case          =      LlamaTokenizer.from_pretrained('meta-llama/Llama-2-13b-chat-hf'     )
				_snake_case          =      tokenizer.encode(lowercase      ,  return_tensors='pt'     )
				_snake_case          =      LlamaForCausalLM.from_pretrained(
				    'meta-llama/Llama-2-13b-chat-hf'      ,  device_map='sequential'      ,  use_safetensors=lowercase     )

				# greedy generation outputs
				_snake_case          =      model.generate(lowercase      ,  max_new_tokens=64      ,  top_p=lowercase      ,  temperature=1      ,  do_sample=lowercase     )
				_snake_case          =      tokenizer.decode(generated_ids[0]      ,  skip_special_tokens=lowercase     )
				self.assertEqual(lowercase      ,  lowercase     )

import argparse
import json
import os

import numpy as np
import PIL
import requests
import tensorflow.keras.applications.efficientnet as efficientnet
import torch
from huggingface_hub import hf_hub_download
from PIL import Image
from tensorflow.keras.preprocessing import image

from transformers import (
    EfficientNetConfig,
    EfficientNetForImageClassification,
    EfficientNetImageProcessor,
)
from transformers.utils import logging


logging.set_verbosity_info()
_lowerCamelCase	:    int          =      logging.get_logger(__name__)

_lowerCamelCase	:    Tuple          =      {
    '''b0''': efficientnet.EfficientNetBa,
    '''b1''': efficientnet.EfficientNetBa,
    '''b2''': efficientnet.EfficientNetBa,
    '''b3''': efficientnet.EfficientNetBa,
    '''b4''': efficientnet.EfficientNetBa,
    '''b5''': efficientnet.EfficientNetBa,
    '''b6''': efficientnet.EfficientNetBa,
    '''b7''': efficientnet.EfficientNetBa,
}

_lowerCamelCase	:    List[str]          =      {
    '''b0''': {
        '''hidden_dim''': 1_280,
        '''width_coef''': 1.0,
        '''depth_coef''': 1.0,
        '''image_size''': 224,
        '''dropout_rate''': 0.2,
        '''dw_padding''': [],
    },
    '''b1''': {
        '''hidden_dim''': 1_280,
        '''width_coef''': 1.0,
        '''depth_coef''': 1.1,
        '''image_size''': 240,
        '''dropout_rate''': 0.2,
        '''dw_padding''': [16],
    },
    '''b2''': {
        '''hidden_dim''': 1_408,
        '''width_coef''': 1.1,
        '''depth_coef''': 1.2,
        '''image_size''': 260,
        '''dropout_rate''': 0.3,
        '''dw_padding''': [5, 8, 16],
    },
    '''b3''': {
        '''hidden_dim''': 1_536,
        '''width_coef''': 1.2,
        '''depth_coef''': 1.4,
        '''image_size''': 300,
        '''dropout_rate''': 0.3,
        '''dw_padding''': [5, 18],
    },
    '''b4''': {
        '''hidden_dim''': 1_792,
        '''width_coef''': 1.4,
        '''depth_coef''': 1.8,
        '''image_size''': 380,
        '''dropout_rate''': 0.4,
        '''dw_padding''': [6],
    },
    '''b5''': {
        '''hidden_dim''': 2_048,
        '''width_coef''': 1.6,
        '''depth_coef''': 2.2,
        '''image_size''': 456,
        '''dropout_rate''': 0.4,
        '''dw_padding''': [13, 27],
    },
    '''b6''': {
        '''hidden_dim''': 2_304,
        '''width_coef''': 1.8,
        '''depth_coef''': 2.6,
        '''image_size''': 528,
        '''dropout_rate''': 0.5,
        '''dw_padding''': [31],
    },
    '''b7''': {
        '''hidden_dim''': 2_560,
        '''width_coef''': 2.0,
        '''depth_coef''': 3.1,
        '''image_size''': 600,
        '''dropout_rate''': 0.5,
        '''dw_padding''': [18],
    },
}






def 	a_		(	__lowercase       :     int			)			->  Optional[int]:
			_snake_case          =      EfficientNetConfig()
			_snake_case          =      CONFIG_MAP[model_name]['hidden_dim']
			_snake_case          =      CONFIG_MAP[model_name]['width_coef']
			_snake_case          =      CONFIG_MAP[model_name]['depth_coef']
			_snake_case          =      CONFIG_MAP[model_name]['image_size']
			_snake_case          =      CONFIG_MAP[model_name]['dropout_rate']
			_snake_case          =      CONFIG_MAP[model_name]['dw_padding']

			_snake_case          =      'huggingface/label-files'
			_snake_case          =      'imagenet-1k-id2label.json'
			_snake_case          =      1_000
			_snake_case          =      json.load(open(hf_hub_download(__lowercase	, __lowercase	, repo_type='dataset'			)	, 'r'			)			)
			_snake_case          =      {int(__lowercase			): v for k, v in idalabel.items()}

			_snake_case          =      idalabel
			_snake_case          =      {v: k for k, v in idalabel.items()}
			return config






def 	a_		(	)			->  Any:
			_snake_case          =      'http://images.cocodataset.org/val2017/000000039769.jpg'
			_snake_case          =      Image.open(requests.get(__lowercase	, stream=__lowercase			).raw			)
			return im






def 	a_		(	__lowercase       :     Union[str, Any]			)			->  Tuple:
			_snake_case          =      CONFIG_MAP[model_name]['image_size']
			_snake_case          =      EfficientNetImageProcessor(
			    size={'height': size, 'width': size}	, image_mean=[0.4_8_5, 0.4_5_6, 0.4_0_6]	, image_std=[0.4_7_8_5_3_9_4_4, 0.4_7_3_2_8_6_4, 0.4_7_4_3_4_1_6_3]	, do_center_crop=__lowercase	, )
			return preprocessor






def 	a_		(	__lowercase       :     str			)			->  List[Any]:
			_snake_case          =      [v.split('_'			)[0].split('block'			)[1] for v in original_param_names if v.startswith('block'			)]
			_snake_case          =      sorted(set(__lowercase			)			)
			_snake_case          =      len(__lowercase			)
			_snake_case          =      {b: str(__lowercase			) for b, i in zip(__lowercase	, range(__lowercase			)			)}

			_snake_case          =      []
			rename_keys.append(('stem_conv/kernel:0', 'embeddings.convolution.weight')			)
			rename_keys.append(('stem_bn/gamma:0', 'embeddings.batchnorm.weight')			)
			rename_keys.append(('stem_bn/beta:0', 'embeddings.batchnorm.bias')			)
			rename_keys.append(('stem_bn/moving_mean:0', 'embeddings.batchnorm.running_mean')			)
			rename_keys.append(('stem_bn/moving_variance:0', 'embeddings.batchnorm.running_var')			)

			for b in block_names:
						_snake_case          =      block_name_mapping[b]
						rename_keys.append((f'''block{b}_expand_conv/kernel:0''', f'''encoder.blocks.{hf_b}.expansion.expand_conv.weight''')			)
						rename_keys.append((f'''block{b}_expand_bn/gamma:0''', f'''encoder.blocks.{hf_b}.expansion.expand_bn.weight''')			)
						rename_keys.append((f'''block{b}_expand_bn/beta:0''', f'''encoder.blocks.{hf_b}.expansion.expand_bn.bias''')			)
						rename_keys.append(
						    (f'''block{b}_expand_bn/moving_mean:0''', f'''encoder.blocks.{hf_b}.expansion.expand_bn.running_mean''')			)
						rename_keys.append(
						    (f'''block{b}_expand_bn/moving_variance:0''', f'''encoder.blocks.{hf_b}.expansion.expand_bn.running_var''')			)
						rename_keys.append(
						    (f'''block{b}_dwconv/depthwise_kernel:0''', f'''encoder.blocks.{hf_b}.depthwise_conv.depthwise_conv.weight''')			)
						rename_keys.append((f'''block{b}_bn/gamma:0''', f'''encoder.blocks.{hf_b}.depthwise_conv.depthwise_norm.weight''')			)
						rename_keys.append((f'''block{b}_bn/beta:0''', f'''encoder.blocks.{hf_b}.depthwise_conv.depthwise_norm.bias''')			)
						rename_keys.append(
						    (f'''block{b}_bn/moving_mean:0''', f'''encoder.blocks.{hf_b}.depthwise_conv.depthwise_norm.running_mean''')			)
						rename_keys.append(
						    (f'''block{b}_bn/moving_variance:0''', f'''encoder.blocks.{hf_b}.depthwise_conv.depthwise_norm.running_var''')			)

						rename_keys.append((f'''block{b}_se_reduce/kernel:0''', f'''encoder.blocks.{hf_b}.squeeze_excite.reduce.weight''')			)
						rename_keys.append((f'''block{b}_se_reduce/bias:0''', f'''encoder.blocks.{hf_b}.squeeze_excite.reduce.bias''')			)
						rename_keys.append((f'''block{b}_se_expand/kernel:0''', f'''encoder.blocks.{hf_b}.squeeze_excite.expand.weight''')			)
						rename_keys.append((f'''block{b}_se_expand/bias:0''', f'''encoder.blocks.{hf_b}.squeeze_excite.expand.bias''')			)
						rename_keys.append(
						    (f'''block{b}_project_conv/kernel:0''', f'''encoder.blocks.{hf_b}.projection.project_conv.weight''')			)
						rename_keys.append((f'''block{b}_project_bn/gamma:0''', f'''encoder.blocks.{hf_b}.projection.project_bn.weight''')			)
						rename_keys.append((f'''block{b}_project_bn/beta:0''', f'''encoder.blocks.{hf_b}.projection.project_bn.bias''')			)
						rename_keys.append(
						    (f'''block{b}_project_bn/moving_mean:0''', f'''encoder.blocks.{hf_b}.projection.project_bn.running_mean''')			)
						rename_keys.append(
						    (f'''block{b}_project_bn/moving_variance:0''', f'''encoder.blocks.{hf_b}.projection.project_bn.running_var''')			)

			rename_keys.append(('top_conv/kernel:0', 'encoder.top_conv.weight')			)
			rename_keys.append(('top_bn/gamma:0', 'encoder.top_bn.weight')			)
			rename_keys.append(('top_bn/beta:0', 'encoder.top_bn.bias')			)
			rename_keys.append(('top_bn/moving_mean:0', 'encoder.top_bn.running_mean')			)
			rename_keys.append(('top_bn/moving_variance:0', 'encoder.top_bn.running_var')			)

			_snake_case          =      {}
			for item in rename_keys:
						if item[0] in original_param_names:
									_snake_case          =      'efficientnet.' + item[1]

			_snake_case          =      'classifier.weight'
			_snake_case          =      'classifier.bias'
			return key_mapping






def 	a_		(	__lowercase       :     Any	, __lowercase       :     Any	, __lowercase       :     Any			)			->  Optional[Any]:
			for key, value in tf_params.items():
						if "normalization" in key:
									continue

						_snake_case          =      key_mapping[key]
						if "_conv" in key and "kernel" in key:
									_snake_case          =      torch.from_numpy(__lowercase			).permute(3	, 2	, 0	, 1			)
						elif "depthwise_kernel" in key:
									_snake_case          =      torch.from_numpy(__lowercase			).permute(2	, 3	, 0	, 1			)
						elif "kernel" in key:
									_snake_case          =      torch.from_numpy(np.transpose(__lowercase			)			)
						else:
									_snake_case          =      torch.from_numpy(__lowercase			)

						# Replace HF parameters with original TF model parameters
						assert hf_params[hf_key].shape == new_hf_value.shape
						hf_params[hf_key].copy_(__lowercase			)






@torch.no_grad()
def 	a_		(	__lowercase       :     List[Any]	, __lowercase       :     Any	, __lowercase       :     int	, __lowercase       :     str			)			->  Dict:
			_snake_case          =      model_classes[model_name](
			    include_top=__lowercase	, weights='imagenet'	, input_tensor=__lowercase	, input_shape=__lowercase	, pooling=__lowercase	, classes=1_000	, classifier_activation='softmax'	, )

			_snake_case          =      original_model.trainable_variables
			_snake_case          =      original_model.non_trainable_variables
			_snake_case          =      {param.name: param.numpy() for param in tf_params}
			for param in tf_non_train_params:
						_snake_case          =      param.numpy()
			_snake_case          =      list(tf_params.keys()			)

			# Load HuggingFace model
			_snake_case          =      get_efficientnet_config(__lowercase			)
			_snake_case          =      EfficientNetForImageClassification(__lowercase			).eval()
			_snake_case          =      hf_model.state_dict()

			# Create src-to-dst parameter name mapping dictionary
			print('Converting parameters...'			)
			_snake_case          =      rename_keys(__lowercase			)
			replace_params(__lowercase	, __lowercase	, __lowercase			)

			# Initialize preprocessor and preprocess input image
			_snake_case          =      convert_image_processor(__lowercase			)
			_snake_case          =      preprocessor(images=prepare_img()	, return_tensors='pt'			)

			# HF model inference
			hf_model.eval()
			with torch.no_grad():
						_snake_case          =      hf_model(**__lowercase			)
			_snake_case          =      outputs.logits.detach().numpy()

			# Original model inference
			_snake_case          =      False
			_snake_case          =      CONFIG_MAP[model_name]['image_size']
			_snake_case          =      prepare_img().resize((image_size, image_size)	, resample=PIL.Image.NEAREST			)
			_snake_case          =      image.img_to_array(__lowercase			)
			_snake_case          =      np.expand_dims(__lowercase	, axis=0			)
			_snake_case          =      original_model.predict(__lowercase			)

			# Check whether original and HF model outputs match  -> np.allclose
			assert np.allclose(__lowercase	, __lowercase	, atol=1E-3			), "The predicted logits are not the same."
			print('Model outputs match!'			)

			if save_model:
						# Create folder to save model
						if not os.path.isdir(__lowercase			):
									os.mkdir(__lowercase			)
						# Save converted model and image processor
						hf_model.save_pretrained(__lowercase			)
						preprocessor.save_pretrained(__lowercase			)

			if push_to_hub:
						# Push model and image processor to hub
						print(f'''Pushing converted {model_name} to the hub...'''			)
						_snake_case          =      f'''efficientnet-{model_name}'''
						preprocessor.push_to_hub(__lowercase			)
						hf_model.push_to_hub(__lowercase			)


if __name__ == "__main__":
			_lowerCamelCase	:    int          =      argparse.ArgumentParser()
			# Required parameters
			parser.add_argument(
			    '''--model_name''',
			    default='''b0''',
			    type=str,
			    help='''Version name of the EfficientNet model you want to convert, select from [b0, b1, b2, b3, b4, b5, b6, b7].''',
			)
			parser.add_argument(
			    '''--pytorch_dump_folder_path''',
			    default='''hf_model''',
			    type=str,
			    help='''Path to the output PyTorch model directory.''',
			)
			parser.add_argument('''--save_model''', action='''store_true''', help='''Save model to local''')
			parser.add_argument('''--push_to_hub''', action='''store_true''', help='''Push model and image processor to the hub''')

			_lowerCamelCase	:    List[str]          =      parser.parse_args()
			convert_efficientnet_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.save_model, args.push_to_hub)