






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

lowerCamelCase     :							List[str]    ={
    '''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     :							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      )			->     Union[str, Any]:
     UpperCamelCase__      :       Tuple	    =  EfficientNetConfig()
     UpperCamelCase__      :       int	    =  CONFIG_MAP[model_name]["hidden_dim"]
     UpperCamelCase__      :       Dict	    =  CONFIG_MAP[model_name]["width_coef"]
     UpperCamelCase__      :       List[str]	    =  CONFIG_MAP[model_name]["depth_coef"]
     UpperCamelCase__      :       Dict	    =  CONFIG_MAP[model_name]["image_size"]
     UpperCamelCase__      :       Any	    =  CONFIG_MAP[model_name]["dropout_rate"]
     UpperCamelCase__      :       Any	    =  CONFIG_MAP[model_name]["dw_padding"]

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

     UpperCamelCase__      :       Dict	    =  idalabel
     UpperCamelCase__      :       Union[str, Any]	    =  {v: k for k, v in idalabel.items()}
     return config







def 		SCREAMING_SNAKE_CASE							( )			->     List[str]:
     UpperCamelCase__      :       Any	    =  "http://images.cocodataset.org/val2017/000000039769.jpg"
     UpperCamelCase__      :       Any	    =  Image.open(requests.get(__lowerCAmelCase ,   stream=__lowerCAmelCase      ).raw      )
     return im







def 		SCREAMING_SNAKE_CASE							( __lowerCAmelCase      )			->     Optional[Any]:
     UpperCamelCase__      :       Any	    =  CONFIG_MAP[model_name]["image_size"]
     UpperCamelCase__      :       List[str]	    =  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      )			->     List[str]:
     UpperCamelCase__      :       Union[str, Any]	    =  [v.split("_"      )[0].split("block"      )[1] for v in original_param_names if v.startswith("block"      )]
     UpperCamelCase__      :       Optional[int]	    =  sorted(set(__lowerCAmelCase      )      )
     UpperCamelCase__      :       int	    =  len(__lowerCAmelCase      )
     UpperCamelCase__      :       Tuple	    =  {b: str(__lowerCAmelCase      ) for b, i in zip(__lowerCAmelCase ,   range(__lowerCAmelCase      )      )}

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

     UpperCamelCase__      :       str	    =  "classifier.weight"
     UpperCamelCase__      :       Optional[int]	    =  "classifier.bias"
     return key_mapping







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

          UpperCamelCase__      :       Union[str, Any]	    =  key_mapping[key]
          if "_conv" in key and "kernel" in key:
               UpperCamelCase__      :       str	    =  torch.from_numpy(__lowerCAmelCase      ).permute(3 ,   2 ,   0 ,   1      )
          elif "depthwise_kernel" in key:
               UpperCamelCase__      :       Tuple	    =  torch.from_numpy(__lowerCAmelCase      ).permute(2 ,   3 ,   0 ,   1      )
          elif "kernel" in key:
               UpperCamelCase__      :       Optional[Any]	    =  torch.from_numpy(np.transpose(__lowerCAmelCase      )      )
          else:
               UpperCamelCase__      :       Optional[int]	    =  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 ,   __lowerCAmelCase ,   __lowerCAmelCase ,   __lowerCAmelCase      )			->     int:
     UpperCamelCase__      :       str	    =  model_classes[model_name](
         include_top=__lowerCAmelCase ,   weights="imagenet" ,   input_tensor=__lowerCAmelCase ,   input_shape=__lowerCAmelCase ,   pooling=__lowerCAmelCase ,   classes=1000 ,   classifier_activation="softmax" ,   )

     UpperCamelCase__      :       int	    =  original_model.trainable_variables
     UpperCamelCase__      :       str	    =  original_model.non_trainable_variables
     UpperCamelCase__      :       str	    =  {param.name: param.numpy() for param in tf_params}
     for param in tf_non_train_params:
          UpperCamelCase__      :       Tuple	    =  param.numpy()
     UpperCamelCase__      :       Union[str, Any]	    =  list(tf_params.keys()      )

     # Load HuggingFace model
     UpperCamelCase__      :       Any	    =  get_efficientnet_config(__lowerCAmelCase      )
     UpperCamelCase__      :       int	    =  EfficientNetForImageClassification(__lowerCAmelCase      ).eval()
     UpperCamelCase__      :       Union[str, Any]	    =  hf_model.state_dict()

     # Create src-to-dst parameter name mapping dictionary
     print("Converting parameters..."      )
     UpperCamelCase__      :       Optional[Any]	    =  rename_keys(__lowerCAmelCase      )
     replace_params(__lowerCAmelCase ,   __lowerCAmelCase ,   __lowerCAmelCase      )

     # Initialize preprocessor and preprocess input image
     UpperCamelCase__      :       Optional[Any]	    =  convert_image_processor(__lowerCAmelCase      )
     UpperCamelCase__      :       Union[str, Any]	    =  preprocessor(images=prepare_img() ,   return_tensors="pt"      )

     # HF model inference
     hf_model.eval()
     with torch.no_grad():
          UpperCamelCase__      :       str	    =  hf_model(**__lowerCAmelCase      )
     UpperCamelCase__      :       Dict	    =  outputs.logits.detach().numpy()

     # Original model inference
     UpperCamelCase__      :       Tuple	    =  False
     UpperCamelCase__      :       List[Any]	    =  CONFIG_MAP[model_name]["image_size"]
     UpperCamelCase__      :       int	    =  prepare_img().resize((image_size, image_size) ,   resample=PIL.Image.NEAREST      )
     UpperCamelCase__      :       int	    =  image.img_to_array(__lowerCAmelCase      )
     UpperCamelCase__      :       List[Any]	    =  np.expand_dims(__lowerCAmelCase ,   axis=0      )
     UpperCamelCase__      :       Union[str, Any]	    =  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__      :       Dict	    =  f'efficientnet-{model_name}'
          preprocessor.push_to_hub(__lowerCAmelCase      )
          hf_model.push_to_hub(__lowerCAmelCase      )


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     :							Any    =parser.parse_args()
 convert_efficientnet_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.save_model, args.push_to_hub)







from __future__ import annotations







def 		SCREAMING_SNAKE_CASE							( __lowerCAmelCase ,   __lowerCAmelCase      )			->     list[int]:
     UpperCamelCase__      :       Optional[Any]	    =  0
     UpperCamelCase__      :       Any	    =  len(__lowerCAmelCase      ) - 1

     while i < j:
          if nums[i] + nums[j] == target:
               return [i, j]
          elif nums[i] + nums[j] < target:
               UpperCamelCase__      :       Optional[int]	    =  i + 1
          else:
               UpperCamelCase__      :       Dict	    =  j - 1

     return []


if __name__ == "__main__":
 import doctest

 doctest.testmod()
 print(F"""{two_pointer([2, 7, 11, 15], 9) = }""")