






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()
lowercase						:      Optional[int]									= logging.get_logger(__name__)

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

lowercase						:      Union[str, Any]									= {
    'b0': {
        'hidden_dim': 1280,
        'width_coef': 1.0,
        'depth_coef': 1.0,
        'image_size': 224,
        'dropout_rate': 0.2,
        'dw_padding': [],
    },
    'b1': {
        'hidden_dim': 1280,
        'width_coef': 1.0,
        'depth_coef': 1.1,
        'image_size': 240,
        'dropout_rate': 0.2,
        'dw_padding': [16],
    },
    'b2': {
        'hidden_dim': 1408,
        'width_coef': 1.1,
        'depth_coef': 1.2,
        'image_size': 260,
        'dropout_rate': 0.3,
        'dw_padding': [5, 8, 16],
    },
    'b3': {
        'hidden_dim': 1536,
        'width_coef': 1.2,
        'depth_coef': 1.4,
        'image_size': 300,
        'dropout_rate': 0.3,
        'dw_padding': [5, 18],
    },
    'b4': {
        'hidden_dim': 1792,
        'width_coef': 1.4,
        'depth_coef': 1.8,
        'image_size': 380,
        'dropout_rate': 0.4,
        'dw_padding': [6],
    },
    'b5': {
        'hidden_dim': 2048,
        'width_coef': 1.6,
        'depth_coef': 2.2,
        'image_size': 456,
        'dropout_rate': 0.4,
        'dw_padding': [13, 27],
    },
    'b6': {
        'hidden_dim': 2304,
        'width_coef': 1.8,
        'depth_coef': 2.6,
        'image_size': 528,
        'dropout_rate': 0.5,
        'dw_padding': [31],
    },
    'b7': {
        'hidden_dim': 2560,
        'width_coef': 2.0,
        'depth_coef': 3.1,
        'image_size': 600,
        'dropout_rate': 0.5,
        'dw_padding': [18],
    },
}




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






							'''simple docstring'''





							__UpperCamelCase			:     Tuple         =      EfficientNetConfig()
							__UpperCamelCase			:     Union[str, Any]         =      CONFIG_MAP[model_name]["hidden_dim"]
							__UpperCamelCase			:     Tuple         =      CONFIG_MAP[model_name]["width_coef"]
							__UpperCamelCase			:     Dict         =      CONFIG_MAP[model_name]["depth_coef"]
							__UpperCamelCase			:     List[Any]         =      CONFIG_MAP[model_name]["image_size"]
							__UpperCamelCase			:     Dict         =      CONFIG_MAP[model_name]["dropout_rate"]
							__UpperCamelCase			:     List[str]         =      CONFIG_MAP[model_name]["dw_padding"]

							__UpperCamelCase			:     Union[str, Any]         =      "huggingface/label-files"
							__UpperCamelCase			:     str         =      "imagenet-1k-id2label.json"
							__UpperCamelCase			:     List[str]         =      1_000
							__UpperCamelCase			:     int         =      json.load(open(hf_hub_download(_lowerCamelCase		,						_lowerCamelCase		,						repo_type="dataset")		,						"r"))
							__UpperCamelCase			:     int         =      {int(_lowerCamelCase): v for k, v in idalabel.items()}

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




def 			_SCREAMING_SNAKE_CASE      (	)      ->					str:






							'''simple docstring'''





							__UpperCamelCase			:     Any         =      "http://images.cocodataset.org/val2017/000000039769.jpg"
							__UpperCamelCase			:     Optional[Any]         =      Image.open(requests.get(_lowerCamelCase		,						stream=_lowerCamelCase).raw)
							return im




def 			_SCREAMING_SNAKE_CASE      (	_lowerCamelCase				:    Any)      ->					Optional[Any]:






							'''simple docstring'''





							__UpperCamelCase			:     Tuple         =      CONFIG_MAP[model_name]["image_size"]
							__UpperCamelCase			:     Union[str, Any]         =      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=_lowerCamelCase		,						)
							return preprocessor




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






							'''simple docstring'''





							__UpperCamelCase			:     Optional[Any]         =      [v.split("_")[0].split("block")[1] for v in original_param_names if v.startswith("block")]
							__UpperCamelCase			:     List[str]         =      sorted(set(_lowerCamelCase))
							__UpperCamelCase			:     Optional[Any]         =      len(_lowerCamelCase)
							__UpperCamelCase			:     Dict         =      {b: str(_lowerCamelCase) for b, i in zip(_lowerCamelCase		,						range(_lowerCamelCase))}

							__UpperCamelCase			:     List[Any]         =      []
							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:
														__UpperCamelCase			:     Union[str, Any]         =      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"))

							__UpperCamelCase			:     Optional[int]         =      {}
							for item in rename_keys:
														if item[0] in original_param_names:
																					__UpperCamelCase			:     Any         =      "efficientnet." + item[1]

							__UpperCamelCase			:     Union[str, Any]         =      "classifier.weight"
							__UpperCamelCase			:     int         =      "classifier.bias"
							return key_mapping




def 			_SCREAMING_SNAKE_CASE      (	_lowerCamelCase				:    str		,						_lowerCamelCase				:    List[str]		,						_lowerCamelCase				:    Optional[Any])      ->					Optional[Any]:






							'''simple docstring'''





							for key, value in tf_params.items():
														if "normalization" in key:
																					continue

														__UpperCamelCase			:     Tuple         =      key_mapping[key]
														if "_conv" in key and "kernel" in key:
																					__UpperCamelCase			:     Dict         =      torch.from_numpy(_lowerCamelCase).permute(3		,						2		,						0		,						1)
														elif "depthwise_kernel" in key:
																					__UpperCamelCase			:     List[Any]         =      torch.from_numpy(_lowerCamelCase).permute(2		,						3		,						0		,						1)
														elif "kernel" in key:
																					__UpperCamelCase			:     Tuple         =      torch.from_numpy(np.transpose(_lowerCamelCase))
														else:
																					__UpperCamelCase			:     str         =      torch.from_numpy(_lowerCamelCase)

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




@torch.no_grad()
def 			_SCREAMING_SNAKE_CASE      (	_lowerCamelCase				:    Optional[Any]		,						_lowerCamelCase				:    Tuple		,						_lowerCamelCase				:    Any		,						_lowerCamelCase				:    Tuple)      ->					List[str]:






							'''simple docstring'''





							__UpperCamelCase			:     str         =      model_classes[model_name](
							    include_top=_lowerCamelCase		,						weights="imagenet"		,						input_tensor=_lowerCamelCase		,						input_shape=_lowerCamelCase		,						pooling=_lowerCamelCase		,						classes=1_000		,						classifier_activation="softmax"		,						)

							__UpperCamelCase			:     Dict         =      original_model.trainable_variables
							__UpperCamelCase			:     Tuple         =      original_model.non_trainable_variables
							__UpperCamelCase			:     Tuple         =      {param.name: param.numpy() for param in tf_params}
							for param in tf_non_train_params:
														__UpperCamelCase			:     str         =      param.numpy()
							__UpperCamelCase			:     str         =      list(tf_params.keys())

							# Load HuggingFace model
							__UpperCamelCase			:     List[Any]         =      get_efficientnet_config(_lowerCamelCase)
							__UpperCamelCase			:     Optional[int]         =      EfficientNetForImageClassification(_lowerCamelCase).eval()
							__UpperCamelCase			:     List[str]         =      hf_model.state_dict()

							# Create src-to-dst parameter name mapping dictionary
							print("Converting parameters...")
							__UpperCamelCase			:     List[str]         =      rename_keys(_lowerCamelCase)
							replace_params(_lowerCamelCase		,						_lowerCamelCase		,						_lowerCamelCase)

							# Initialize preprocessor and preprocess input image
							__UpperCamelCase			:     Dict         =      convert_image_processor(_lowerCamelCase)
							__UpperCamelCase			:     List[Any]         =      preprocessor(images=prepare_img()		,						return_tensors="pt")

							# HF model inference
							hf_model.eval()
							with torch.no_grad():
														__UpperCamelCase			:     Dict         =      hf_model(**_lowerCamelCase)
							__UpperCamelCase			:     Tuple         =      outputs.logits.detach().numpy()

							# Original model inference
							__UpperCamelCase			:     Any         =      False
							__UpperCamelCase			:     List[str]         =      CONFIG_MAP[model_name]["image_size"]
							__UpperCamelCase			:     Tuple         =      prepare_img().resize((image_size, image_size)		,						resample=PIL.Image.NEAREST)
							__UpperCamelCase			:     List[Any]         =      image.img_to_array(_lowerCamelCase)
							__UpperCamelCase			:     Optional[Any]         =      np.expand_dims(_lowerCamelCase		,						axis=0)
							__UpperCamelCase			:     str         =      original_model.predict(_lowerCamelCase)

							# Check whether original and HF model outputs match  -> np.allclose
							assert np.allclose(_lowerCamelCase		,						_lowerCamelCase		,						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(_lowerCamelCase):
																					os.mkdir(_lowerCamelCase)
														# Save converted model and image processor
														hf_model.save_pretrained(_lowerCamelCase)
														preprocessor.save_pretrained(_lowerCamelCase)

							if push_to_hub:
														# Push model and image processor to hub
														print(F'Pushing converted {model_name} to the hub...')
														__UpperCamelCase			:     Any         =      F'efficientnet-{model_name}'
														preprocessor.push_to_hub(_lowerCamelCase)
														hf_model.push_to_hub(_lowerCamelCase)


if __name__ == "__main__":
		lowercase						:      Optional[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')

		lowercase						:      Union[str, Any]									= parser.parse_args()
		convert_efficientnet_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.save_model, args.push_to_hub)

import re
import string

import numpy as np

import datasets


lowercase						:      List[str]									= '\nReturns the rate at which the input predicted strings exactly match their references, ignoring any strings input as part of the regexes_to_ignore list.\n'

lowercase						:      List[str]									= '\nArgs:\n    predictions: List of predicted texts.\n    references: List of reference texts.\n    regexes_to_ignore: List, defaults to None. Regex expressions of characters to\n        ignore when calculating the exact matches. Note: these regexes are removed\n        from the input data before the changes based on the options below (e.g. ignore_case,\n        ignore_punctuation, ignore_numbers) are applied.\n    ignore_case: Boolean, defaults to False. If true, turns everything\n        to lowercase so that capitalization differences are ignored.\n    ignore_punctuation: Boolean, defaults to False. If true, removes all punctuation before\n        comparing predictions and references.\n    ignore_numbers: Boolean, defaults to False. If true, removes all punctuation before\n        comparing predictions and references.\nReturns:\n    exact_match: Dictionary containing exact_match rate. Possible values are between 0.0 and 100.0, inclusive.\nExamples:\n    >>> exact_match = datasets.load_metric("exact_match")\n    >>> refs = ["the cat", "theater", "YELLING", "agent007"]\n    >>> preds = ["cat?", "theater", "yelling", "agent"]\n    >>> results = exact_match.compute(references=refs, predictions=preds)\n    >>> print(round(results["exact_match"], 1))\n    25.0\n\n    >>> exact_match = datasets.load_metric("exact_match")\n    >>> refs = ["the cat", "theater", "YELLING", "agent007"]\n    >>> preds = ["cat?", "theater", "yelling", "agent"]\n    >>> results = exact_match.compute(references=refs, predictions=preds, regexes_to_ignore=["the ", "yell"], ignore_case=True, ignore_punctuation=True)\n    >>> print(round(results["exact_match"], 1))\n    50.0\n\n\n    >>> exact_match = datasets.load_metric("exact_match")\n    >>> refs = ["the cat", "theater", "YELLING", "agent007"]\n    >>> preds = ["cat?", "theater", "yelling", "agent"]\n    >>> results = exact_match.compute(references=refs, predictions=preds, regexes_to_ignore=["the ", "yell", "YELL"], ignore_case=True, ignore_punctuation=True)\n    >>> print(round(results["exact_match"], 1))\n    75.0\n\n    >>> exact_match = datasets.load_metric("exact_match")\n    >>> refs = ["the cat", "theater", "YELLING", "agent007"]\n    >>> preds = ["cat?", "theater", "yelling", "agent"]\n    >>> results = exact_match.compute(references=refs, predictions=preds, regexes_to_ignore=["the ", "yell", "YELL"], ignore_case=True, ignore_punctuation=True, ignore_numbers=True)\n    >>> print(round(results["exact_match"], 1))\n    100.0\n\n    >>> exact_match = datasets.load_metric("exact_match")\n    >>> refs = ["The cat sat on the mat.", "Theaters are great.", "It\'s like comparing oranges and apples."]\n    >>> preds = ["The cat sat on the mat?", "Theaters are great.", "It\'s like comparing apples and oranges."]\n    >>> results = exact_match.compute(references=refs, predictions=preds)\n    >>> print(round(results["exact_match"], 1))\n    33.3\n\n'

lowercase						:      List[str]									= '\n'




@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION  ,		_KWARGS_DESCRIPTION)
class 				lowerCamelCase__							(       datasets.Metric):




	'''simple docstring'''




	def      _lowerCamelCase       (      self	:Dict		)	->				Optional[Any]:
								return datasets.MetricInfo(
								    description=_DESCRIPTION  ,     citation=_CITATION  ,     inputs_description=_KWARGS_DESCRIPTION  ,     features=datasets.Features(
								        {
								            "predictions": datasets.Value("string"  ,     id="sequence"		),
								            "references": datasets.Value("string"  ,     id="sequence"		),
								        }		)  ,     reference_urls=[]  ,     )







	def      _lowerCamelCase       (      self	:int  ,     a	:Optional[Any]  ,     a	:Dict  ,     a	:Optional[int]=None  ,     a	:int=False  ,     a	:Tuple=False  ,     a	:Optional[int]=False  ,     )	->				Any:
								if regexes_to_ignore is not None:
															for s in regexes_to_ignore:
																						__UpperCamelCase			:     List[Any]         =      np.array([re.sub(a  ,     ""  ,     a		) for x in predictions]		)
																						__UpperCamelCase			:     Optional[Any]         =      np.array([re.sub(a  ,     ""  ,     a		) for x in references]		)
								else:
															__UpperCamelCase			:     Optional[int]         =      np.asarray(a		)
															__UpperCamelCase			:     List[str]         =      np.asarray(a		)

								if ignore_case:
															__UpperCamelCase			:     Optional[int]         =      np.char.lower(a		)
															__UpperCamelCase			:     str         =      np.char.lower(a		)

								if ignore_punctuation:
															__UpperCamelCase			:     Tuple         =      string.punctuation.maketrans(""  ,     ""  ,     string.punctuation		)
															__UpperCamelCase			:     int         =      np.char.translate(a  ,     table=a		)
															__UpperCamelCase			:     str         =      np.char.translate(a  ,     table=a		)

								if ignore_numbers:
															__UpperCamelCase			:     List[str]         =      string.digits.maketrans(""  ,     ""  ,     string.digits		)
															__UpperCamelCase			:     Tuple         =      np.char.translate(a  ,     table=a		)
															__UpperCamelCase			:     Union[str, Any]         =      np.char.translate(a  ,     table=a		)

								__UpperCamelCase			:     List[Any]         =      predictions == references

								return {"exact_match": np.mean(a		) * 1_0_0}