


'''simple docstring'''






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

lowercase							={
    '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',
}
lowercase							=[
    'lm_head',
    'quantizer.weight_proj',
    'quantizer.codevectors',
    'project_q',
    'project_hid',
]





def lowerCamelCase__      (						__lowerCamelCase	:							Union[str, Any]	,   __lowerCamelCase	:							Any	,   __lowerCamelCase	:							str	,   __lowerCamelCase	:							Dict	,   __lowerCamelCase	:							Any							):







   '''simple docstring'''




   for attribute in key.split('.'							):
      _UpperCAmelCase       :       Any							   =getattr(__lowerCamelCase	,   __lowerCamelCase							)

   if weight_type is not None:
      _UpperCAmelCase       :       Optional[Any]							   =getattr(__lowerCamelCase	,   __lowerCamelCase							).shape
   else:
      _UpperCAmelCase       :       Any							   =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       :       Any							   =value
   elif weight_type == "weight_g":
      _UpperCAmelCase       :       Optional[Any]							   =value
   elif weight_type == "weight_v":
      _UpperCAmelCase       :       Dict							   =value
   elif weight_type == "bias":
      _UpperCAmelCase       :       int							   =value
   else:
      _UpperCAmelCase       :       List[str]							   =value

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





def lowerCamelCase__      (						__lowerCamelCase	:							str	,   __lowerCamelCase	:							Optional[Any]							):







   '''simple docstring'''




   _UpperCAmelCase       :       Dict							   =[]
   _UpperCAmelCase       :       Any							   =fairseq_model.state_dict()

   _UpperCAmelCase       :       Optional[int]							   =hf_model.feature_extractor

   # if encoder has different dim to decoder -> use proj_weight
   _UpperCAmelCase       :       Any							   =None

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

   logger.warning(f"Unused weights: {unused_weights}"							)

   return proj_weight





def lowerCamelCase__      (						__lowerCamelCase	:							Union[str, Any]	,   __lowerCamelCase	:							str	,   __lowerCamelCase	:							List[str]	,   __lowerCamelCase	:							Optional[int]	,   __lowerCamelCase	:							List[Any]							):







   '''simple docstring'''




   _UpperCAmelCase       :       int							   =full_name.split('conv_layers.'							)[-1]
   _UpperCAmelCase       :       str							   =name.split('.'							)
   _UpperCAmelCase       :       Union[str, Any]							   =int(items[0]							)
   _UpperCAmelCase       :       Optional[int]							   =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       :       Union[str, Any]							   =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       :       List[str]							   =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       :       Dict							   =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       :       List[Any]							   =value
         logger.info(f"Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}."							)
   else:
      unused_weights.append(__lowerCamelCase							)





def lowerCamelCase__      (						__lowerCamelCase	:							Dict							):







   '''simple docstring'''




   _UpperCAmelCase   ,	_UpperCAmelCase       :       int							   =emb.weight.shape
   _UpperCAmelCase       :       Union[str, Any]							   =nn.Linear(__lowerCamelCase	,   __lowerCamelCase	,   bias=__lowerCamelCase							)
   _UpperCAmelCase       :       Optional[int]							   =emb.weight.data
   return lin_layer





def lowerCamelCase__      (						__lowerCamelCase	:							Tuple							):







   '''simple docstring'''




   with open(__lowerCamelCase	,   'r'	,   encoding='utf-8'							) as f:
      _UpperCAmelCase       :       str							   =f.readlines()
      _UpperCAmelCase       :       Optional[int]							   =[line.split(' '							)[0] for line in lines]

   _UpperCAmelCase       :       str							   =len(__lowerCamelCase							)

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

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





@torch.no_grad()
def lowerCamelCase__      (						__lowerCamelCase	:							Optional[Any]	,   __lowerCamelCase	:							Tuple	,   __lowerCamelCase	:							Union[str, Any]	,   __lowerCamelCase	:							str	,   __lowerCamelCase	:							int	,   __lowerCamelCase	:							Optional[int]	,   __lowerCamelCase	:							Optional[int]	,   ):







   '''simple docstring'''




   _UpperCAmelCase       :       Dict							   =WavaVecaConfig.from_pretrained(__lowerCamelCase							)
   _UpperCAmelCase       :       Any							   =SpeechaTextaConfig.from_pretrained(
       __lowerCamelCase	,   vocab_size=__lowerCamelCase	,   decoder_layers=__lowerCamelCase	,   do_stable_layer_norm=__lowerCamelCase							)

   _UpperCAmelCase       :       int							   =WavaVecaFeatureExtractor(
       feature_size=1	,   sampling_rate=1_6_0_0_0	,   padding_value=0	,   do_normalize=__lowerCamelCase	,   return_attention_mask=__lowerCamelCase	,   )

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

   # set weights for wav2vec2 encoder
   _UpperCAmelCase       :       int							   =WavaVecaModel(__lowerCamelCase							)
   _UpperCAmelCase       :       Dict							   =recursively_load_weights_wavaveca(model.encoder	,   __lowerCamelCase							)

   _UpperCAmelCase       :       Dict							   =SpeechaTextaForCausalLM(__lowerCamelCase							)
   _UpperCAmelCase   ,	_UpperCAmelCase       :       int							   =hf_decoder.model.decoder.load_state_dict(model.decoder.state_dict()	,   strict=__lowerCamelCase							)

   # set output linear layer
   unexpected_keys.remove('embed_out'							)
   _UpperCAmelCase       :       Any							   =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       :       Dict							   =SpeechEncoderDecoderModel(encoder=__lowerCamelCase	,   decoder=__lowerCamelCase							)
   _UpperCAmelCase       :       Tuple							   =False

   # add projection layer
   _UpperCAmelCase       :       Any							   =nn.Parameter(projection_layer.weight							)
   _UpperCAmelCase       :       Any							   =nn.Parameter(projection_layer.bias							)

   _UpperCAmelCase       :       List[Any]							   =create_vocab_dict(__lowerCamelCase							)

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

   _UpperCAmelCase       :       Optional[int]							   =SpeechaTextaTokenizer(os.path.join(__lowerCamelCase	,   'vocab.json'							)							)
   tokenizer.save_pretrained(__lowerCamelCase							)

   _UpperCAmelCase       :       str							   =hf_wavavec.config.to_dict()
   _UpperCAmelCase       :       str							   =tokenizer.pad_token_id
   _UpperCAmelCase       :       str							   =tokenizer.bos_token_id
   _UpperCAmelCase       :       Union[str, Any]							   =tokenizer.eos_token_id
   _UpperCAmelCase       :       str							   ='speech_to_text_2'
   _UpperCAmelCase       :       Dict							   ='wav2vec2'

   _UpperCAmelCase       :       Optional[int]							   =SpeechEncoderDecoderConfig.from_dict(__lowerCamelCase							)

   hf_wavavec.save_pretrained(__lowerCamelCase							)
   feature_extractor.save_pretrained(__lowerCamelCase							)


if __name__ == "__main__":
 lowercase							=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=10224, type=int, help='Vocab size of decoder')
 parser.add_argument('--num_decoder_layers', default=7, type=int, help='Number of decoder layers')

 lowercase							=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,
 )





'''simple docstring'''






import datasets

from .evaluate import evaluate


lowercase							='\\n@inproceedings{Rajpurkar2016SQuAD10,\n  title={SQuAD: 100, 000+ Questions for Machine Comprehension of Text},\n  author={Pranav Rajpurkar and Jian Zhang and Konstantin Lopyrev and Percy Liang},\n  booktitle={EMNLP},\n  year={2016}\n}\n'

lowercase							='\nThis metric wrap the official scoring script for version 1 of the Stanford Question Answering Dataset (SQuAD).\n\nStanford Question Answering Dataset (SQuAD) is a reading comprehension dataset, consisting of questions posed by\ncrowdworkers on a set of Wikipedia articles, where the answer to every question is a segment of text, or span,\nfrom the corresponding reading passage, or the question might be unanswerable.\n'

lowercase							='\nComputes SQuAD scores (F1 and EM).\nArgs:\n    predictions: List of question-answers dictionaries with the following key-values:\n        - \'id\': id of the question-answer pair as given in the references (see below)\n        - \'prediction_text\': the text of the answer\n    references: List of question-answers dictionaries with the following key-values:\n        - \'id\': id of the question-answer pair (see above),\n        - \'answers\': a Dict in the SQuAD dataset format\n            {\n                \'text\': list of possible texts for the answer, as a list of strings\n                \'answer_start\': list of start positions for the answer, as a list of ints\n            }\n            Note that answer_start values are not taken into account to compute the metric.\nReturns:\n    \'exact_match\': Exact match (the normalized answer exactly match the gold answer)\n    \'f1\': The F-score of predicted tokens versus the gold answer\nExamples:\n\n    >>> predictions = [{\'prediction_text\': \'1976\', \'id\': \'56e10a3be3433e1400422b22\'}]\n    >>> references = [{\'answers\': {\'answer_start\': [97], \'text\': [\'1976\']}, \'id\': \'56e10a3be3433e1400422b22\'}]\n    >>> squad_metric = datasets.load_metric("squad")\n    >>> results = squad_metric.compute(predictions=predictions, references=references)\n    >>> print(results)\n    {\'exact_match\': 100.0, \'f1\': 100.0}\n'






@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION ,_KWARGS_DESCRIPTION    )
class  __magic_name__							(		datasets.Metric    ):






       def       lowerCAmelCase		(      self)						->  List[str]:




          '''simple docstring'''
          return datasets.MetricInfo(
              description=_DESCRIPTION  ,							citation=_CITATION  ,							inputs_description=_KWARGS_DESCRIPTION  ,							features=datasets.Features(
                  {
                      'predictions': {'id': datasets.Value('string'), 'prediction_text': datasets.Value('string')},
                      'references': {
                          'id': datasets.Value('string'),
                          'answers': datasets.features.Sequence(
                              {
                                  'text': datasets.Value('string'),
                                  'answer_start': datasets.Value('int32'),
                              }),
                      },
                  })  ,							codebase_urls=['https://rajpurkar.github.io/SQuAD-explorer/']  ,							reference_urls=['https://rajpurkar.github.io/SQuAD-explorer/']  ,							)






       def       lowerCAmelCase		(      self  ,							snake_case  ,							snake_case)						->  int:




          '''simple docstring'''
          _UpperCAmelCase       :       Optional[int]							   ={prediction['id']: prediction['prediction_text'] for prediction in predictions}
          _UpperCAmelCase       :       Optional[int]							   =[
              {
                  'paragraphs': [
                      {
                          'qas': [
                              {
                                  'answers': [{'text': answer_text} for answer_text in ref['answers']['text']],
                                  'id': ref['id'],
                              }
                              for ref in references
                          ]
                      }
                  ]
              }
          ]
          _UpperCAmelCase       :       List[Any]							   =evaluate(dataset=snake_case  ,							predictions=snake_case)
          return score

