


"""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()
lowerCamelCase_       :       Tuple      						=  logging.get_logger(__name__)

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

lowerCamelCase_       :       Optional[int]      						=  {
    """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						(						lowercase		):







    """simple docstring"""
    a					=EfficientNetConfig()
    a					=CONFIG_MAP[model_name]['''hidden_dim''']
    a					=CONFIG_MAP[model_name]['''width_coef''']
    a					=CONFIG_MAP[model_name]['''depth_coef''']
    a					=CONFIG_MAP[model_name]['''image_size''']
    a					=CONFIG_MAP[model_name]['''dropout_rate''']
    a					=CONFIG_MAP[model_name]['''dw_padding''']

    a					='''huggingface/label-files'''
    a					='''imagenet-1k-id2label.json'''
    a					=10_00
    a					=json.load(open(hf_hub_download(lowercase	,   lowercase	,   repo_type='''dataset'''		)	,   '''r'''		)		)
    a					={int(lowercase		): v for k, v in idalabel.items()}

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







    """simple docstring"""
    a					='''http://images.cocodataset.org/val2017/000000039769.jpg'''
    a					=Image.open(requests.get(lowercase	,   stream=lowercase		).raw		)
    return im
def _A						(						lowercase		):







    """simple docstring"""
    a					=CONFIG_MAP[model_name]['''image_size''']
    a					=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=lowercase	,   )
    return preprocessor
def _A						(						lowercase		):







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

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

    a					='''classifier.weight'''
    a					='''classifier.bias'''
    return key_mapping
def _A						(						lowercase	,   lowercase	,   lowercase		):







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

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

        # Replace HF parameters with original TF model parameters
        assert hf_params[hf_key].shape == new_hf_value.shape
        hf_params[hf_key].copy_(lowercase		)
@torch.no_grad()
def _A						(						lowercase	,   lowercase	,   lowercase	,   lowercase		):







    """simple docstring"""
    a					=model_classes[model_name](
        include_top=lowercase	,   weights='''imagenet'''	,   input_tensor=lowercase	,   input_shape=lowercase	,   pooling=lowercase	,   classes=10_00	,   classifier_activation='''softmax'''	,   )

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

    # Load HuggingFace model
    a					=get_efficientnet_config(lowercase		)
    a					=EfficientNetForImageClassification(lowercase		).eval()
    a					=hf_model.state_dict()

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

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

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

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

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

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


if __name__ == "__main__":
       lowerCamelCase_       :       Tuple      						=  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_       :       Optional[Any]      						=  parser.parse_args()
       convert_efficientnet_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.save_model, args.push_to_hub)



"""simple docstring"""







def _A						(						lowercase = 2_00_00_00		):







    """simple docstring"""
    a					=[0 for i in range(n + 1		)]
    a					=1
    a					=1

    for i in range(2	,   int(n**0.5		) + 1		):
        if primality_list[i] == 0:
            for j in range(i * i	,   n + 1	,   lowercase		):
                a					=1
    a					=0
    for i in range(lowercase		):
        if primality_list[i] == 0:
            sum_of_primes += i
    return sum_of_primes


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