


"""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()
__snake_case :    Optional[Any]             =   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 :    Union[str, 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   __lowerCAmelCase						(						lowercase  :  List[Any]			)     ->						Optional[Any]:


    """simple docstring"""





    snake_case   :				Optional[Any]				 =   EfficientNetConfig()
    snake_case   :				Tuple				 =   CONFIG_MAP[model_name]["hidden_dim"]
    snake_case   :				int				 =   CONFIG_MAP[model_name]["width_coef"]
    snake_case   :				List[Any]				 =   CONFIG_MAP[model_name]["depth_coef"]
    snake_case   :				List[str]				 =   CONFIG_MAP[model_name]["image_size"]
    snake_case   :				Dict				 =   CONFIG_MAP[model_name]["dropout_rate"]
    snake_case   :				List[str]				 =   CONFIG_MAP[model_name]["dw_padding"]

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

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







def   __lowerCAmelCase						(						)     ->						List[str]:


    """simple docstring"""





    snake_case   :				int				 =   "http://images.cocodataset.org/val2017/000000039769.jpg"
    snake_case   :				List[Any]				 =   Image.open(requests.get(__snake_case						,							stream=__snake_case			).raw			)
    return im







def   __lowerCAmelCase						(						lowercase  :  Optional[int]			)     ->						str:


    """simple docstring"""





    snake_case   :				Any				 =   CONFIG_MAP[model_name]["image_size"]
    snake_case   :				Tuple				 =   EfficientNetImageProcessor(
        size={"height": size, "width": size}						,							image_mean=[0.485, 0.456, 0.406]						,							image_std=[0.4785_3944, 0.473_2864, 0.4743_4163]						,							do_center_crop=__snake_case						,							)
    return preprocessor







def   __lowerCAmelCase						(						lowercase  :  Dict			)     ->						Any:


    """simple docstring"""





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

    snake_case   :				List[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:
        snake_case   :				List[str]				 =   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")			)

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

    snake_case   :				Dict				 =   "classifier.weight"
    snake_case   :				List[Any]				 =   "classifier.bias"
    return key_mapping







def   __lowerCAmelCase						(						lowercase  :  str						,							lowercase  :  Optional[int]						,							lowercase  :  Union[str, Any]			)     ->						List[Any]:


    """simple docstring"""





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

        snake_case   :				Dict				 =   key_mapping[key]
        if "_conv" in key and "kernel" in key:
            snake_case   :				List[str]				 =   torch.from_numpy(__snake_case			).permute(3						,							2						,							0						,							1			)
        elif "depthwise_kernel" in key:
            snake_case   :				List[str]				 =   torch.from_numpy(__snake_case			).permute(2						,							3						,							0						,							1			)
        elif "kernel" in key:
            snake_case   :				Optional[Any]				 =   torch.from_numpy(np.transpose(__snake_case			)			)
        else:
            snake_case   :				Optional[Any]				 =   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   __lowerCAmelCase						(						lowercase  :  Optional[int]						,							lowercase  :  Any						,							lowercase  :  Optional[int]						,							lowercase  :  List[str]			)     ->						str:


    """simple docstring"""





    snake_case   :				Dict				 =   model_classes[model_name](
        include_top=__snake_case						,							weights="imagenet"						,							input_tensor=__snake_case						,							input_shape=__snake_case						,							pooling=__snake_case						,							classes=1000						,							classifier_activation="softmax"						,							)

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

    # Load HuggingFace model
    snake_case   :				str				 =   get_efficientnet_config(__snake_case			)
    snake_case   :				Optional[int]				 =   EfficientNetForImageClassification(__snake_case			).eval()
    snake_case   :				Optional[Any]				 =   hf_model.state_dict()

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

    # Initialize preprocessor and preprocess input image
    snake_case   :				int				 =   convert_image_processor(__snake_case			)
    snake_case   :				Tuple				 =   preprocessor(images=prepare_img()						,							return_tensors="pt"			)

    # HF model inference
    hf_model.eval()
    with torch.no_grad():
        snake_case   :				Optional[int]				 =   hf_model(**__snake_case			)
    snake_case   :				Any				 =   outputs.logits.detach().numpy()

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


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

  __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"""



from dataclasses import dataclass
from typing import List, Optional, Union

import numpy as np
import PIL
from PIL import Image

from ...utils import (
    BaseOutput,
    OptionalDependencyNotAvailable,
    is_flax_available,
    is_k_diffusion_available,
    is_k_diffusion_version,
    is_onnx_available,
    is_torch_available,
    is_transformers_available,
    is_transformers_version,
)







@dataclass
class _lowerCAmelCase    (				snake_case_     ):
   __UpperCAmelCase			:	Union[List[PIL.Image.Image], np.ndarray]
   __UpperCAmelCase			:	Optional[List[bool]]


try:
  if not (is_transformers_available() and is_torch_available()):
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  from ...utils.dummy_torch_and_transformers_objects import *  # noqa F403
else:
  from .pipeline_cycle_diffusion import CycleDiffusionPipeline
  from .pipeline_stable_diffusion import StableDiffusionPipeline
  from .pipeline_stable_diffusion_attend_and_excite import StableDiffusionAttendAndExcitePipeline
  from .pipeline_stable_diffusion_imgaimg import StableDiffusionImgaImgPipeline
  from .pipeline_stable_diffusion_inpaint import StableDiffusionInpaintPipeline
  from .pipeline_stable_diffusion_inpaint_legacy import StableDiffusionInpaintPipelineLegacy
  from .pipeline_stable_diffusion_instruct_pixapix import StableDiffusionInstructPixaPixPipeline
  from .pipeline_stable_diffusion_latent_upscale import StableDiffusionLatentUpscalePipeline
  from .pipeline_stable_diffusion_ldmad import StableDiffusionLDMaDPipeline
  from .pipeline_stable_diffusion_model_editing import StableDiffusionModelEditingPipeline
  from .pipeline_stable_diffusion_panorama import StableDiffusionPanoramaPipeline
  from .pipeline_stable_diffusion_paradigms import StableDiffusionParadigmsPipeline
  from .pipeline_stable_diffusion_sag import StableDiffusionSAGPipeline
  from .pipeline_stable_diffusion_upscale import StableDiffusionUpscalePipeline
  from .pipeline_stable_unclip import StableUnCLIPPipeline
  from .pipeline_stable_unclip_imgaimg import StableUnCLIPImgaImgPipeline
  from .safety_checker import StableDiffusionSafetyChecker
  from .stable_unclip_image_normalizer import StableUnCLIPImageNormalizer

try:
  if not (is_transformers_available() and is_torch_available() and is_transformers_version(""">=""", """4.25.0""")):
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  from ...utils.dummy_torch_and_transformers_objects import StableDiffusionImageVariationPipeline
else:
  from .pipeline_stable_diffusion_image_variation import StableDiffusionImageVariationPipeline


try:
  if not (is_transformers_available() and is_torch_available() and is_transformers_version(""">=""", """4.26.0""")):
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  from ...utils.dummy_torch_and_transformers_objects import (
      StableDiffusionDepthaImgPipeline,
      StableDiffusionDiffEditPipeline,
      StableDiffusionPixaPixZeroPipeline,
  )
else:
  from .pipeline_stable_diffusion_depthaimg import StableDiffusionDepthaImgPipeline
  from .pipeline_stable_diffusion_diffedit import StableDiffusionDiffEditPipeline
  from .pipeline_stable_diffusion_pixapix_zero import StableDiffusionPixaPixZeroPipeline


try:
  if not (
      is_torch_available()
      and is_transformers_available()
      and is_k_diffusion_available()
      and is_k_diffusion_version(""">=""", """0.0.12""")
  ):
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  from ...utils.dummy_torch_and_transformers_and_k_diffusion_objects import *  # noqa F403
else:
  from .pipeline_stable_diffusion_k_diffusion import StableDiffusionKDiffusionPipeline

try:
  if not (is_transformers_available() and is_onnx_available()):
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  from ...utils.dummy_onnx_objects import *  # noqa F403
else:
  from .pipeline_onnx_stable_diffusion import OnnxStableDiffusionPipeline, StableDiffusionOnnxPipeline
  from .pipeline_onnx_stable_diffusion_imgaimg import OnnxStableDiffusionImgaImgPipeline
  from .pipeline_onnx_stable_diffusion_inpaint import OnnxStableDiffusionInpaintPipeline
  from .pipeline_onnx_stable_diffusion_inpaint_legacy import OnnxStableDiffusionInpaintPipelineLegacy
  from .pipeline_onnx_stable_diffusion_upscale import OnnxStableDiffusionUpscalePipeline

if is_transformers_available() and is_flax_available():
  import flax







  @flax.struct.dataclass
  class _lowerCAmelCase    (				snake_case_     ):
     __UpperCAmelCase			:	np.ndarray
     __UpperCAmelCase			:	List[bool]



  from ...schedulers.scheduling_pndm_flax import PNDMSchedulerState
  from .pipeline_flax_stable_diffusion import FlaxStableDiffusionPipeline
  from .pipeline_flax_stable_diffusion_imgaimg import FlaxStableDiffusionImgaImgPipeline
  from .pipeline_flax_stable_diffusion_inpaint import FlaxStableDiffusionInpaintPipeline
  from .safety_checker_flax import FlaxStableDiffusionSafetyChecker





