


import argparse
import json
import os

import fairseq
import torch
from torch import nn

from transformers import (
    SpeechaTextaConfig,
    SpeechaTextaForCausalLM,
    SpeechaTextaTokenizer,
    SpeechEncoderDecoderConfig,
    SpeechEncoderDecoderModel,
    WavaVecaConfig,
    WavaVecaFeatureExtractor,
    WavaVecaModel,
    logging,
)


logging.set_verbosity_info()
_A			=						logging.get_logger(__name__)

_A			=						{
    'post_extract_proj': 'feature_projection.projection',
    'encoder.pos_conv.0': 'encoder.pos_conv_embed.conv',
    'self_attn.k_proj': 'encoder.layers.*.attention.k_proj',
    'self_attn.v_proj': 'encoder.layers.*.attention.v_proj',
    'self_attn.q_proj': 'encoder.layers.*.attention.q_proj',
    'self_attn.out_proj': 'encoder.layers.*.attention.out_proj',
    'self_attn_layer_norm': 'encoder.layers.*.layer_norm',
    'fc1': 'encoder.layers.*.feed_forward.intermediate_dense',
    'fc2': 'encoder.layers.*.feed_forward.output_dense',
    'final_layer_norm': 'encoder.layers.*.final_layer_norm',
    'encoder.layer_norm': 'encoder.layer_norm',
    'w2v_model.layer_norm': 'feature_projection.layer_norm',
    'quantizer.weight_proj': 'quantizer.weight_proj',
    'quantizer.vars': 'quantizer.codevectors',
    'project_q': 'project_q',
    'final_proj': 'project_hid',
    'w2v_encoder.proj': 'lm_head',
    'mask_emb': 'masked_spec_embed',
}
_A			=						[
    'lm_head',
    'quantizer.weight_proj',
    'quantizer.codevectors',
    'project_q',
    'project_hid',
]

def 						_UpperCAmelCase    (      SCREAMING_SNAKE_CASE__      : List[Any]      ,					SCREAMING_SNAKE_CASE__      : Optional[int]      ,					SCREAMING_SNAKE_CASE__      : Dict      ,					SCREAMING_SNAKE_CASE__      : Optional[int]      ,					SCREAMING_SNAKE_CASE__      : List[Any]    ):
     for attribute in key.split('.'    ):
          __UpperCamelCase   							=getattr(SCREAMING_SNAKE_CASE__      ,					SCREAMING_SNAKE_CASE__    )

     if weight_type is not None:
          __UpperCamelCase   							=getattr(SCREAMING_SNAKE_CASE__      ,					SCREAMING_SNAKE_CASE__    ).shape
     else:
          __UpperCamelCase   							=hf_pointer.shape

     assert hf_shape == value.shape, (
         F'Shape of hf {key + "." + weight_type if weight_type is not None else ""} is {hf_shape}, but should be'
         F' {value.shape} for {full_name}'
     )

     if weight_type == "weight":
          __UpperCamelCase   							=value
     elif weight_type == "weight_g":
          __UpperCamelCase   							=value
     elif weight_type == "weight_v":
          __UpperCamelCase   							=value
     elif weight_type == "bias":
          __UpperCamelCase   							=value
     else:
          __UpperCamelCase   							=value

     logger.info(F'{key + "." + weight_type if weight_type is not None else ""} was initialized from {full_name}.'    )

def 						_UpperCAmelCase    (      SCREAMING_SNAKE_CASE__      : Any      ,					SCREAMING_SNAKE_CASE__      : Optional[int]    ):
     __UpperCamelCase   							=[]
     __UpperCamelCase   							=fairseq_model.state_dict()

     __UpperCamelCase   							=hf_model.feature_extractor

     # if encoder has different dim to decoder -> use proj_weight
     __UpperCamelCase   							=None

     for name, value in fairseq_dict.items():
          __UpperCamelCase   							=False
          if "conv_layers" in name:
               load_conv_layer(
                   SCREAMING_SNAKE_CASE__      ,					SCREAMING_SNAKE_CASE__      ,					SCREAMING_SNAKE_CASE__      ,					SCREAMING_SNAKE_CASE__      ,					hf_model.config.feat_extract_norm == 'group'      ,					)
               __UpperCamelCase   							=True
          elif name.split('.'    )[0] == "proj":
               __UpperCamelCase   							=fairseq_model.proj
               __UpperCamelCase   							=True
          else:
               for key, mapped_key in MAPPING.items():
                    if key in name or key.split('w2v_model.'    )[-1] == name.split('.'    )[0]:
                         __UpperCamelCase   							=True
                         if "*" in mapped_key:
                              __UpperCamelCase   							=name.split(SCREAMING_SNAKE_CASE__    )[0].split('.'    )[-2]
                              __UpperCamelCase   							=mapped_key.replace('*'      ,					SCREAMING_SNAKE_CASE__    )
                         if "weight_g" in name:
                              __UpperCamelCase   							='weight_g'
                         elif "weight_v" in name:
                              __UpperCamelCase   							='weight_v'
                         elif "bias" in name:
                              __UpperCamelCase   							='bias'
                         elif "weight" in name:
                              __UpperCamelCase   							='weight'
                         else:
                              __UpperCamelCase   							=None
                         set_recursively(SCREAMING_SNAKE_CASE__      ,					SCREAMING_SNAKE_CASE__      ,					SCREAMING_SNAKE_CASE__      ,					SCREAMING_SNAKE_CASE__      ,					SCREAMING_SNAKE_CASE__    )
                    continue
          if not is_used:
               unused_weights.append(SCREAMING_SNAKE_CASE__    )

     logger.warning(F'Unused weights: {unused_weights}'    )

     return proj_weight

def 						_UpperCAmelCase    (      SCREAMING_SNAKE_CASE__      : Dict      ,					SCREAMING_SNAKE_CASE__      : List[Any]      ,					SCREAMING_SNAKE_CASE__      : Union[str, Any]      ,					SCREAMING_SNAKE_CASE__      : Tuple      ,					SCREAMING_SNAKE_CASE__      : Dict    ):
     __UpperCamelCase   							=full_name.split('conv_layers.'    )[-1]
     __UpperCamelCase   							=name.split('.'    )
     __UpperCamelCase   							=int(items[0]    )
     __UpperCamelCase   							=int(items[1]    )

     if type_id == 0:
          if "bias" in name:
               assert value.shape == feature_extractor.conv_layers[layer_id].conv.bias.data.shape, (
                   F'{full_name} has size {value.shape}, but'
                   F' {feature_extractor.conv_layers[layer_id].conv.bias.data.shape} was found.'
               )
               __UpperCamelCase   							=value
               logger.info(F'Feat extract conv layer {layer_id} was initialized from {full_name}.'    )
          elif "weight" in name:
               assert value.shape == feature_extractor.conv_layers[layer_id].conv.weight.data.shape, (
                   F'{full_name} has size {value.shape}, but'
                   F' {feature_extractor.conv_layers[layer_id].conv.weight.data.shape} was found.'
               )
               __UpperCamelCase   							=value
               logger.info(F'Feat extract conv layer {layer_id} was initialized from {full_name}.'    )
     elif (type_id == 2 and not use_group_norm) or (type_id == 2 and layer_id == 0 and use_group_norm):
          if "bias" in name:
               assert value.shape == feature_extractor.conv_layers[layer_id].layer_norm.bias.data.shape, (
                   F'{full_name} has size {value.shape}, but {feature_extractor[layer_id].layer_norm.bias.data.shape} was'
                   " found."
               )
               __UpperCamelCase   							=value
               logger.info(F'Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}.'    )
          elif "weight" in name:
               assert value.shape == feature_extractor.conv_layers[layer_id].layer_norm.weight.data.shape, (
                   F'{full_name} has size {value.shape}, but'
                   F' {feature_extractor[layer_id].layer_norm.weight.data.shape} was found.'
               )
               __UpperCamelCase   							=value
               logger.info(F'Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}.'    )
     else:
          unused_weights.append(SCREAMING_SNAKE_CASE__    )

def 						_UpperCAmelCase    (      SCREAMING_SNAKE_CASE__      : Tuple    ):
     __UpperCamelCase							,				__UpperCamelCase   							=emb.weight.shape
     __UpperCamelCase   							=nn.Linear(SCREAMING_SNAKE_CASE__      ,					SCREAMING_SNAKE_CASE__      ,					bias=SCREAMING_SNAKE_CASE__    )
     __UpperCamelCase   							=emb.weight.data
     return lin_layer

def 						_UpperCAmelCase    (      SCREAMING_SNAKE_CASE__      : Any    ):
     with open(SCREAMING_SNAKE_CASE__      ,					'r'      ,					encoding='utf-8'    ) as f:
          __UpperCamelCase   							=f.readlines()
          __UpperCamelCase   							=[line.split(' '    )[0] for line in lines]

     __UpperCamelCase   							=len(SCREAMING_SNAKE_CASE__    )

     __UpperCamelCase   							={
         '<s>': 0,
         '<pad>': 1,
         '</s>': 2,
         '<unk>': 3,
     }

     vocab_dict.update(dict(zip(SCREAMING_SNAKE_CASE__      ,					range(4      ,					num_words + 4    )    )    )    )
     return vocab_dict

@torch.no_grad()
def 						_UpperCAmelCase    (      SCREAMING_SNAKE_CASE__      : Tuple      ,					SCREAMING_SNAKE_CASE__      : int      ,					SCREAMING_SNAKE_CASE__      : List[str]      ,					SCREAMING_SNAKE_CASE__      : List[str]      ,					SCREAMING_SNAKE_CASE__      : Optional[Any]      ,					SCREAMING_SNAKE_CASE__      : Any      ,					SCREAMING_SNAKE_CASE__      : Dict      ,					):
     __UpperCamelCase   							=WavaVecaConfig.from_pretrained(SCREAMING_SNAKE_CASE__    )
     __UpperCamelCase   							=SpeechaTextaConfig.from_pretrained(
         SCREAMING_SNAKE_CASE__      ,					vocab_size=SCREAMING_SNAKE_CASE__      ,					decoder_layers=SCREAMING_SNAKE_CASE__      ,					do_stable_layer_norm=SCREAMING_SNAKE_CASE__    )

     __UpperCamelCase   							=WavaVecaFeatureExtractor(
         feature_size=1      ,					sampling_rate=1_60_00      ,					padding_value=0      ,					do_normalize=SCREAMING_SNAKE_CASE__      ,					return_attention_mask=SCREAMING_SNAKE_CASE__      ,					)

     __UpperCamelCase							,				__UpperCamelCase							,				__UpperCamelCase   							=fairseq.checkpoint_utils.load_model_ensemble_and_task(
         [checkpoint_path]      ,					arg_overrides={'data': '/'.join(dict_path.split('/'    )[:-1]    )}    )
     __UpperCamelCase   							=model[0].eval()

     # set weights for wav2vec2 encoder
     __UpperCamelCase   							=WavaVecaModel(SCREAMING_SNAKE_CASE__    )
     __UpperCamelCase   							=recursively_load_weights_wavaveca(model.encoder      ,					SCREAMING_SNAKE_CASE__    )

     __UpperCamelCase   							=SpeechaTextaForCausalLM(SCREAMING_SNAKE_CASE__    )
     __UpperCamelCase							,				__UpperCamelCase   							=hf_decoder.model.decoder.load_state_dict(model.decoder.state_dict()      ,					strict=SCREAMING_SNAKE_CASE__    )

     # set output linear layer
     unexpected_keys.remove('embed_out'    )
     __UpperCamelCase   							=nn.Parameter(model.decoder.embed_out.detach()    )

     # layer norm is init to identity matrix so leaving it is fine
     logger.warning(F'The following keys are missing when loading the decoder weights: {missing_keys}'    )
     logger.warning(F'The following keys are unexpected when loading the decoder weights: {unexpected_keys}'    )

     __UpperCamelCase   							=SpeechEncoderDecoderModel(encoder=SCREAMING_SNAKE_CASE__      ,					decoder=SCREAMING_SNAKE_CASE__    )
     __UpperCamelCase   							=False

     # add projection layer
     __UpperCamelCase   							=nn.Parameter(projection_layer.weight    )
     __UpperCamelCase   							=nn.Parameter(projection_layer.bias    )

     __UpperCamelCase   							=create_vocab_dict(SCREAMING_SNAKE_CASE__    )

     with open(os.path.join(SCREAMING_SNAKE_CASE__      ,					'vocab.json'    )      ,					'w'    ) as fp:
          json.dump(SCREAMING_SNAKE_CASE__      ,					SCREAMING_SNAKE_CASE__    )

     __UpperCamelCase   							=SpeechaTextaTokenizer(os.path.join(SCREAMING_SNAKE_CASE__      ,					'vocab.json'    )    )
     tokenizer.save_pretrained(SCREAMING_SNAKE_CASE__    )

     __UpperCamelCase   							=hf_wavavec.config.to_dict()
     __UpperCamelCase   							=tokenizer.pad_token_id
     __UpperCamelCase   							=tokenizer.bos_token_id
     __UpperCamelCase   							=tokenizer.eos_token_id
     __UpperCamelCase   							='speech_to_text_2'
     __UpperCamelCase   							='wav2vec2'

     __UpperCamelCase   							=SpeechEncoderDecoderConfig.from_dict(SCREAMING_SNAKE_CASE__    )

     hf_wavavec.save_pretrained(SCREAMING_SNAKE_CASE__    )
     feature_extractor.save_pretrained(SCREAMING_SNAKE_CASE__    )


if __name__ == "__main__":
   _A			=						argparse.ArgumentParser()
   parser.add_argument('--pytorch_dump_folder_path', default=None, type=str, help='Path to the output PyTorch model.')
   parser.add_argument('--checkpoint_path', default=None, type=str, help='Path to fairseq checkpoint')
   parser.add_argument('--dict_path', default=None, type=str, help='Path to dict of fine-tuned model')
   parser.add_argument(
       '--encoder_config_path',
       default='facebook/wav2vec2-large-lv60',
       type=str,
       help='Path to hf encoder wav2vec2 checkpoint config',
   )
   parser.add_argument(
       '--decoder_config_path',
       default='facebook/s2t-small-mustc-en-fr-st',
       type=str,
       help='Path to hf decoder s2t checkpoint config',
   )
   parser.add_argument('--vocab_size', default=1_0224, type=int, help='Vocab size of decoder')
   parser.add_argument('--num_decoder_layers', default=7, type=int, help='Number of decoder layers')

   _A			=						parser.parse_args()
   convert_wavaveca_checkpoint(
       args.checkpoint_path,
       args.pytorch_dump_folder_path,
       args.dict_path,
       encoder_config_path=args.encoder_config_path,
       decoder_config_path=args.decoder_config_path,
       vocab_size=args.vocab_size,
       num_decoder_layers=args.num_decoder_layers,
   )









from ...configuration_utils import PretrainedConfig
from ...utils import logging


_A			=						logging.get_logger(__name__)

_A			=						{
    'google/realm-cc-news-pretrained-embedder': (
        'https://huggingface.co/google/realm-cc-news-pretrained-embedder/resolve/main/config.json'
    ),
    'google/realm-cc-news-pretrained-encoder': (
        'https://huggingface.co/google/realm-cc-news-pretrained-encoder/resolve/main/config.json'
    ),
    'google/realm-cc-news-pretrained-scorer': (
        'https://huggingface.co/google/realm-cc-news-pretrained-scorer/resolve/main/config.json'
    ),
    'google/realm-cc-news-pretrained-openqa': (
        'https://huggingface.co/google/realm-cc-news-pretrained-openqa/aresolve/main/config.json'
    ),
    'google/realm-orqa-nq-openqa': 'https://huggingface.co/google/realm-orqa-nq-openqa/resolve/main/config.json',
    'google/realm-orqa-nq-reader': 'https://huggingface.co/google/realm-orqa-nq-reader/resolve/main/config.json',
    'google/realm-orqa-wq-openqa': 'https://huggingface.co/google/realm-orqa-wq-openqa/resolve/main/config.json',
    'google/realm-orqa-wq-reader': 'https://huggingface.co/google/realm-orqa-wq-reader/resolve/main/config.json',
    # See all REALM models at https://huggingface.co/models?filter=realm
}






class    UpperCAmelCase__	( A_		):



    """simple docstring"""






    UpperCAmelCase__						:		str              =  "realm"






    def __init__(      self ,       A_=30522 ,       A_=768 ,       A_=128 ,       A_=12 ,       A_=12 ,       A_=8 ,       A_=3072 ,       A_="gelu_new" ,       A_=0.1 ,       A_=0.1 ,       A_=512 ,       A_=2 ,       A_=0.02 ,       A_=1E-12 ,       A_=256 ,       A_=10 ,       A_=1E-3 ,       A_=5 ,       A_=320 ,       A_=13353718 ,       A_=5000 ,       A_=1 ,       A_=0 ,       A_=2 ,       **A_ ,       )  ->	Dict:
         super().__init__(pad_token_id=A_ ,       bos_token_id=A_ ,       eos_token_id=A_ ,       **A_   )

         # Common config
         __UpperCamelCase   							=vocab_size
         __UpperCamelCase   							=max_position_embeddings
         __UpperCamelCase   							=hidden_size
         __UpperCamelCase   							=retriever_proj_size
         __UpperCamelCase   							=num_hidden_layers
         __UpperCamelCase   							=num_attention_heads
         __UpperCamelCase   							=num_candidates
         __UpperCamelCase   							=intermediate_size
         __UpperCamelCase   							=hidden_act
         __UpperCamelCase   							=hidden_dropout_prob
         __UpperCamelCase   							=attention_probs_dropout_prob
         __UpperCamelCase   							=initializer_range
         __UpperCamelCase   							=type_vocab_size
         __UpperCamelCase   							=layer_norm_eps

         # Reader config
         __UpperCamelCase   							=span_hidden_size
         __UpperCamelCase   							=max_span_width
         __UpperCamelCase   							=reader_layer_norm_eps
         __UpperCamelCase   							=reader_beam_size
         __UpperCamelCase   							=reader_seq_len

         # Retrieval config
         __UpperCamelCase   							=num_block_records
         __UpperCamelCase   							=searcher_beam_size





