
"""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()
UpperCamelCase     :    Optional[Any]       =			logging.get_logger(__name__)

UpperCamelCase     :    Union[str, Any]       =			{
    'b0': efficientnet.EfficientNetBa,
    'b1': efficientnet.EfficientNetBa,
    'b2': efficientnet.EfficientNetBa,
    'b3': efficientnet.EfficientNetBa,
    'b4': efficientnet.EfficientNetBa,
    'b5': efficientnet.EfficientNetBa,
    'b6': efficientnet.EfficientNetBa,
    'b7': efficientnet.EfficientNetBa,
}

UpperCamelCase     :    Union[str, Any]       =			{
    'b0': {
        'hidden_dim': 1_2_8_0,
        'width_coef': 1.0,
        'depth_coef': 1.0,
        'image_size': 2_2_4,
        'dropout_rate': 0.2,
        'dw_padding': [],
    },
    'b1': {
        'hidden_dim': 1_2_8_0,
        'width_coef': 1.0,
        'depth_coef': 1.1,
        'image_size': 2_4_0,
        'dropout_rate': 0.2,
        'dw_padding': [1_6],
    },
    'b2': {
        'hidden_dim': 1_4_0_8,
        'width_coef': 1.1,
        'depth_coef': 1.2,
        'image_size': 2_6_0,
        'dropout_rate': 0.3,
        'dw_padding': [5, 8, 1_6],
    },
    'b3': {
        'hidden_dim': 1_5_3_6,
        'width_coef': 1.2,
        'depth_coef': 1.4,
        'image_size': 3_0_0,
        'dropout_rate': 0.3,
        'dw_padding': [5, 1_8],
    },
    'b4': {
        'hidden_dim': 1_7_9_2,
        'width_coef': 1.4,
        'depth_coef': 1.8,
        'image_size': 3_8_0,
        'dropout_rate': 0.4,
        'dw_padding': [6],
    },
    'b5': {
        'hidden_dim': 2_0_4_8,
        'width_coef': 1.6,
        'depth_coef': 2.2,
        'image_size': 4_5_6,
        'dropout_rate': 0.4,
        'dw_padding': [1_3, 2_7],
    },
    'b6': {
        'hidden_dim': 2_3_0_4,
        'width_coef': 1.8,
        'depth_coef': 2.6,
        'image_size': 5_2_8,
        'dropout_rate': 0.5,
        'dw_padding': [3_1],
    },
    'b7': {
        'hidden_dim': 2_5_6_0,
        'width_coef': 2.0,
        'depth_coef': 3.1,
        'image_size': 6_0_0,
        'dropout_rate': 0.5,
        'dw_padding': [1_8],
    },
}






def 							A						(    snake_case				:Tuple		)				->     Optional[Any]:






 """simple docstring"""




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

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

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






def 							A						(    )				->     List[str]:






 """simple docstring"""




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






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






 """simple docstring"""




 __UpperCamelCase      =	CONFIG_MAP[model_name]["image_size"]
 __UpperCamelCase      =	EfficientNetImageProcessor(
     size={'height': size, 'width': size}    , image_mean=[0.485, 0.456, 0.406]    , image_std=[0.47_853_944, 0.4_732_864, 0.47_434_163]    , do_center_crop=__snake_case    , )
 return preprocessor






def 							A						(    snake_case				:Tuple		)				->     Any:






 """simple docstring"""




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

 __UpperCamelCase      =	[]
 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      =	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      =	{}
 for item in rename_keys:
  if item[0] in original_param_names:
   __UpperCamelCase      =	"efficientnet." + item[1]

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






def 							A						(    snake_case				:List[Any]    , snake_case				:Optional[int]    , snake_case				:List[Any]		)				->     List[Any]:






 """simple docstring"""




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

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

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






@torch.no_grad()
def 							A						(    snake_case				:int    , snake_case				:str    , snake_case				:int    , snake_case				:Any		)				->     str:






 """simple docstring"""




 __UpperCamelCase      =	model_classes[model_name](
     include_top=__snake_case    , weights='imagenet'    , input_tensor=__snake_case    , input_shape=__snake_case    , pooling=__snake_case    , classes=1_0_0_0    , classifier_activation='softmax'    , )

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

 # Load HuggingFace model
 __UpperCamelCase      =	get_efficientnet_config(__snake_case		)
 __UpperCamelCase      =	EfficientNetForImageClassification(__snake_case		).eval()
 __UpperCamelCase      =	hf_model.state_dict()

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

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

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

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

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

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


if __name__ == "__main__":
      UpperCamelCase     :    Optional[Any]       =			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")

      UpperCamelCase     :    Any       =			parser.parse_args()
      convert_efficientnet_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.save_model, args.push_to_hub)





"""simple docstring"""

from __future__ import annotations

from typing import Any






def 							A						(    snake_case				:list		)				->     int:
 if not postfix_notation:
  return 0

 __UpperCamelCase      =	{'+', '-', '*', '/'}
 __UpperCamelCase      =	[]

 for token in postfix_notation:
  if token in operations:
   __UpperCamelCase  ,     __UpperCamelCase      =	stack.pop(), stack.pop()
   if token == "+":
    stack.append(a + b		)
   elif token == "-":
    stack.append(a - b		)
   elif token == "*":
    stack.append(a * b		)
   else:
    if a * b < 0 and a % b != 0:
     stack.append(a // b + 1		)
    else:
     stack.append(a // b		)
  else:
   stack.append(int(snake_case		)		)

 return stack.pop()


if __name__ == "__main__":
      import doctest

      doctest.testmod()



