





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()
SCREAMING_SNAKE_CASE_						   =       logging.get_logger(__name__)

SCREAMING_SNAKE_CASE_						   =       {
    """b0""": efficientnet.EfficientNetBa,
    """b1""": efficientnet.EfficientNetBa,
    """b2""": efficientnet.EfficientNetBa,
    """b3""": efficientnet.EfficientNetBa,
    """b4""": efficientnet.EfficientNetBa,
    """b5""": efficientnet.EfficientNetBa,
    """b6""": efficientnet.EfficientNetBa,
    """b7""": efficientnet.EfficientNetBa,
}

SCREAMING_SNAKE_CASE_						   =       {
    """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    __lowercase   (      _SCREAMING_SNAKE_CASE	) ->   Any:


      '''simple docstring'''


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

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

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



def    __lowercase   (      ) ->   Optional[Any]:


      '''simple docstring'''


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



def    __lowercase   (      _SCREAMING_SNAKE_CASE	) ->   int:


      '''simple docstring'''


      SCREAMING_SNAKE_CASE		=						CONFIG_MAP[model_name]["""image_size"""]
      SCREAMING_SNAKE_CASE		=						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=_SCREAMING_SNAKE_CASE ,						)
      return preprocessor



def    __lowercase   (      _SCREAMING_SNAKE_CASE	) ->   Any:


      '''simple docstring'''


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

      SCREAMING_SNAKE_CASE		=						[]
      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:
            SCREAMING_SNAKE_CASE		=						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""")	)

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

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



def    __lowercase   (      _SCREAMING_SNAKE_CASE ,						_SCREAMING_SNAKE_CASE ,						_SCREAMING_SNAKE_CASE	) ->   Optional[Any]:


      '''simple docstring'''


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

            SCREAMING_SNAKE_CASE		=						key_mapping[key]
            if "_conv" in key and "kernel" in key:
                  SCREAMING_SNAKE_CASE		=						torch.from_numpy(_SCREAMING_SNAKE_CASE	).permute(3 ,						2 ,						0 ,						1	)
            elif "depthwise_kernel" in key:
                  SCREAMING_SNAKE_CASE		=						torch.from_numpy(_SCREAMING_SNAKE_CASE	).permute(2 ,						3 ,						0 ,						1	)
            elif "kernel" in key:
                  SCREAMING_SNAKE_CASE		=						torch.from_numpy(np.transpose(_SCREAMING_SNAKE_CASE	)	)
            else:
                  SCREAMING_SNAKE_CASE		=						torch.from_numpy(_SCREAMING_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_(_SCREAMING_SNAKE_CASE	)



@torch.no_grad()
def    __lowercase   (      _SCREAMING_SNAKE_CASE ,						_SCREAMING_SNAKE_CASE ,						_SCREAMING_SNAKE_CASE ,						_SCREAMING_SNAKE_CASE	) ->   int:


      '''simple docstring'''


      SCREAMING_SNAKE_CASE		=						model_classes[model_name](
          include_top=_SCREAMING_SNAKE_CASE ,						weights="""imagenet""" ,						input_tensor=_SCREAMING_SNAKE_CASE ,						input_shape=_SCREAMING_SNAKE_CASE ,						pooling=_SCREAMING_SNAKE_CASE ,						classes=10_00 ,						classifier_activation="""softmax""" ,						)

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

      # Load HuggingFace model
      SCREAMING_SNAKE_CASE		=						get_efficientnet_config(_SCREAMING_SNAKE_CASE	)
      SCREAMING_SNAKE_CASE		=						EfficientNetForImageClassification(_SCREAMING_SNAKE_CASE	).eval()
      SCREAMING_SNAKE_CASE		=						hf_model.state_dict()

      # Create src-to-dst parameter name mapping dictionary
      print("""Converting parameters..."""	)
      SCREAMING_SNAKE_CASE		=						rename_keys(_SCREAMING_SNAKE_CASE	)
      replace_params(_SCREAMING_SNAKE_CASE ,						_SCREAMING_SNAKE_CASE ,						_SCREAMING_SNAKE_CASE	)

      # Initialize preprocessor and preprocess input image
      SCREAMING_SNAKE_CASE		=						convert_image_processor(_SCREAMING_SNAKE_CASE	)
      SCREAMING_SNAKE_CASE		=						preprocessor(images=prepare_img() ,						return_tensors="""pt"""	)

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

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

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

      if push_to_hub:
            # Push model and image processor to hub
            print(F"""Pushing converted {model_name} to the hub..."""	)
            SCREAMING_SNAKE_CASE		=						F"""efficientnet-{model_name}"""
            preprocessor.push_to_hub(_SCREAMING_SNAKE_CASE	)
            hf_model.push_to_hub(_SCREAMING_SNAKE_CASE	)


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

      SCREAMING_SNAKE_CASE_						   =       parser.parse_args()
      convert_efficientnet_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.save_model, args.push_to_hub)









from collections import OrderedDict

from ...utils import logging
from .auto_factory import _BaseAutoModelClass, _LazyAutoMapping, auto_class_update
from .configuration_auto import CONFIG_MAPPING_NAMES


SCREAMING_SNAKE_CASE_						   =       logging.get_logger(__name__)


SCREAMING_SNAKE_CASE_						   =       OrderedDict(
    [
        # Base model mapping
        ("""albert""", """FlaxAlbertModel"""),
        ("""bart""", """FlaxBartModel"""),
        ("""beit""", """FlaxBeitModel"""),
        ("""bert""", """FlaxBertModel"""),
        ("""big_bird""", """FlaxBigBirdModel"""),
        ("""blenderbot""", """FlaxBlenderbotModel"""),
        ("""blenderbot-small""", """FlaxBlenderbotSmallModel"""),
        ("""clip""", """FlaxCLIPModel"""),
        ("""distilbert""", """FlaxDistilBertModel"""),
        ("""electra""", """FlaxElectraModel"""),
        ("""gpt-sw3""", """FlaxGPT2Model"""),
        ("""gpt2""", """FlaxGPT2Model"""),
        ("""gpt_neo""", """FlaxGPTNeoModel"""),
        ("""gptj""", """FlaxGPTJModel"""),
        ("""longt5""", """FlaxLongT5Model"""),
        ("""marian""", """FlaxMarianModel"""),
        ("""mbart""", """FlaxMBartModel"""),
        ("""mt5""", """FlaxMT5Model"""),
        ("""opt""", """FlaxOPTModel"""),
        ("""pegasus""", """FlaxPegasusModel"""),
        ("""regnet""", """FlaxRegNetModel"""),
        ("""resnet""", """FlaxResNetModel"""),
        ("""roberta""", """FlaxRobertaModel"""),
        ("""roberta-prelayernorm""", """FlaxRobertaPreLayerNormModel"""),
        ("""roformer""", """FlaxRoFormerModel"""),
        ("""t5""", """FlaxT5Model"""),
        ("""vision-text-dual-encoder""", """FlaxVisionTextDualEncoderModel"""),
        ("""vit""", """FlaxViTModel"""),
        ("""wav2vec2""", """FlaxWav2Vec2Model"""),
        ("""whisper""", """FlaxWhisperModel"""),
        ("""xglm""", """FlaxXGLMModel"""),
        ("""xlm-roberta""", """FlaxXLMRobertaModel"""),
    ]
)

SCREAMING_SNAKE_CASE_						   =       OrderedDict(
    [
        # Model for pre-training mapping
        ("""albert""", """FlaxAlbertForPreTraining"""),
        ("""bart""", """FlaxBartForConditionalGeneration"""),
        ("""bert""", """FlaxBertForPreTraining"""),
        ("""big_bird""", """FlaxBigBirdForPreTraining"""),
        ("""electra""", """FlaxElectraForPreTraining"""),
        ("""longt5""", """FlaxLongT5ForConditionalGeneration"""),
        ("""mbart""", """FlaxMBartForConditionalGeneration"""),
        ("""mt5""", """FlaxMT5ForConditionalGeneration"""),
        ("""roberta""", """FlaxRobertaForMaskedLM"""),
        ("""roberta-prelayernorm""", """FlaxRobertaPreLayerNormForMaskedLM"""),
        ("""roformer""", """FlaxRoFormerForMaskedLM"""),
        ("""t5""", """FlaxT5ForConditionalGeneration"""),
        ("""wav2vec2""", """FlaxWav2Vec2ForPreTraining"""),
        ("""whisper""", """FlaxWhisperForConditionalGeneration"""),
        ("""xlm-roberta""", """FlaxXLMRobertaForMaskedLM"""),
    ]
)

SCREAMING_SNAKE_CASE_						   =       OrderedDict(
    [
        # Model for Masked LM mapping
        ("""albert""", """FlaxAlbertForMaskedLM"""),
        ("""bart""", """FlaxBartForConditionalGeneration"""),
        ("""bert""", """FlaxBertForMaskedLM"""),
        ("""big_bird""", """FlaxBigBirdForMaskedLM"""),
        ("""distilbert""", """FlaxDistilBertForMaskedLM"""),
        ("""electra""", """FlaxElectraForMaskedLM"""),
        ("""mbart""", """FlaxMBartForConditionalGeneration"""),
        ("""roberta""", """FlaxRobertaForMaskedLM"""),
        ("""roberta-prelayernorm""", """FlaxRobertaPreLayerNormForMaskedLM"""),
        ("""roformer""", """FlaxRoFormerForMaskedLM"""),
        ("""xlm-roberta""", """FlaxXLMRobertaForMaskedLM"""),
    ]
)

SCREAMING_SNAKE_CASE_						   =       OrderedDict(
    [
        # Model for Seq2Seq Causal LM mapping
        ("""bart""", """FlaxBartForConditionalGeneration"""),
        ("""blenderbot""", """FlaxBlenderbotForConditionalGeneration"""),
        ("""blenderbot-small""", """FlaxBlenderbotSmallForConditionalGeneration"""),
        ("""encoder-decoder""", """FlaxEncoderDecoderModel"""),
        ("""longt5""", """FlaxLongT5ForConditionalGeneration"""),
        ("""marian""", """FlaxMarianMTModel"""),
        ("""mbart""", """FlaxMBartForConditionalGeneration"""),
        ("""mt5""", """FlaxMT5ForConditionalGeneration"""),
        ("""pegasus""", """FlaxPegasusForConditionalGeneration"""),
        ("""t5""", """FlaxT5ForConditionalGeneration"""),
    ]
)

SCREAMING_SNAKE_CASE_						   =       OrderedDict(
    [
        # Model for Image-classsification
        ("""beit""", """FlaxBeitForImageClassification"""),
        ("""regnet""", """FlaxRegNetForImageClassification"""),
        ("""resnet""", """FlaxResNetForImageClassification"""),
        ("""vit""", """FlaxViTForImageClassification"""),
    ]
)

SCREAMING_SNAKE_CASE_						   =       OrderedDict(
    [
        ("""vision-encoder-decoder""", """FlaxVisionEncoderDecoderModel"""),
    ]
)

SCREAMING_SNAKE_CASE_						   =       OrderedDict(
    [
        # Model for Causal LM mapping
        ("""bart""", """FlaxBartForCausalLM"""),
        ("""bert""", """FlaxBertForCausalLM"""),
        ("""big_bird""", """FlaxBigBirdForCausalLM"""),
        ("""electra""", """FlaxElectraForCausalLM"""),
        ("""gpt-sw3""", """FlaxGPT2LMHeadModel"""),
        ("""gpt2""", """FlaxGPT2LMHeadModel"""),
        ("""gpt_neo""", """FlaxGPTNeoForCausalLM"""),
        ("""gptj""", """FlaxGPTJForCausalLM"""),
        ("""opt""", """FlaxOPTForCausalLM"""),
        ("""roberta""", """FlaxRobertaForCausalLM"""),
        ("""roberta-prelayernorm""", """FlaxRobertaPreLayerNormForCausalLM"""),
        ("""xglm""", """FlaxXGLMForCausalLM"""),
        ("""xlm-roberta""", """FlaxXLMRobertaForCausalLM"""),
    ]
)

SCREAMING_SNAKE_CASE_						   =       OrderedDict(
    [
        # Model for Sequence Classification mapping
        ("""albert""", """FlaxAlbertForSequenceClassification"""),
        ("""bart""", """FlaxBartForSequenceClassification"""),
        ("""bert""", """FlaxBertForSequenceClassification"""),
        ("""big_bird""", """FlaxBigBirdForSequenceClassification"""),
        ("""distilbert""", """FlaxDistilBertForSequenceClassification"""),
        ("""electra""", """FlaxElectraForSequenceClassification"""),
        ("""mbart""", """FlaxMBartForSequenceClassification"""),
        ("""roberta""", """FlaxRobertaForSequenceClassification"""),
        ("""roberta-prelayernorm""", """FlaxRobertaPreLayerNormForSequenceClassification"""),
        ("""roformer""", """FlaxRoFormerForSequenceClassification"""),
        ("""xlm-roberta""", """FlaxXLMRobertaForSequenceClassification"""),
    ]
)

SCREAMING_SNAKE_CASE_						   =       OrderedDict(
    [
        # Model for Question Answering mapping
        ("""albert""", """FlaxAlbertForQuestionAnswering"""),
        ("""bart""", """FlaxBartForQuestionAnswering"""),
        ("""bert""", """FlaxBertForQuestionAnswering"""),
        ("""big_bird""", """FlaxBigBirdForQuestionAnswering"""),
        ("""distilbert""", """FlaxDistilBertForQuestionAnswering"""),
        ("""electra""", """FlaxElectraForQuestionAnswering"""),
        ("""mbart""", """FlaxMBartForQuestionAnswering"""),
        ("""roberta""", """FlaxRobertaForQuestionAnswering"""),
        ("""roberta-prelayernorm""", """FlaxRobertaPreLayerNormForQuestionAnswering"""),
        ("""roformer""", """FlaxRoFormerForQuestionAnswering"""),
        ("""xlm-roberta""", """FlaxXLMRobertaForQuestionAnswering"""),
    ]
)

SCREAMING_SNAKE_CASE_						   =       OrderedDict(
    [
        # Model for Token Classification mapping
        ("""albert""", """FlaxAlbertForTokenClassification"""),
        ("""bert""", """FlaxBertForTokenClassification"""),
        ("""big_bird""", """FlaxBigBirdForTokenClassification"""),
        ("""distilbert""", """FlaxDistilBertForTokenClassification"""),
        ("""electra""", """FlaxElectraForTokenClassification"""),
        ("""roberta""", """FlaxRobertaForTokenClassification"""),
        ("""roberta-prelayernorm""", """FlaxRobertaPreLayerNormForTokenClassification"""),
        ("""roformer""", """FlaxRoFormerForTokenClassification"""),
        ("""xlm-roberta""", """FlaxXLMRobertaForTokenClassification"""),
    ]
)

SCREAMING_SNAKE_CASE_						   =       OrderedDict(
    [
        # Model for Multiple Choice mapping
        ("""albert""", """FlaxAlbertForMultipleChoice"""),
        ("""bert""", """FlaxBertForMultipleChoice"""),
        ("""big_bird""", """FlaxBigBirdForMultipleChoice"""),
        ("""distilbert""", """FlaxDistilBertForMultipleChoice"""),
        ("""electra""", """FlaxElectraForMultipleChoice"""),
        ("""roberta""", """FlaxRobertaForMultipleChoice"""),
        ("""roberta-prelayernorm""", """FlaxRobertaPreLayerNormForMultipleChoice"""),
        ("""roformer""", """FlaxRoFormerForMultipleChoice"""),
        ("""xlm-roberta""", """FlaxXLMRobertaForMultipleChoice"""),
    ]
)

SCREAMING_SNAKE_CASE_						   =       OrderedDict(
    [
        ("""bert""", """FlaxBertForNextSentencePrediction"""),
    ]
)

SCREAMING_SNAKE_CASE_						   =       OrderedDict(
    [
        ("""speech-encoder-decoder""", """FlaxSpeechEncoderDecoderModel"""),
        ("""whisper""", """FlaxWhisperForConditionalGeneration"""),
    ]
)

SCREAMING_SNAKE_CASE_						   =       OrderedDict(
    [
        ("""whisper""", """FlaxWhisperForAudioClassification"""),
    ]
)

SCREAMING_SNAKE_CASE_						   =       _LazyAutoMapping(CONFIG_MAPPING_NAMES, FLAX_MODEL_MAPPING_NAMES)
SCREAMING_SNAKE_CASE_						   =       _LazyAutoMapping(CONFIG_MAPPING_NAMES, FLAX_MODEL_FOR_PRETRAINING_MAPPING_NAMES)
SCREAMING_SNAKE_CASE_						   =       _LazyAutoMapping(CONFIG_MAPPING_NAMES, FLAX_MODEL_FOR_MASKED_LM_MAPPING_NAMES)
SCREAMING_SNAKE_CASE_						   =       _LazyAutoMapping(
    CONFIG_MAPPING_NAMES, FLAX_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING_NAMES
)
SCREAMING_SNAKE_CASE_						   =       _LazyAutoMapping(
    CONFIG_MAPPING_NAMES, FLAX_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING_NAMES
)
SCREAMING_SNAKE_CASE_						   =       _LazyAutoMapping(CONFIG_MAPPING_NAMES, FLAX_MODEL_FOR_VISION_2_SEQ_MAPPING_NAMES)
SCREAMING_SNAKE_CASE_						   =       _LazyAutoMapping(CONFIG_MAPPING_NAMES, FLAX_MODEL_FOR_CAUSAL_LM_MAPPING_NAMES)
SCREAMING_SNAKE_CASE_						   =       _LazyAutoMapping(
    CONFIG_MAPPING_NAMES, FLAX_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING_NAMES
)
SCREAMING_SNAKE_CASE_						   =       _LazyAutoMapping(
    CONFIG_MAPPING_NAMES, FLAX_MODEL_FOR_QUESTION_ANSWERING_MAPPING_NAMES
)
SCREAMING_SNAKE_CASE_						   =       _LazyAutoMapping(
    CONFIG_MAPPING_NAMES, FLAX_MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING_NAMES
)
SCREAMING_SNAKE_CASE_						   =       _LazyAutoMapping(
    CONFIG_MAPPING_NAMES, FLAX_MODEL_FOR_MULTIPLE_CHOICE_MAPPING_NAMES
)
SCREAMING_SNAKE_CASE_						   =       _LazyAutoMapping(
    CONFIG_MAPPING_NAMES, FLAX_MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING_NAMES
)
SCREAMING_SNAKE_CASE_						   =       _LazyAutoMapping(
    CONFIG_MAPPING_NAMES, FLAX_MODEL_FOR_SPEECH_SEQ_2_SEQ_MAPPING_NAMES
)
SCREAMING_SNAKE_CASE_						   =       _LazyAutoMapping(
    CONFIG_MAPPING_NAMES, FLAX_MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING_NAMES
)

class 		UpperCamelCase__ (      _BaseAutoModelClass   ):



     '''simple docstring'''

     __snake_case    :	List[str]			=			FLAX_MODEL_MAPPING
SCREAMING_SNAKE_CASE_						   =       auto_class_update(FlaxAutoModel)

class 		UpperCamelCase__ (      _BaseAutoModelClass   ):



     '''simple docstring'''

     __snake_case    :	Dict			=			FLAX_MODEL_FOR_PRETRAINING_MAPPING
SCREAMING_SNAKE_CASE_						   =       auto_class_update(FlaxAutoModelForPreTraining, head_doc="""pretraining""")

class 		UpperCamelCase__ (      _BaseAutoModelClass   ):



     '''simple docstring'''

     __snake_case    :	Optional[Any]			=			FLAX_MODEL_FOR_CAUSAL_LM_MAPPING
SCREAMING_SNAKE_CASE_						   =       auto_class_update(FlaxAutoModelForCausalLM, head_doc="""causal language modeling""")

class 		UpperCamelCase__ (      _BaseAutoModelClass   ):



     '''simple docstring'''

     __snake_case    :	Any			=			FLAX_MODEL_FOR_MASKED_LM_MAPPING
SCREAMING_SNAKE_CASE_						   =       auto_class_update(FlaxAutoModelForMaskedLM, head_doc="""masked language modeling""")

class 		UpperCamelCase__ (      _BaseAutoModelClass   ):



     '''simple docstring'''

     __snake_case    :	int			=			FLAX_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING
SCREAMING_SNAKE_CASE_						   =       auto_class_update(
    FlaxAutoModelForSeqaSeqLM, head_doc="""sequence-to-sequence language modeling""", checkpoint_for_example="""t5-base"""
)

class 		UpperCamelCase__ (      _BaseAutoModelClass   ):



     '''simple docstring'''

     __snake_case    :	Optional[int]			=			FLAX_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING
SCREAMING_SNAKE_CASE_						   =       auto_class_update(
    FlaxAutoModelForSequenceClassification, head_doc="""sequence classification"""
)

class 		UpperCamelCase__ (      _BaseAutoModelClass   ):



     '''simple docstring'''

     __snake_case    :	List[Any]			=			FLAX_MODEL_FOR_QUESTION_ANSWERING_MAPPING
SCREAMING_SNAKE_CASE_						   =       auto_class_update(FlaxAutoModelForQuestionAnswering, head_doc="""question answering""")

class 		UpperCamelCase__ (      _BaseAutoModelClass   ):



     '''simple docstring'''

     __snake_case    :	Tuple			=			FLAX_MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING
SCREAMING_SNAKE_CASE_						   =       auto_class_update(
    FlaxAutoModelForTokenClassification, head_doc="""token classification"""
)

class 		UpperCamelCase__ (      _BaseAutoModelClass   ):



     '''simple docstring'''

     __snake_case    :	Union[str, Any]			=			FLAX_MODEL_FOR_MULTIPLE_CHOICE_MAPPING
SCREAMING_SNAKE_CASE_						   =       auto_class_update(FlaxAutoModelForMultipleChoice, head_doc="""multiple choice""")

class 		UpperCamelCase__ (      _BaseAutoModelClass   ):



     '''simple docstring'''

     __snake_case    :	List[str]			=			FLAX_MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING
SCREAMING_SNAKE_CASE_						   =       auto_class_update(
    FlaxAutoModelForNextSentencePrediction, head_doc="""next sentence prediction"""
)

class 		UpperCamelCase__ (      _BaseAutoModelClass   ):



     '''simple docstring'''

     __snake_case    :	Dict			=			FLAX_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING
SCREAMING_SNAKE_CASE_						   =       auto_class_update(
    FlaxAutoModelForImageClassification, head_doc="""image classification"""
)

class 		UpperCamelCase__ (      _BaseAutoModelClass   ):



     '''simple docstring'''

     __snake_case    :	Dict			=			FLAX_MODEL_FOR_VISION_2_SEQ_MAPPING
SCREAMING_SNAKE_CASE_						   =       auto_class_update(FlaxAutoModelForVisionaSeq, head_doc="""vision-to-text modeling""")

class 		UpperCamelCase__ (      _BaseAutoModelClass   ):



     '''simple docstring'''

     __snake_case    :	Optional[Any]			=			FLAX_MODEL_FOR_SPEECH_SEQ_2_SEQ_MAPPING
SCREAMING_SNAKE_CASE_						   =       auto_class_update(
    FlaxAutoModelForSpeechSeqaSeq, head_doc="""sequence-to-sequence speech-to-text modeling"""
)


