
'''simple docstring'''




import os
import re
import unicodedata
from shutil import copyfile
from typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple, Union

import sentencepiece as spm

from ...tokenization_utils import PreTrainedTokenizer
from ...utils import is_torch_available, logging


if is_torch_available():
      import torch


if TYPE_CHECKING:
      from transformers.pipelines.conversational import Conversation


lowercase			:				List[Any]    		=			logging.get_logger(__name__)
lowercase			:				Any    		=			{'vocab_file': 'spiece.model'}

lowercase			:				int    		=			{
    'vocab_file': {
        'AI-Sweden/gpt-sw3-126m': 'https://huggingface.co/AI-Sweden/gpt-sw3-126m/resolve/main/spiece.model',
        'AI-Sweden/gpt-sw3-350m': 'https://huggingface.co/AI-Sweden/gpt-sw3-350m/resolve/main/spiece.model',
        'AI-Sweden/gpt-sw3-1.6b': 'https://huggingface.co/AI-Sweden/gpt-sw3-1.6b/resolve/main/spiece.model',
        'AI-Sweden/gpt-sw3-6.7b': 'https://huggingface.co/AI-Sweden/gpt-sw3-6.7b/resolve/main/spiece.model',
        'AI-Sweden/gpt-sw3-20b': 'https://huggingface.co/AI-Sweden/gpt-sw3-20b/resolve/main/spiece.model',
    }
}

lowercase			:				List[str]    		=			{
    'AI-Sweden/gpt-sw3-126m': 20_48,
    'AI-Sweden/gpt-sw3-350m': 20_48,
    'AI-Sweden/gpt-sw3-1.6b': 20_48,
    'AI-Sweden/gpt-sw3-6.7b': 20_48,
    'AI-Sweden/gpt-sw3-20b': 20_48,
}





class  A				(							__snake_case						):
     __magic_name__						=		VOCAB_FILES_NAMES
     __magic_name__						=		PRETRAINED_VOCAB_FILES_MAP
     __magic_name__						=		PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
     __magic_name__						=		['''input_ids''', '''attention_mask''']





     def __init__(							self						,			SCREAMING_SNAKE_CASE						,			SCREAMING_SNAKE_CASE=False						,			SCREAMING_SNAKE_CASE=False						,			SCREAMING_SNAKE_CASE=False						,			SCREAMING_SNAKE_CASE=None						,			SCREAMING_SNAKE_CASE=None						,			SCREAMING_SNAKE_CASE=None						,			SCREAMING_SNAKE_CASE=None						,			SCREAMING_SNAKE_CASE = None						,			**SCREAMING_SNAKE_CASE						,			) ->				None:






         """simple docstring"""






         A       :   List[str]					=						{} if sp_model_kwargs is None else sp_model_kwargs

         A       :   Optional[int]					=						kwargs.get('''name_or_path'''	)
         if name_or_path is None:
             logger.warning(
                 '''name_or_path not provided, will work for all GPTSw3 models except gpt-sw3-7b,'''
                 ''' you are testing the model, this can safely be ignored'''	)
             A       :   List[Any]					=						'''None'''

         # Default definitions for our 2 tokenizer versions, with None-checks to enable proper testing
         A       :   int					=						'''<|endoftext|>''' if eos_token is None else eos_token
         A       :   Dict					=						'''<unk>''' if unk_token is None else unk_token
         if "gpt-sw3-7b" in name_or_path:
             A       :   List[Any]					=						unk_token if pad_token is None else pad_token
             A       :   List[str]					=						eos_token if bos_token is None else bos_token
         else:
             A       :   Optional[Any]					=						'''<pad>''' if pad_token is None else pad_token
             A       :   Optional[int]					=						'''<s>''' if bos_token is None else bos_token

         super().__init__(
             do_lower_case=SCREAMING_SNAKE_CASE						,			remove_space=SCREAMING_SNAKE_CASE						,			keep_accents=SCREAMING_SNAKE_CASE						,			bos_token=SCREAMING_SNAKE_CASE						,			eos_token=SCREAMING_SNAKE_CASE						,			unk_token=SCREAMING_SNAKE_CASE						,			pad_token=SCREAMING_SNAKE_CASE						,			sp_model_kwargs=self.sp_model_kwargs						,			**SCREAMING_SNAKE_CASE						,			)

         A       :   List[str]					=						do_lower_case
         A       :   List[str]					=						remove_space
         A       :   Union[str, Any]					=						keep_accents
         A       :   Union[str, Any]					=						vocab_file

         A       :   Tuple					=						spm.SentencePieceProcessor(**self.sp_model_kwargs	)
         self.sp_model.Load(SCREAMING_SNAKE_CASE	)

         # Used for whitespace normalization in input texts
         # fmt : off
         A       :   Any					=						{''' ''', ''' ''', ''' ''', ''' ''', ''' ''', '''　''', ''' ''', ''' ''', ''' ''', ''' ''', '''￼''', ''''''}
         # fmt : on

         # Regular expression to remove non-printing characters (e.g. some unicode control chars) in preprocessing
         A       :   List[str]					=						re.compile(
             F'[{"".join(map(SCREAMING_SNAKE_CASE						,			list(range(0						,			9	)	) + list(range(11						,			32	)	) + list(range(127						,			160	)	) + [160, 173, 8203]	)	)}]'	)





     def __getstate__(							self	) ->				Dict:






         """simple docstring"""






         A       :   Tuple					=						self.__dict__.copy()
         A       :   List[Any]					=						None
         return state





     def __setstate__(							self						,			SCREAMING_SNAKE_CASE	) ->				str:






         """simple docstring"""






         A       :   Tuple					=						d

         # for backward compatibility
         if not hasattr(self						,			'''sp_model_kwargs'''	):
             A       :   Any					=						{}

         A       :   Dict					=						spm.SentencePieceProcessor(**self.sp_model_kwargs	)
         self.sp_model.Load(self.vocab_file	)





     @property
     # Copied from transformers.models.albert.tokenization_albert.AlbertTokenizer.vocab_size
     def 				__lowerCAmelCase							(							self	) ->				int:






         """simple docstring"""






         return len(self.sp_model	)





     def 				__lowerCAmelCase							(							self						,			SCREAMING_SNAKE_CASE	) ->				str:






         """simple docstring"""






         A       :   List[str]					=						self.non_printing_characters_re.sub(''''''						,			SCREAMING_SNAKE_CASE	)

         # Normalize whitespaces
         A       :   Union[str, Any]					=						''''''.join([char if char not in self.whitespaces else ''' ''' for char in text]	)

         # NFC Unicode normalization
         A       :   Optional[int]					=						unicodedata.normalize('''NFC'''						,			SCREAMING_SNAKE_CASE	)
         return text





     def 				__lowerCAmelCase							(							self						,			SCREAMING_SNAKE_CASE						,			**SCREAMING_SNAKE_CASE	) ->				List[str]:






         """simple docstring"""






         A       :   Optional[int]					=						self.preprocess_text(SCREAMING_SNAKE_CASE	)
         return self.sp_model.encode(SCREAMING_SNAKE_CASE						,			out_type=SCREAMING_SNAKE_CASE	)





     def 				__lowerCAmelCase							(							self						,			SCREAMING_SNAKE_CASE	) ->				int:






         """simple docstring"""






         return self.sp_model.PieceToId(SCREAMING_SNAKE_CASE	)





     def 				__lowerCAmelCase							(							self						,			SCREAMING_SNAKE_CASE	) ->				str:






         """simple docstring"""






         return self.sp_model.IdToPiece(SCREAMING_SNAKE_CASE	)





     @staticmethod
     def 				__lowerCAmelCase							(							SCREAMING_SNAKE_CASE	) ->				str:






         """simple docstring"""






         return out_string





     def 				__lowerCAmelCase							(							self						,			SCREAMING_SNAKE_CASE	) ->				str:






         """simple docstring"""






         A       :   Optional[int]					=						[]
         A       :   Optional[Any]					=						''''''
         A       :   List[str]					=						False
         for token in tokens:
             # make sure that special tokens are not decoded using sentencepiece model
             if token in self.all_special_tokens:
                 # TODO: Check if this is needed, as it ensures that decode(encode(doc)) != doc by adding extra whitespace in the decoded document
                 if not prev_is_special:
                     out_string += " "

                 out_string += self.sp_model.decode(SCREAMING_SNAKE_CASE	) + token
                 A       :   Dict					=						True
                 A       :   int					=						[]
             else:
                 current_sub_tokens.append(SCREAMING_SNAKE_CASE	)
                 A       :   List[Any]					=						False
         out_string += self.sp_model.decode(SCREAMING_SNAKE_CASE	)

         return out_string





     def 				__lowerCAmelCase							(							self	) ->				Dict[str, int]:






         """simple docstring"""






         A       :   Tuple					=						{self.convert_ids_to_tokens(SCREAMING_SNAKE_CASE	): i for i in range(self.vocab_size	)}
         vocab.update(self.added_tokens_encoder	)
         return vocab





     def 				__lowerCAmelCase							(							self						,			SCREAMING_SNAKE_CASE						,			SCREAMING_SNAKE_CASE = None	) ->				Tuple[str]:






         """simple docstring"""






         if not os.path.isdir(SCREAMING_SNAKE_CASE	):
             logger.error(F'Vocabulary path ({save_directory}) should be a directory'	)
             return
         A       :   Tuple					=						os.path.join(
             SCREAMING_SNAKE_CASE						,			(filename_prefix + '''-''' if filename_prefix else '''''') + VOCAB_FILES_NAMES['''vocab_file''']	)

         if os.path.abspath(self.vocab_file	) != os.path.abspath(SCREAMING_SNAKE_CASE	) and os.path.isfile(self.vocab_file	):
             copyfile(self.vocab_file						,			SCREAMING_SNAKE_CASE	)
         elif not os.path.isfile(self.vocab_file	):
             with open(SCREAMING_SNAKE_CASE						,			'''wb'''	) as fi:
                 A       :   List[str]					=						self.sp_model.serialized_model_proto()
                 fi.write(SCREAMING_SNAKE_CASE	)

         return (out_vocab_file,)





     def 				__lowerCAmelCase							(							self						,			SCREAMING_SNAKE_CASE						,			SCREAMING_SNAKE_CASE = False	) ->				Union[List[int], List[List[int]], "torch.Tensor"]:






         """simple docstring"""






         if isinstance(SCREAMING_SNAKE_CASE						,			SCREAMING_SNAKE_CASE	):
             A       :   List[str]					=						self.preprocess_text(SCREAMING_SNAKE_CASE	)
             A       :   Any					=						self.sp_model.encode(SCREAMING_SNAKE_CASE	)
         else:
             A       :   Any					=						[self.preprocess_text(SCREAMING_SNAKE_CASE	) for t in text]
             A       :   Optional[int]					=						self.sp_model.encode(SCREAMING_SNAKE_CASE	)

         if return_tensors is True or return_tensors == "pt":
             A       :   Union[str, Any]					=						torch.tensor(SCREAMING_SNAKE_CASE	)

         return token_ids





     def 				__lowerCAmelCase							(							self						,			SCREAMING_SNAKE_CASE	) ->				str:






         """simple docstring"""






         return self.sp_model.decode(SCREAMING_SNAKE_CASE	)





     def 				__lowerCAmelCase							(							self						,			SCREAMING_SNAKE_CASE	) ->				List[int]:






         """simple docstring"""






         A       :   int					=						[F'User: {text}' if is_user else F'Bot: {text}' for is_user, text in conversation.iter_texts()]
         A       :   Tuple					=						(
             F'{self.eos_token}{self.bos_token}' + F'{self.bos_token}'.join(SCREAMING_SNAKE_CASE	) + F'{self.bos_token}Bot:'
         )
         return self.encode(text=SCREAMING_SNAKE_CASE	)






'''simple docstring'''




import os
from pickle import UnpicklingError
from typing import Dict, Tuple

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

import transformers

from .utils import logging


lowercase			:				Dict    		=			logging.get_logger(__name__)







def 		lowerCAmelCase_				(   snake_case__		,				snake_case__		,				snake_case__		,				snake_case__=False						):




    '''simple docstring'''



    try:
        import torch  # noqa: F401
    except ImportError:
        logger.error(
            '''Loading a PyTorch model in Flax, 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

    if not is_sharded:
        A       :   Union[str, Any]					=						os.path.abspath(snake_case__						)
        logger.info(F'Loading PyTorch weights from {pt_path}'						)

        A       :   Any					=						torch.load(snake_case__		,				map_location='''cpu'''						)
        logger.info(F'PyTorch checkpoint contains {sum(t.numel() for t in pt_state_dict.values()						):,} parameters.'						)

        A       :   List[str]					=						convert_pytorch_state_dict_to_flax(snake_case__		,				snake_case__						)
    else:
        # model is sharded and pytorch_checkpoint_path already contains the list of .pt shard files
        A       :   Any					=						convert_pytorch_sharded_state_dict_to_flax(snake_case__		,				snake_case__						)
    return flax_state_dict







def 		lowerCAmelCase_				(   snake_case__		,				snake_case__		,				snake_case__		,				snake_case__		,				):




    '''simple docstring'''



    def is_key_or_prefix_key_in_dict(snake_case__						) -> bool:
        return len(set(snake_case__						) & {key, (model_prefix,) + key}						) > 0

    # layer norm
    A       :   Union[str, Any]					=						pt_tuple_key[:-1] + ('''scale''',)
    if pt_tuple_key[-1] in ["weight", "gamma"] and is_key_or_prefix_key_in_dict(snake_case__						):
        return renamed_pt_tuple_key, pt_tensor

    # batch norm layer mean
    A       :   Tuple					=						pt_tuple_key[:-1] + ('''mean''',)
    if pt_tuple_key[-1] == "running_mean" and not is_key_or_prefix_key_in_dict(snake_case__						):
        return renamed_pt_tuple_key, pt_tensor

    # batch norm layer var
    A       :   Dict					=						pt_tuple_key[:-1] + ('''var''',)
    if pt_tuple_key[-1] == "running_var" and not is_key_or_prefix_key_in_dict(snake_case__						):
        return renamed_pt_tuple_key, pt_tensor

    # embedding
    A       :   Any					=						pt_tuple_key[:-1] + ('''embedding''',)
    if pt_tuple_key[-1] == "weight" and is_key_or_prefix_key_in_dict(snake_case__						):
        return renamed_pt_tuple_key, pt_tensor

    # conv layer
    A       :   Optional[Any]					=						pt_tuple_key[:-1] + ('''kernel''',)
    if pt_tuple_key[-1] == "weight" and pt_tensor.ndim == 4 and not is_key_or_prefix_key_in_dict(snake_case__						):
        A       :   List[Any]					=						pt_tensor.transpose(2		,				3		,				1		,				0						)
        return renamed_pt_tuple_key, pt_tensor

    # linear layer
    A       :   Optional[int]					=						pt_tuple_key[:-1] + ('''kernel''',)
    if pt_tuple_key[-1] == "weight" and not is_key_or_prefix_key_in_dict(snake_case__						):
        A       :   str					=						pt_tensor.T
        return renamed_pt_tuple_key, pt_tensor

    # old PyTorch layer norm weight
    A       :   Dict					=						pt_tuple_key[:-1] + ('''weight''',)
    if pt_tuple_key[-1] == "gamma":
        return renamed_pt_tuple_key, pt_tensor

    # old PyTorch layer norm bias
    A       :   List[Any]					=						pt_tuple_key[:-1] + ('''bias''',)
    if pt_tuple_key[-1] == "beta":
        return renamed_pt_tuple_key, pt_tensor

    # New `weight_norm` from https://github.com/huggingface/transformers/pull/24030
    A       :   Dict					=						None
    if pt_tuple_key[-3::2] == ("parametrizations", "original0"):
        A       :   List[Any]					=						pt_tuple_key[-2] + '''_g'''
    elif pt_tuple_key[-3::2] == ("parametrizations", "original1"):
        A       :   List[str]					=						pt_tuple_key[-2] + '''_v'''
    if name is not None:
        A       :   int					=						pt_tuple_key[:-3] + (name,)
        return renamed_pt_tuple_key, pt_tensor

    return pt_tuple_key, pt_tensor







def 		lowerCAmelCase_				(   snake_case__		,				snake_case__						):




    '''simple docstring'''



    A       :   Dict					=						{k: v.numpy() for k, v in pt_state_dict.items()}

    A       :   int					=						flax_model.base_model_prefix

    # use params dict if the model contains batch norm layers
    if "params" in flax_model.params:
        A       :   List[str]					=						flax_model.params['''params''']
    else:
        A       :   Dict					=						flax_model.params
    A       :   List[Any]					=						flatten_dict(snake_case__						)

    # add batch_stats keys,values to dict
    if "batch_stats" in flax_model.params:
        A       :   List[str]					=						flatten_dict(flax_model.params['''batch_stats''']						)
        random_flax_state_dict.update(snake_case__						)

    A       :   int					=						{}

    A       :   List[str]					=						(model_prefix not in flax_model_params) and (
        model_prefix in {k.split('''.'''						)[0] for k in pt_state_dict.keys()}
    )
    A       :   int					=						(model_prefix in flax_model_params) and (
        model_prefix not in {k.split('''.'''						)[0] for k in pt_state_dict.keys()}
    )

    # Need to change some parameters name to match Flax names
    for pt_key, pt_tensor in pt_state_dict.items():
        A       :   str					=						tuple(pt_key.split('''.'''						)						)

        # remove base model prefix if necessary
        A       :   Union[str, Any]					=						pt_tuple_key[0] == model_prefix
        if load_model_with_head_into_base_model and has_base_model_prefix:
            A       :   Any					=						pt_tuple_key[1:]

        # Correctly rename weight parameters
        A,  A       :   Dict					=						rename_key_and_reshape_tensor(
            snake_case__		,				snake_case__		,				snake_case__		,				snake_case__						)

        # add model prefix if necessary
        A       :   Any					=						(model_prefix,) + flax_key in random_flax_state_dict
        if load_base_model_into_model_with_head and require_base_model_prefix:
            A       :   int					=						(model_prefix,) + flax_key

        if flax_key in random_flax_state_dict:
            if flax_tensor.shape != random_flax_state_dict[flax_key].shape:
                raise ValueError(
                    F'PyTorch checkpoint seems to be incorrect. Weight {pt_key} was expected to be of shape '
                    F'{random_flax_state_dict[flax_key].shape}, but is {flax_tensor.shape}.'						)

        # add batch stats if the model contains batchnorm layers
        if "batch_stats" in flax_model.params:
            if "mean" in flax_key[-1] or "var" in flax_key[-1]:
                A       :   Tuple					=						jnp.asarray(snake_case__						)
                continue
            # remove num_batches_tracked key
            if "num_batches_tracked" in flax_key[-1]:
                flax_state_dict.pop(snake_case__		,				snake_case__						)
                continue

            # also add unexpected weight so that warning is thrown
            A       :   List[str]					=						jnp.asarray(snake_case__						)

        else:
            # also add unexpected weight so that warning is thrown
            A       :   Optional[Any]					=						jnp.asarray(snake_case__						)

    return unflatten_dict(snake_case__						)







def 		lowerCAmelCase_				(   snake_case__		,				snake_case__						):




    '''simple docstring'''



    import torch

    # Load the index
    A       :   Union[str, Any]					=						{}
    for shard_file in shard_filenames:
        # load using msgpack utils
        A       :   List[str]					=						torch.load(snake_case__						)
        A       :   int					=						{k: v.numpy() for k, v in pt_state_dict.items()}

        A       :   Tuple					=						flax_model.base_model_prefix

        # use params dict if the model contains batch norm layers and then add batch_stats keys,values to dict
        if "batch_stats" in flax_model.params:
            A       :   Optional[int]					=						flax_model.params['''params''']

            A       :   List[Any]					=						flatten_dict(snake_case__						)
            random_flax_state_dict.update(flatten_dict(flax_model.params['''batch_stats''']						)						)
        else:
            A       :   Dict					=						flax_model.params
            A       :   Tuple					=						flatten_dict(snake_case__						)

        A       :   List[str]					=						(model_prefix not in flax_model_params) and (
            model_prefix in {k.split('''.'''						)[0] for k in pt_state_dict.keys()}
        )
        A       :   List[str]					=						(model_prefix in flax_model_params) and (
            model_prefix not in {k.split('''.'''						)[0] for k in pt_state_dict.keys()}
        )
        # Need to change some parameters name to match Flax names
        for pt_key, pt_tensor in pt_state_dict.items():
            A       :   int					=						tuple(pt_key.split('''.'''						)						)

            # remove base model prefix if necessary
            A       :   List[str]					=						pt_tuple_key[0] == model_prefix
            if load_model_with_head_into_base_model and has_base_model_prefix:
                A       :   Union[str, Any]					=						pt_tuple_key[1:]

            # Correctly rename weight parameters
            A,  A       :   Any					=						rename_key_and_reshape_tensor(
                snake_case__		,				snake_case__		,				snake_case__		,				snake_case__						)
            # add model prefix if necessary
            A       :   int					=						(model_prefix,) + flax_key in random_flax_state_dict
            if load_base_model_into_model_with_head and require_base_model_prefix:
                A       :   int					=						(model_prefix,) + flax_key

            if flax_key in random_flax_state_dict:
                if flax_tensor.shape != random_flax_state_dict[flax_key].shape:
                    raise ValueError(
                        F'PyTorch checkpoint seems to be incorrect. Weight {pt_key} was expected to be of shape '
                        F'{random_flax_state_dict[flax_key].shape}, but is {flax_tensor.shape}.'						)

            # add batch stats if the model contains batchnorm layers
            if "batch_stats" in flax_model.params:
                if "mean" in flax_key[-1]:
                    A       :   Optional[int]					=						jnp.asarray(snake_case__						)
                    continue
                if "var" in flax_key[-1]:
                    A       :   Optional[int]					=						jnp.asarray(snake_case__						)
                    continue
                # remove num_batches_tracked key
                if "num_batches_tracked" in flax_key[-1]:
                    flax_state_dict.pop(snake_case__		,				snake_case__						)
                    continue

                # also add unexpected weight so that warning is thrown
                A       :   Optional[Any]					=						jnp.asarray(snake_case__						)

            else:
                # also add unexpected weight so that warning is thrown
                A       :   Optional[Any]					=						jnp.asarray(snake_case__						)
    return unflatten_dict(snake_case__						)







def 		lowerCAmelCase_				(   snake_case__		,				snake_case__						):




    '''simple docstring'''



    A       :   Dict					=						os.path.abspath(snake_case__						)
    logger.info(F'Loading Flax weights from {flax_checkpoint_path}'						)

    # import correct flax class
    A       :   List[str]					=						getattr(snake_case__		,				'''Flax''' + model.__class__.__name__						)

    # load flax weight dict
    with open(snake_case__		,				'''rb'''						) as state_f:
        try:
            A       :   int					=						from_bytes(snake_case__		,				state_f.read()						)
        except UnpicklingError:
            raise EnvironmentError(F'Unable to convert {flax_checkpoint_path} to Flax deserializable object. '						)

    return load_flax_weights_in_pytorch_model(snake_case__		,				snake_case__						)







def 		lowerCAmelCase_				(   snake_case__		,				snake_case__						):




    '''simple docstring'''



    try:
        import torch  # noqa: F401
    except ImportError:
        logger.error(
            '''Loading a 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
    A       :   List[str]					=						flatten_dict(jax.tree_util.tree_map(lambda snake_case__						: x.dtype == jnp.bfloataa		,				snake_case__						)						).values()
    if any(snake_case__						):
        # convert all weights to fp32 if the 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.'''						)
        A       :   Optional[Any]					=						jax.tree_util.tree_map(
            lambda snake_case__						: params.astype(np.floataa						) if params.dtype == jnp.bfloataa else params		,				snake_case__						)

    A       :   Union[str, Any]					=						flatten_dict(snake_case__						)
    A       :   List[Any]					=						pt_model.state_dict()

    A       :   Union[str, Any]					=						(pt_model.base_model_prefix in flax_state) and (
        pt_model.base_model_prefix not in {k.split('''.'''						)[0] for k in pt_model_dict.keys()}
    )
    A       :   Tuple					=						(pt_model.base_model_prefix not in flax_state) and (
        pt_model.base_model_prefix in {k.split('''.'''						)[0] for k in pt_model_dict.keys()}
    )

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

    for flax_key_tuple, flax_tensor in flax_state_dict.items():
        A       :   Union[str, Any]					=						flax_key_tuple[0] == pt_model.base_model_prefix
        A       :   int					=						'''.'''.join((pt_model.base_model_prefix,) + flax_key_tuple						) in pt_model_dict

        # adapt flax_key to prepare for loading from/to base model only
        if load_model_with_head_into_base_model and has_base_model_prefix:
            A       :   List[str]					=						flax_key_tuple[1:]
        elif load_base_model_into_model_with_head and require_base_model_prefix:
            A       :   Optional[Any]					=						(pt_model.base_model_prefix,) + flax_key_tuple

        # rename flax weights to PyTorch format
        if flax_key_tuple[-1] == "kernel" and flax_tensor.ndim == 4 and ".".join(snake_case__						) not in pt_model_dict:
            # conv layer
            A       :   Optional[int]					=						flax_key_tuple[:-1] + ('''weight''',)
            A       :   Optional[int]					=						jnp.transpose(snake_case__		,				(3, 2, 0, 1)						)
        elif flax_key_tuple[-1] == "kernel" and ".".join(snake_case__						) not in pt_model_dict:
            # linear layer
            A       :   Tuple					=						flax_key_tuple[:-1] + ('''weight''',)
            A       :   Tuple					=						flax_tensor.T
        elif flax_key_tuple[-1] in ["scale", "embedding"]:
            A       :   Optional[int]					=						flax_key_tuple[:-1] + ('''weight''',)

        # adding batch stats from flax batch norm to pt
        elif "mean" in flax_key_tuple[-1]:
            A       :   Tuple					=						flax_key_tuple[:-1] + ('''running_mean''',)
        elif "var" in flax_key_tuple[-1]:
            A       :   Tuple					=						flax_key_tuple[:-1] + ('''running_var''',)

        if "batch_stats" in flax_state:
            A       :   List[Any]					=						'''.'''.join(flax_key_tuple[1:]						)  # Remove the params/batch_stats header
        else:
            A       :   Union[str, Any]					=						'''.'''.join(snake_case__						)

        # We also need to look at `pt_model_dict` and see if there are keys requiring further transformation.
        A       :   int					=						{}
        # New `weight_norm` from https://github.com/huggingface/transformers/pull/24030
        for key in pt_model_dict:
            A       :   Optional[int]					=						key.split('''.'''						)
            A       :   Dict					=						None
            if key_components[-3::2] == ["parametrizations", "original0"]:
                A       :   List[str]					=						key_components[-2] + '''_g'''
            elif key_components[-3::2] == ["parametrizations", "original1"]:
                A       :   List[Any]					=						key_components[-2] + '''_v'''
            if name is not None:
                A       :   str					=						key_components[:-3] + [name]
                A       :   Optional[Any]					=						'''.'''.join(snake_case__						)
                A       :   Optional[Any]					=						key

        if flax_key in special_pt_names:
            A       :   Optional[Any]					=						special_pt_names[flax_key]

        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
                A       :   Dict					=						np.asarray(snake_case__						) if not isinstance(snake_case__		,				np.ndarray						) else flax_tensor
                A       :   Dict					=						torch.from_numpy(snake_case__						)
                # remove from missing keys
                missing_keys.remove(snake_case__						)
        else:
            # weight is not expected by PyTorch model
            unexpected_keys.append(snake_case__						)

    pt_model.load_state_dict(snake_case__						)

    # re-transform missing_keys to list
    A       :   List[Any]					=						list(snake_case__						)

    if len(snake_case__						) > 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).'''						)
    else:
        logger.warning(F'All Flax model weights were used when initializing {pt_model.__class__.__name__}.\n'						)
    if len(snake_case__						) > 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.'''						)
    else:
        logger.warning(
            F'All the weights of {pt_model.__class__.__name__} were initialized from the Flax model.\n'
            '''If your task is similar to the task the model of the checkpoint was trained on, '''
            F'you can already use {pt_model.__class__.__name__} for predictions without further training.'						)

    return pt_model




