





from collections import OrderedDict
from typing import TYPE_CHECKING, Any, Mapping, Optional, Union

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig, OnnxSeqaSeqConfigWithPast
from ...utils import logging


if TYPE_CHECKING:
      from ...feature_extraction_utils import FeatureExtractionMixin
      from ...tokenization_utils_base import PreTrainedTokenizerBase
      from ...utils import TensorType

snake_case								=							logging.get_logger(__name__)

snake_case								=							{
    """openai/whisper-base""": """https://huggingface.co/openai/whisper-base/resolve/main/config.json""",
}

# fmt: off
snake_case								=							[
    1, 2, 7, 8, 9, 1_0, 1_4, 2_5,
    2_6, 2_7, 2_8, 2_9, 3_1, 5_8, 5_9, 6_0, 6_1, 6_2,
    6_3, 9_0, 9_1, 9_2, 9_3, 3_5_7, 3_6_6, 4_3_8, 5_3_2, 6_8_5,
    7_0_5, 7_9_6, 9_3_0, 1_0_5_8, 1_2_2_0, 1_2_6_7, 1_2_7_9, 1_3_0_3, 1_3_4_3, 1_3_7_7,
    1_3_9_1, 1_6_3_5, 1_7_8_2, 1_8_7_5, 2_1_6_2, 2_3_6_1, 2_4_8_8, 3_4_6_7, 4_0_0_8, 4_2_1_1,
    4_6_0_0, 4_8_0_8, 5_2_9_9, 5_8_5_5, 6_3_2_9, 7_2_0_3, 9_6_0_9, 9_9_5_9, 1_0_5_6_3, 1_0_7_8_6,
    1_1_4_2_0, 1_1_7_0_9, 1_1_9_0_7, 1_3_1_6_3, 1_3_6_9_7, 1_3_7_0_0, 1_4_8_0_8, 1_5_3_0_6, 1_6_4_1_0, 1_6_7_9_1,
    1_7_9_9_2, 1_9_2_0_3, 1_9_5_1_0, 2_0_7_2_4, 2_2_3_0_5, 2_2_9_3_5, 2_7_0_0_7, 3_0_1_0_9, 3_0_4_2_0, 3_3_4_0_9,
    3_4_9_4_9, 4_0_2_8_3, 4_0_4_9_3, 4_0_5_4_9, 4_7_2_8_2, 4_9_1_4_6, 5_0_2_5_7, 5_0_3_5_9, 5_0_3_6_0, 5_0_3_6_1
]
snake_case								=							[
    1, 2, 7, 8, 9, 1_0, 1_4, 2_5,
    2_6, 2_7, 2_8, 2_9, 3_1, 5_8, 5_9, 6_0, 6_1, 6_2,
    6_3, 9_0, 9_1, 9_2, 9_3, 3_5_9, 5_0_3, 5_2_2, 5_4_2, 8_7_3,
    8_9_3, 9_0_2, 9_1_8, 9_2_2, 9_3_1, 1_3_5_0, 1_8_5_3, 1_9_8_2, 2_4_6_0, 2_6_2_7,
    3_2_4_6, 3_2_5_3, 3_2_6_8, 3_5_3_6, 3_8_4_6, 3_9_6_1, 4_1_8_3, 4_6_6_7, 6_5_8_5, 6_6_4_7,
    7_2_7_3, 9_0_6_1, 9_3_8_3, 1_0_4_2_8, 1_0_9_2_9, 1_1_9_3_8, 1_2_0_3_3, 1_2_3_3_1, 1_2_5_6_2, 1_3_7_9_3,
    1_4_1_5_7, 1_4_6_3_5, 1_5_2_6_5, 1_5_6_1_8, 1_6_5_5_3, 1_6_6_0_4, 1_8_3_6_2, 1_8_9_5_6, 2_0_0_7_5, 2_1_6_7_5,
    2_2_5_2_0, 2_6_1_3_0, 2_6_1_6_1, 2_6_4_3_5, 2_8_2_7_9, 2_9_4_6_4, 3_1_6_5_0, 3_2_3_0_2, 3_2_4_7_0, 3_6_8_6_5,
    4_2_8_6_3, 4_7_4_2_5, 4_9_8_7_0, 5_0_2_5_4, 5_0_2_5_8, 5_0_3_6_0, 5_0_3_6_1, 5_0_3_6_2
]





class 					A_					(   UpperCAmelCase						):







       """simple docstring"""





       SCREAMING_SNAKE_CASE_   :			int  			=	'''whisper'''
       SCREAMING_SNAKE_CASE_   :			str  			=	['''past_key_values''']
       SCREAMING_SNAKE_CASE_   :			Any  			=	{'''num_attention_heads''': '''encoder_attention_heads''', '''hidden_size''': '''d_model'''}







       def __init__(     self						:						int    ,__A						:						Dict=5_1865    ,__A						:						List[str]=80    ,__A						:						str=6    ,__A						:						List[str]=4    ,__A						:						int=6    ,__A						:						Optional[Any]=4    ,__A						:						int=1536    ,__A						:						List[str]=1536    ,__A						:						Optional[Any]=0.0    ,__A						:						Union[str, Any]=0.0    ,__A						:						int=5_0257    ,__A						:						Dict=True    ,__A						:						int=True    ,__A						:						int="gelu"    ,__A						:						Union[str, Any]=256    ,__A						:						Optional[int]=0.0    ,__A						:						Any=0.0    ,__A						:						Optional[int]=0.0    ,__A						:						List[Any]=0.02    ,__A						:						Optional[int]=False    ,__A						:						int=1500    ,__A						:						Union[str, Any]=448    ,__A						:						Optional[Any]=5_0256    ,__A						:						List[str]=5_0256    ,__A						:						Dict=5_0256    ,__A						:						int=None    ,__A						:						Optional[Any]=[220, 5_0256]    ,__A						:						Optional[Any]=False    ,__A						:						Dict=256    ,__A						:						Tuple=False    ,__A						:						Union[str, Any]=0.05    ,__A						:						Optional[Any]=10    ,__A						:						int=2    ,__A						:						Optional[int]=0.0    ,__A						:						Optional[int]=10    ,__A						:						Any=0    ,__A						:						Optional[int]=7    ,**__A						:						str    ,)    ->       List[Any]:
         _lowercase						    =			vocab_size
         _lowercase						    =			num_mel_bins
         _lowercase						    =			d_model
         _lowercase						    =			encoder_layers
         _lowercase						    =			encoder_attention_heads
         _lowercase						    =			decoder_layers
         _lowercase						    =			decoder_attention_heads
         _lowercase						    =			decoder_ffn_dim
         _lowercase						    =			encoder_ffn_dim
         _lowercase						    =			dropout
         _lowercase						    =			attention_dropout
         _lowercase						    =			activation_dropout
         _lowercase						    =			activation_function
         _lowercase						    =			init_std
         _lowercase						    =			encoder_layerdrop
         _lowercase						    =			decoder_layerdrop
         _lowercase						    =			use_cache
         _lowercase						    =			encoder_layers
         _lowercase						    =			scale_embedding  # scale factor will be sqrt(d_model) if True
         _lowercase						    =			max_source_positions
         _lowercase						    =			max_target_positions

         # Audio Classification-specific parameters. Feel free to ignore for other classes.
         _lowercase						    =			classifier_proj_size
         _lowercase						    =			use_weighted_layer_sum

         # fine-tuning config parameters for SpecAugment: https://arxiv.org/abs/1904.08779
         _lowercase						    =			apply_spec_augment
         _lowercase						    =			mask_time_prob
         _lowercase						    =			mask_time_length
         _lowercase						    =			mask_time_min_masks
         _lowercase						    =			mask_feature_prob
         _lowercase						    =			mask_feature_length
         _lowercase						    =			mask_feature_min_masks

         _lowercase						    =			median_filter_width

         super().__init__(
             pad_token_id=__A    ,bos_token_id=__A    ,eos_token_id=__A    ,is_encoder_decoder=__A    ,decoder_start_token_id=__A    ,suppress_tokens=__A    ,begin_suppress_tokens=__A    ,**__A    ,)





class 					A_					(   UpperCAmelCase						):







       """simple docstring"""





       @property
       def  __UpperCAmelCase			(     self						:						int	)    ->       Mapping[str, Mapping[int, str]]:
         _lowercase						    =			OrderedDict(
             [
                 ('input_features', {0: 'batch', 1: 'feature_size', 2: 'encoder_sequence'}),
             ]	)
         if self.use_past:
           _lowercase						    =			{0: 'batch'}
         else:
           _lowercase						    =			{0: 'batch', 1: 'decoder_sequence'}

         if self.use_past:
           self.fill_with_past_key_values_(__A    ,direction='inputs'	)

         return common_inputs







       def  __UpperCAmelCase			(     self						:						Tuple    ,__A						:						Union["PreTrainedTokenizerBase", "FeatureExtractionMixin"]    ,__A						:						int = -1    ,__A						:						int = -1    ,__A						:						bool = False    ,__A						:						Optional["TensorType"] = None    ,__A						:						int = 2_2050    ,__A						:						float = 5.0    ,__A						:						int = 220    ,)    ->       Mapping[str, Any]:
         _lowercase						    =			OrderedDict()
         _lowercase						    =			OnnxConfig.generate_dummy_inputs(
             self    ,preprocessor=preprocessor.feature_extractor    ,batch_size=__A    ,framework=__A    ,sampling_rate=__A    ,time_duration=__A    ,frequency=__A    ,)
         _lowercase						    =			encoder_inputs['input_features'].shape[2]
         _lowercase						    =			encoder_sequence_length // 2 if self.use_past else seq_length

         _lowercase						    =			super().generate_dummy_inputs(
             preprocessor.tokenizer    ,__A    ,__A    ,__A    ,__A	)

         _lowercase						    =			encoder_inputs.pop('input_features'	)
         _lowercase						    =			decoder_inputs.pop('decoder_input_ids'	)

         if "past_key_values" in decoder_inputs:
           _lowercase						    =			decoder_inputs.pop('past_key_values'	)

         return dummy_inputs







       @property
       def  __UpperCAmelCase			(     self						:						Union[str, Any]	)    ->       float:
         return 1e-3




'''simple docstring'''





import argparse
import re

from flax.traverse_util import flatten_dict, unflatten_dict
from tax import checkpoints

from transformers import SwitchTransformersConfig, SwitchTransformersForConditionalGeneration
from transformers.modeling_flax_pytorch_utils import load_flax_weights_in_pytorch_model
from transformers.utils import logging


logging.set_verbosity_info()


# should not include what is already done by the `from_pt` argument
lowercase_									=    {
    "/attention/": "/0/SelfAttention/",
    "/self_attention/": "/0/SelfAttention/",
    "/encoder_decoder_attention/": "/1/EncDecAttention/",
    "value": "v",
    "query": "q",
    "key": "k",
    "out": "o",
    "pre_self_attention_layer_norm": "0/layer_norm",
    "pre_cross_attention_layer_norm": "1/layer_norm",
    "pre_attention_layer_norm": "0/layer_norm",  # previously 1, but seems wrong
    "token_embedder": "shared",
    "encoder_norm": "final_layer_norm",
    "decoder_norm": "final_layer_norm",
    "relpos_bias/rel_embedding": "block/0/layer/0/SelfAttention/relative_attention_bias/weight",
    "router/router_weights/w/": "router/classifier/",
    "roer/roer_weights/w/": "router/classifier/",
    "logits_dense": "lm_head",
}




def lowerCAmelCase    (__A):



     """simple docstring"""



     _a           =    list(s_dict.keys())
     for key in keys:
          _a           =    r'''.*/layers_(\d+)'''
          _a           =    key
          if re.match(__A    ,      __A):
               _a           =    re.sub(r'''layers_(\d+)'''    ,      r'''block/\1/layer'''    ,      __A)

          _a           =    r'''(encoder|decoder)\/'''

          if re.match(__A    ,      __A):
               _a           =    re.match(__A    ,      __A).groups()
               if groups[0] == "encoder":
                    _a           =    re.sub(r'''/mlp/'''    ,      r'''/1/mlp/'''    ,      __A)
                    _a           =    re.sub(r'''/pre_mlp_layer_norm/'''    ,      r'''/1/layer_norm/'''    ,      __A)

               elif groups[0] == "decoder":
                    _a           =    re.sub(r'''/mlp/'''    ,      r'''/2/mlp/'''    ,      __A)
                    _a           =    re.sub(r'''/pre_mlp_layer_norm/'''    ,      r'''/2/layer_norm/'''    ,      __A)

        # 2. Convert other classic mappings
          for old_key, temp_key in MOE_LAYER_NAME_MAPPING.items():
               if old_key in new_key:
                    _a           =    new_key.replace(__A    ,      __A)

          print(F'''{key} -> {new_key}''')
          _a           =    s_dict.pop(__A)

     if "encoder/block/0/layer/0/SelfAttention/relative_attention_bias/weight" in s_dict:
          _a           =    s_dict[
              '''encoder/block/0/layer/0/SelfAttention/relative_attention_bias/weight'''
          ].T
     if "decoder/block/0/layer/0/SelfAttention/relative_attention_bias/weight" in s_dict:
          _a           =    s_dict[
              '''decoder/block/0/layer/0/SelfAttention/relative_attention_bias/weight'''
          ].T

     # 3. Take extra care of the EXPERTS layer
     for key in list(s_dict.keys()):
          if "expert" in key:
               _a           =    s_dict[key].shape[0]
               _a           =    s_dict[key]
               for idx in range(__A):
                    _a           =    expert_weihts[idx]
                    print(F'''{key} -> {key.replace('expert/'    ,      'nested fstring')}''')

               s_dict.pop(__A)

     return s_dict


lowercase_									=    {
    "NUM_ENCODER_LAYERS": "num_layers",
    "NUM_DECODER_LAYERS": "num_decoder_layers",
    "NUM_HEADS": "num_heads",
    "HEAD_DIM": "d_kv",
    "EMBED_DIM": "d_model",
    "MLP_DIM": "d_ff",
    "NUM_SELECTED_EXPERTS": "num_selected_experts",
    "NUM_ENCODER_SPARSE_LAYERS": "num_sparse_encoder_layers",
    "NUM_DECODER_SPARSE_LAYERS": "num_sparse_decoder_layers",
    "dense.MlpBlock.activations": "feed_forward_proj",
}




def lowerCAmelCase    (__A    ,      __A):



     """simple docstring"""



     import regex as re

     with open(__A    ,      '''r''') as f:
          _a           =    f.read()

     _a           =    re.findall(r'''(.*) = ([0-9.]*)'''    ,      __A)
     _a           =    {}
     for param, value in regex_match:
          if param in GIN_TO_CONFIG_MAPPING and value != "":
               _a           =    float(__A) if '''.''' in value else int(__A)

     _a           =    re.findall(r'''(.*activations) = \(\'(.*)\',\)'''    ,      __A)[0]
     _a           =    str(activation[1])

     _a           =    num_experts
     _a           =    SwitchTransformersConfig(**__A)
     return config




def lowerCAmelCase    (__A    ,      __A    ,      __A=None    ,      __A="./"    ,      __A=8):



     """simple docstring"""



     print(F'''Loading flax weights from : {flax_checkpoint_path}''')
     _a           =    checkpoints.load_tax_checkpoint(__A)

     if gin_file is not None:
          _a           =    convert_gin_to_config(__A    ,      __A)
     else:
          _a           =    SwitchTransformersConfig.from_pretrained(__A)

     _a           =    SwitchTransformersForConditionalGeneration(__A)

     _a           =    flax_params['''target''']
     _a           =    flatten_dict(__A    ,      sep='''/''')
     _a           =    rename_keys(__A)
     _a           =    unflatten_dict(__A    ,      sep='''/''')

     # Load the flax params in the PT model
     load_flax_weights_in_pytorch_model(__A    ,      __A)

     print(F'''Save PyTorch model to {pytorch_dump_path}''')
     pt_model.save_pretrained(__A)


if __name__ == "__main__":
  lowercase_									=    argparse.ArgumentParser()
  # Required parameters
  parser.add_argument(
      "--switch_t5x_checkpoint_path",
      default=None,
      type=str,
      required=True,
      help=(
          "The config json file corresponding to the pre-trained SwitchTransformers model. \nThis specifies the"
          " model architecture. If not provided, a `gin_file` has to be provided."
      ),
  )
  parser.add_argument(
      "--gin_file",
      default=None,
      type=str,
      required=False,
      help="Path to the gin config file. If not provided, a `config_file` has to be passed   ",
  )
  parser.add_argument(
      "--config_name", default=None, type=str, required=False, help="Config name of SwitchTransformers model."
  )
  parser.add_argument(
      "--pytorch_dump_folder_path", default=None, type=str, required=True, help="Path to the output pytorch model."
  )
  parser.add_argument("--num_experts", default=8, type=int, required=False, help="Number of experts")
  lowercase_									=    parser.parse_args()
  convert_flax_checkpoint_to_pytorch(
      args.switch_tax_checkpoint_path,
      args.config_name,
      args.gin_file,
      args.pytorch_dump_folder_path,
      args.num_experts,
  )



