





'''simple docstring'''

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()
a   	=    logging.get_logger(__name__)

a   	=    {
    "b0": efficientnet.EfficientNetBa,
    "b1": efficientnet.EfficientNetBa,
    "b2": efficientnet.EfficientNetBa,
    "b3": efficientnet.EfficientNetBa,
    "b4": efficientnet.EfficientNetBa,
    "b5": efficientnet.EfficientNetBa,
    "b6": efficientnet.EfficientNetBa,
    "b7": efficientnet.EfficientNetBa,
}

a   	=    {
    "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     __magic_name__							(				__UpperCAmelCase   )    ->       Tuple:

   '''simple docstring'''







   __SCREAMING_SNAKE_CASE   				=							EfficientNetConfig()
   __SCREAMING_SNAKE_CASE   				=							CONFIG_MAP[model_name]["""hidden_dim"""]
   __SCREAMING_SNAKE_CASE   				=							CONFIG_MAP[model_name]["""width_coef"""]
   __SCREAMING_SNAKE_CASE   				=							CONFIG_MAP[model_name]["""depth_coef"""]
   __SCREAMING_SNAKE_CASE   				=							CONFIG_MAP[model_name]["""image_size"""]
   __SCREAMING_SNAKE_CASE   				=							CONFIG_MAP[model_name]["""dropout_rate"""]
   __SCREAMING_SNAKE_CASE   				=							CONFIG_MAP[model_name]["""dw_padding"""]

   __SCREAMING_SNAKE_CASE   				=							"""huggingface/label-files"""
   __SCREAMING_SNAKE_CASE   				=							"""imagenet-1k-id2label.json"""
   __SCREAMING_SNAKE_CASE   				=							1000
   __SCREAMING_SNAKE_CASE   				=							json.load(open(hf_hub_download(__UpperCAmelCase				,						__UpperCAmelCase				,						repo_type="""dataset"""   )				,						"""r"""   )   )
   __SCREAMING_SNAKE_CASE   				=							{int(__UpperCAmelCase   ): v for k, v in idalabel.items()}

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

def     __magic_name__							(				)    ->       List[str]:

   '''simple docstring'''







   __SCREAMING_SNAKE_CASE   				=							"""http://images.cocodataset.org/val2017/000000039769.jpg"""
   __SCREAMING_SNAKE_CASE   				=							Image.open(requests.get(__UpperCAmelCase				,						stream=__UpperCAmelCase   ).raw   )
   return im

def     __magic_name__							(				__UpperCAmelCase   )    ->       Tuple:

   '''simple docstring'''







   __SCREAMING_SNAKE_CASE   				=							CONFIG_MAP[model_name]["""image_size"""]
   __SCREAMING_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=__UpperCAmelCase				,						)
   return preprocessor

def     __magic_name__							(				__UpperCAmelCase   )    ->       List[str]:

   '''simple docstring'''







   __SCREAMING_SNAKE_CASE   				=							[v.split("""_"""   )[0].split("""block"""   )[1] for v in original_param_names if v.startswith("""block"""   )]
   __SCREAMING_SNAKE_CASE   				=							sorted(set(__UpperCAmelCase   )   )
   __SCREAMING_SNAKE_CASE   				=							len(__UpperCAmelCase   )
   __SCREAMING_SNAKE_CASE   				=							{b: str(__UpperCAmelCase   ) for b, i in zip(__UpperCAmelCase				,						range(__UpperCAmelCase   )   )}

   __SCREAMING_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:
      __SCREAMING_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""")   )

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

   __SCREAMING_SNAKE_CASE   				=							"""classifier.weight"""
   __SCREAMING_SNAKE_CASE   				=							"""classifier.bias"""
   return key_mapping

def     __magic_name__							(				__UpperCAmelCase				,						__UpperCAmelCase				,						__UpperCAmelCase   )    ->       Tuple:

   '''simple docstring'''







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

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

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

@torch.no_grad()
def     __magic_name__							(				__UpperCAmelCase				,						__UpperCAmelCase				,						__UpperCAmelCase				,						__UpperCAmelCase   )    ->       str:

   '''simple docstring'''







   __SCREAMING_SNAKE_CASE   				=							model_classes[model_name](
       include_top=__UpperCAmelCase				,						weights="""imagenet"""				,						input_tensor=__UpperCAmelCase				,						input_shape=__UpperCAmelCase				,						pooling=__UpperCAmelCase				,						classes=1000				,						classifier_activation="""softmax"""				,						)

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

   # Load HuggingFace model
   __SCREAMING_SNAKE_CASE   				=							get_efficientnet_config(__UpperCAmelCase   )
   __SCREAMING_SNAKE_CASE   				=							EfficientNetForImageClassification(__UpperCAmelCase   ).eval()
   __SCREAMING_SNAKE_CASE   				=							hf_model.state_dict()

   # Create src-to-dst parameter name mapping dictionary
   print("""Converting parameters..."""   )
   __SCREAMING_SNAKE_CASE   				=							rename_keys(__UpperCAmelCase   )
   replace_params(__UpperCAmelCase				,						__UpperCAmelCase				,						__UpperCAmelCase   )

   # Initialize preprocessor and preprocess input image
   __SCREAMING_SNAKE_CASE   				=							convert_image_processor(__UpperCAmelCase   )
   __SCREAMING_SNAKE_CASE   				=							preprocessor(images=prepare_img()				,						return_tensors="""pt"""   )

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

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

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

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


if __name__ == "__main__":
    a   	=    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")

    a   	=    parser.parse_args()
    convert_efficientnet_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.save_model, args.push_to_hub)











from functools import reduce

__a							     =					(
    '73167176531330624919225119674426574742355349194934'
    '96983520312774506326239578318016984801869478851843'
    '85861560789112949495459501737958331952853208805511'
    '12540698747158523863050715693290963295227443043557'
    '66896648950445244523161731856403098711121722383113'
    '62229893423380308135336276614282806444486645238749'
    '30358907296290491560440772390713810515859307960866'
    '70172427121883998797908792274921901699720888093776'
    '65727333001053367881220235421809751254540594752243'
    '52584907711670556013604839586446706324415722155397'
    '53697817977846174064955149290862569321978468622482'
    '83972241375657056057490261407972968652414535100474'
    '82166370484403199890008895243450658541227588666881'
    '16427171479924442928230863465674813919123162824586'
    '17866458359124566529476545682848912883142607690042'
    '24219022671055626321111109370544217506941658960408'
    '07198403850962455444362981230987879927244284909188'
    '84580156166097919133875499200524063689912560717606'
    '05886116467109405077541002256983155200055935729725'
    '71636269561882670428252483600823257530420752963450'
)







def lowerCamelCase__  (     _lowercase = N ):

     '''simple docstring'''


     return max(
         # mypy cannot properly interpret reduce
         int(reduce(lambda _lowercase					,		_lowercase : str(int(_lowercase ) * int(_lowercase ) )					,		n[i : i + 13] ) )
         for i in range(len(_lowercase ) - 12 ) )


if __name__ == "__main__":
     print(F"""{solution() = }""")