


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()
snake_case				:    List[str]       				=     logging.get_logger(__name__)

snake_case				:    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,
}

snake_case				:    Optional[Any]       				=     {
    '''b0''': {
        '''hidden_dim''': 12_80,
        '''width_coef''': 1.0,
        '''depth_coef''': 1.0,
        '''image_size''': 2_24,
        '''dropout_rate''': 0.2,
        '''dw_padding''': [],
    },
    '''b1''': {
        '''hidden_dim''': 12_80,
        '''width_coef''': 1.0,
        '''depth_coef''': 1.1,
        '''image_size''': 2_40,
        '''dropout_rate''': 0.2,
        '''dw_padding''': [16],
    },
    '''b2''': {
        '''hidden_dim''': 14_08,
        '''width_coef''': 1.1,
        '''depth_coef''': 1.2,
        '''image_size''': 2_60,
        '''dropout_rate''': 0.3,
        '''dw_padding''': [5, 8, 16],
    },
    '''b3''': {
        '''hidden_dim''': 15_36,
        '''width_coef''': 1.2,
        '''depth_coef''': 1.4,
        '''image_size''': 3_00,
        '''dropout_rate''': 0.3,
        '''dw_padding''': [5, 18],
    },
    '''b4''': {
        '''hidden_dim''': 17_92,
        '''width_coef''': 1.4,
        '''depth_coef''': 1.8,
        '''image_size''': 3_80,
        '''dropout_rate''': 0.4,
        '''dw_padding''': [6],
    },
    '''b5''': {
        '''hidden_dim''': 20_48,
        '''width_coef''': 1.6,
        '''depth_coef''': 2.2,
        '''image_size''': 4_56,
        '''dropout_rate''': 0.4,
        '''dw_padding''': [13, 27],
    },
    '''b6''': {
        '''hidden_dim''': 23_04,
        '''width_coef''': 1.8,
        '''depth_coef''': 2.6,
        '''image_size''': 5_28,
        '''dropout_rate''': 0.5,
        '''dw_padding''': [31],
    },
    '''b7''': {
        '''hidden_dim''': 25_60,
        '''width_coef''': 2.0,
        '''depth_coef''': 3.1,
        '''image_size''': 6_00,
        '''dropout_rate''': 0.5,
        '''dw_padding''': [18],
    },
}
def 				__lowerCamelCase						( UpperCAmelCase_						:		Tuple						):




      """simple docstring"""





      a						:Union[str, Any] 							=       EfficientNetConfig()
      a						:Tuple 							=       CONFIG_MAP[model_name]['''hidden_dim''']
      a						:Dict 							=       CONFIG_MAP[model_name]['''width_coef''']
      a						:Dict 							=       CONFIG_MAP[model_name]['''depth_coef''']
      a						:Dict 							=       CONFIG_MAP[model_name]['''image_size''']
      a						:int 							=       CONFIG_MAP[model_name]['''dropout_rate''']
      a						:str 							=       CONFIG_MAP[model_name]['''dw_padding''']

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

      a						:Optional[Any] 							=       idalabel
      a						:Dict 							=       {v: k for k, v in idalabel.items()}
      return config
def 				__lowerCamelCase						( ):




      """simple docstring"""





      a						:int 							=       '''http://images.cocodataset.org/val2017/000000039769.jpg'''
      a						:Dict 							=       Image.open(requests.get(__lowerCamelCase ,  stream=__lowerCamelCase						).raw						)
      return im
def 				__lowerCamelCase						( UpperCAmelCase_						:		Tuple						):




      """simple docstring"""





      a						:Tuple 							=       CONFIG_MAP[model_name]['''image_size''']
      a						:Dict 							=       EfficientNetImageProcessor(
          size={'''height''': size, '''width''': size} ,  image_mean=[0.485, 0.456, 0.406] ,  image_std=[0.47853944, 0.4732864, 0.47434163] ,  do_center_crop=__lowerCamelCase ,  )
      return preprocessor
def 				__lowerCamelCase						( UpperCAmelCase_						:		Optional[int]						):




      """simple docstring"""





      a						:str 							=       [v.split('''_'''						)[0].split('''block'''						)[1] for v in original_param_names if v.startswith('''block'''						)]
      a						:Tuple 							=       sorted(set(__lowerCamelCase						)						)
      a						:Optional[int] 							=       len(__lowerCamelCase						)
      a						:Any 							=       {b: str(__lowerCamelCase						) for b, i in zip(__lowerCamelCase ,  range(__lowerCamelCase						)						)}

      a						:str 							=       []
      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:
            a						:Optional[int] 							=       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''')						)

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

      a						:int 							=       '''classifier.weight'''
      a						:List[Any] 							=       '''classifier.bias'''
      return key_mapping
def 				__lowerCamelCase						( UpperCAmelCase_						:		str ,  UpperCAmelCase_						:		List[str] ,  UpperCAmelCase_						:		List[str]						):




      """simple docstring"""





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

            a						:Dict 							=       key_mapping[key]
            if "_conv" in key and "kernel" in key:
                  a						:Any 							=       torch.from_numpy(__lowerCamelCase						).permute(3 ,  2 ,  0 ,  1						)
            elif "depthwise_kernel" in key:
                  a						:Union[str, Any] 							=       torch.from_numpy(__lowerCamelCase						).permute(2 ,  3 ,  0 ,  1						)
            elif "kernel" in key:
                  a						:Union[str, Any] 							=       torch.from_numpy(np.transpose(__lowerCamelCase						)						)
            else:
                  a						:Dict 							=       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 				__lowerCamelCase						( UpperCAmelCase_						:		Tuple ,  UpperCAmelCase_						:		List[Any] ,  UpperCAmelCase_						:		Dict ,  UpperCAmelCase_						:		List[Any]						):




      """simple docstring"""





      a						:Optional[Any] 							=       model_classes[model_name](
          include_top=__lowerCamelCase ,  weights='''imagenet''' ,  input_tensor=__lowerCamelCase ,  input_shape=__lowerCamelCase ,  pooling=__lowerCamelCase ,  classes=1000 ,  classifier_activation='''softmax''' ,  )

      a						:str 							=       original_model.trainable_variables
      a						:Dict 							=       original_model.non_trainable_variables
      a						:Optional[int] 							=       {param.name: param.numpy() for param in tf_params}
      for param in tf_non_train_params:
            a						:List[str] 							=       param.numpy()
      a						:List[str] 							=       list(tf_params.keys()						)

      # Load HuggingFace model
      a						:Optional[int] 							=       get_efficientnet_config(__lowerCamelCase						)
      a						:int 							=       EfficientNetForImageClassification(__lowerCamelCase						).eval()
      a						:Optional[Any] 							=       hf_model.state_dict()

      # Create src-to-dst parameter name mapping dictionary
      print('''Converting parameters...'''						)
      a						:List[Any] 							=       rename_keys(__lowerCamelCase						)
      replace_params(__lowerCamelCase ,  __lowerCamelCase ,  __lowerCamelCase						)

      # Initialize preprocessor and preprocess input image
      a						:Optional[Any] 							=       convert_image_processor(__lowerCamelCase						)
      a						:Union[str, Any] 							=       preprocessor(images=prepare_img() ,  return_tensors='''pt'''						)

      # HF model inference
      hf_model.eval()
      with torch.no_grad():
            a						:Union[str, Any] 							=       hf_model(**__lowerCamelCase						)
      a						:Tuple 							=       outputs.logits.detach().numpy()

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


if __name__ == "__main__":
     snake_case				:    Union[str, 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''')

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












'''simple docstring'''

import argparse
import logging
import pickle
from collections import Counter


logging.basicConfig(
    format="""%(asctime)s - %(levelname)s - %(name)s - %(message)s""", datefmt="""%m/%d/%Y %H:%M:%S""", level=logging.INFO
)
lowercase_					= logging.getLogger(__name__)

if __name__ == "__main__":
      lowercase_					= argparse.ArgumentParser(
          description="""Token Counts for smoothing the masking probabilities in MLM (cf XLM/word2vec)"""
      )
      parser.add_argument(
          """--data_file""", type=str, default="""data/dump.bert-base-uncased.pickle""", help="""The binarized dataset."""
      )
      parser.add_argument(
          """--token_counts_dump""", type=str, default="""data/token_counts.bert-base-uncased.pickle""", help="""The dump file."""
      )
      parser.add_argument("""--vocab_size""", default=30_522, type=int)
      lowercase_					= parser.parse_args()

      logger.info(f"""Loading data from {args.data_file}""")
      with open(args.data_file, """rb""") as fp:
            lowercase_					= pickle.load(fp)

      logger.info("""Counting occurrences for MLM.""")
      lowercase_					= Counter()
      for tk_ids in data:
            counter.update(tk_ids)
      lowercase_					= [0] * args.vocab_size
      for k, v in counter.items():
            lowercase_					= v

      logger.info(f"""Dump to {args.token_counts_dump}""")
      with open(args.token_counts_dump, """wb""") as handle:
            pickle.dump(counts, handle, protocol=pickle.HIGHEST_PROTOCOL)



