
from collections import OrderedDict

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


__lowerCamelCase							=       logging.get_logger(__name__)


__lowerCamelCase							=       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"""),
    ]
)

__lowerCamelCase							=       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"""),
    ]
)

__lowerCamelCase							=       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"""),
    ]
)

__lowerCamelCase							=       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"""),
    ]
)

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

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

__lowerCamelCase							=       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"""),
    ]
)

__lowerCamelCase							=       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"""),
    ]
)

__lowerCamelCase							=       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"""),
    ]
)

__lowerCamelCase							=       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"""),
    ]
)

__lowerCamelCase							=       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"""),
    ]
)

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

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

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

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






class   UpperCAmelCase		(						_BaseAutoModelClass ):
   A__					:		Any						     =     FLAX_MODEL_MAPPING



__lowerCamelCase							=       auto_class_update(FlaxAutoModel)






class   UpperCAmelCase		(						_BaseAutoModelClass ):
   A__					:		Any						     =     FLAX_MODEL_FOR_PRETRAINING_MAPPING



__lowerCamelCase							=       auto_class_update(FlaxAutoModelForPreTraining, head_doc="""pretraining""")






class   UpperCAmelCase		(						_BaseAutoModelClass ):
   A__					:		Optional[Any]						     =     FLAX_MODEL_FOR_CAUSAL_LM_MAPPING



__lowerCamelCase							=       auto_class_update(FlaxAutoModelForCausalLM, head_doc="""causal language modeling""")






class   UpperCAmelCase		(						_BaseAutoModelClass ):
   A__					:		int						     =     FLAX_MODEL_FOR_MASKED_LM_MAPPING



__lowerCamelCase							=       auto_class_update(FlaxAutoModelForMaskedLM, head_doc="""masked language modeling""")






class   UpperCAmelCase		(						_BaseAutoModelClass ):
   A__					:		str						     =     FLAX_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING



__lowerCamelCase							=       auto_class_update(
    FlaxAutoModelForSeqaSeqLM, head_doc="""sequence-to-sequence language modeling""", checkpoint_for_example="""t5-base"""
)






class   UpperCAmelCase		(						_BaseAutoModelClass ):
   A__					:		Dict						     =     FLAX_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING



__lowerCamelCase							=       auto_class_update(
    FlaxAutoModelForSequenceClassification, head_doc="""sequence classification"""
)






class   UpperCAmelCase		(						_BaseAutoModelClass ):
   A__					:		Tuple						     =     FLAX_MODEL_FOR_QUESTION_ANSWERING_MAPPING



__lowerCamelCase							=       auto_class_update(FlaxAutoModelForQuestionAnswering, head_doc="""question answering""")






class   UpperCAmelCase		(						_BaseAutoModelClass ):
   A__					:		str						     =     FLAX_MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING



__lowerCamelCase							=       auto_class_update(
    FlaxAutoModelForTokenClassification, head_doc="""token classification"""
)






class   UpperCAmelCase		(						_BaseAutoModelClass ):
   A__					:		int						     =     FLAX_MODEL_FOR_MULTIPLE_CHOICE_MAPPING



__lowerCamelCase							=       auto_class_update(FlaxAutoModelForMultipleChoice, head_doc="""multiple choice""")






class   UpperCAmelCase		(						_BaseAutoModelClass ):
   A__					:		Optional[Any]						     =     FLAX_MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING



__lowerCamelCase							=       auto_class_update(
    FlaxAutoModelForNextSentencePrediction, head_doc="""next sentence prediction"""
)






class   UpperCAmelCase		(						_BaseAutoModelClass ):
   A__					:		Tuple						     =     FLAX_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING



__lowerCamelCase							=       auto_class_update(
    FlaxAutoModelForImageClassification, head_doc="""image classification"""
)






class   UpperCAmelCase		(						_BaseAutoModelClass ):
   A__					:		int						     =     FLAX_MODEL_FOR_VISION_2_SEQ_MAPPING



__lowerCamelCase							=       auto_class_update(FlaxAutoModelForVisionaSeq, head_doc="""vision-to-text modeling""")






class   UpperCAmelCase		(						_BaseAutoModelClass ):
   A__					:		Tuple						     =     FLAX_MODEL_FOR_SPEECH_SEQ_2_SEQ_MAPPING



__lowerCamelCase							=       auto_class_update(
    FlaxAutoModelForSpeechSeqaSeq, head_doc="""sequence-to-sequence speech-to-text modeling"""
)










'''simple docstring'''





from pickle import UnpicklingError

import jax
import jax.numpy as jnp
import numpy as np
from flax.serialization import from_bytes
from flax.traverse_util import flatten_dict

from ..utils import logging


_lowerCAmelCase      						=	logging.get_logger(__name__)
def    _SCREAMING_SNAKE_CASE  (       UpperCamelCase							,    UpperCamelCase			):



    """simple docstring"""





    try:
        with open(UpperCamelCase							,    """rb"""			) as flax_state_f:
            lowerCAmelCase__ :  Union[str, Any]							      =					from_bytes(UpperCamelCase							,    flax_state_f.read()			)
    except UnpicklingError as e:
        try:
            with open(UpperCamelCase			) as f:
                if f.read().startswith("""version"""			):
                    raise OSError(
                        """You seem to have cloned a repository without having git-lfs installed. Please"""
                        """ install git-lfs and run `git lfs install` followed by `git lfs pull` in the"""
                        """ folder you cloned."""			)
                else:
                    raise ValueError from e
        except (UnicodeDecodeError, ValueError):
            raise EnvironmentError(f"""Unable to convert {model_file} to Flax deserializable object. """			)

    return load_flax_weights_in_pytorch_model(UpperCamelCase							,    UpperCamelCase			)




def    _SCREAMING_SNAKE_CASE  (       UpperCamelCase							,    UpperCamelCase			):



    """simple docstring"""





    try:
        import torch  # noqa: F401
    except ImportError:
        logger.error(
            """Loading Flax weights in PyTorch requires both PyTorch and Flax to be installed. Please see"""
            """ https://pytorch.org/ and https://flax.readthedocs.io/en/latest/installation.html for installation"""
            """ instructions."""			)
        raise

    # check if we have bf16 weights
    lowerCAmelCase__ :  str							      =					flatten_dict(jax.tree_util.tree_map(lambda UpperCamelCase			: x.dtype == jnp.bfloataa							,    UpperCamelCase			)			).values()
    if any(UpperCamelCase			):
        # convert all weights to fp32 if they are bf16 since torch.from_numpy can-not handle bf16

        # and bf16 is not fully supported in PT yet.
        logger.warning(
            """Found ``bfloat16`` weights in Flax model. Casting all ``bfloat16`` weights to ``float32`` """
            """before loading those in PyTorch model."""			)
        lowerCAmelCase__ :  Dict							      =					jax.tree_util.tree_map(
            lambda UpperCamelCase			: params.astype(np.floataa			) if params.dtype == jnp.bfloataa else params							,    UpperCamelCase			)

    lowerCAmelCase__ :  Any							      =					""""""

    lowerCAmelCase__ :  Any							      =					flatten_dict(UpperCamelCase							,    sep="""."""			)
    lowerCAmelCase__ :  Optional[int]							      =					pt_model.state_dict()

    # keep track of unexpected & missing keys
    lowerCAmelCase__ :  Optional[Any]							      =					[]
    lowerCAmelCase__ :  int							      =					set(pt_model_dict.keys()			)

    for flax_key_tuple, flax_tensor in flax_state_dict.items():
        lowerCAmelCase__ :  Union[str, Any]							      =					flax_key_tuple.split("""."""			)

        if flax_key_tuple_array[-1] == "kernel" and flax_tensor.ndim == 4:
            lowerCAmelCase__ :  Optional[int]							      =					flax_key_tuple_array[:-1] + ["""weight"""]
            lowerCAmelCase__ :  Any							      =					jnp.transpose(UpperCamelCase							,    (3, 2, 0, 1)			)
        elif flax_key_tuple_array[-1] == "kernel":
            lowerCAmelCase__ :  str							      =					flax_key_tuple_array[:-1] + ["""weight"""]
            lowerCAmelCase__ :  Any							      =					flax_tensor.T
        elif flax_key_tuple_array[-1] == "scale":
            lowerCAmelCase__ :  int							      =					flax_key_tuple_array[:-1] + ["""weight"""]

        if "time_embedding" not in flax_key_tuple_array:
            for i, flax_key_tuple_string in enumerate(UpperCamelCase			):
                lowerCAmelCase__ :  List[str]							      =					(
                    flax_key_tuple_string.replace("""_0"""							,    """.0"""			)
                    .replace("""_1"""							,    """.1"""			)
                    .replace("""_2"""							,    """.2"""			)
                    .replace("""_3"""							,    """.3"""			)
                    .replace("""_4"""							,    """.4"""			)
                    .replace("""_5"""							,    """.5"""			)
                    .replace("""_6"""							,    """.6"""			)
                    .replace("""_7"""							,    """.7"""			)
                    .replace("""_8"""							,    """.8"""			)
                    .replace("""_9"""							,    """.9"""			)
                )

        lowerCAmelCase__ :  Union[str, Any]							      =					""".""".join(UpperCamelCase			)

        if flax_key in pt_model_dict:
            if flax_tensor.shape != pt_model_dict[flax_key].shape:
                raise ValueError(
                    f"""Flax checkpoint seems to be incorrect. Weight {flax_key_tuple} was expected """
                    f"""to be of shape {pt_model_dict[flax_key].shape}, but is {flax_tensor.shape}."""			)
            else:
                # add weight to pytorch dict
                lowerCAmelCase__ :  int							      =					np.asarray(UpperCamelCase			) if not isinstance(UpperCamelCase							,    np.ndarray			) else flax_tensor
                lowerCAmelCase__ :  int							      =					torch.from_numpy(UpperCamelCase			)
                # remove from missing keys
                missing_keys.remove(UpperCamelCase			)
        else:
            # weight is not expected by PyTorch model
            unexpected_keys.append(UpperCamelCase			)

    pt_model.load_state_dict(UpperCamelCase			)

    # re-transform missing_keys to list
    lowerCAmelCase__ :  Optional[int]							      =					list(UpperCamelCase			)

    if len(UpperCamelCase			) > 0:
        logger.warning(
            """Some weights of the Flax model were not used when initializing the PyTorch model"""
            f""" {pt_model.__class__.__name__}: {unexpected_keys}\n- This IS expected if you are initializing"""
            f""" {pt_model.__class__.__name__} from a Flax model trained on another task or with another architecture"""
            """ (e.g. initializing a BertForSequenceClassification model from a FlaxBertForPreTraining model).\n- This"""
            f""" IS NOT expected if you are initializing {pt_model.__class__.__name__} from a Flax model that you expect"""
            """ to be exactly identical (e.g. initializing a BertForSequenceClassification model from a"""
            """ FlaxBertForSequenceClassification model)."""			)
    if len(UpperCamelCase			) > 0:
        logger.warning(
            f"""Some weights of {pt_model.__class__.__name__} were not initialized from the Flax model and are newly"""
            f""" initialized: {missing_keys}\nYou should probably TRAIN this model on a down-stream task to be able to"""
            """ use it for predictions and inference."""			)

    return pt_model


