



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

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




def        lowerCamelCase  (				_snake_case  :						Optional[int]     ,_snake_case  :						Any     ,_snake_case  :						Dict     ,_snake_case  :						Union[str, Any]     ,_snake_case  :						Optional[Any]       ):





    '''simple docstring'''


    for attribute in key.split("."       ):
        lowercase__		       =						getattr(_snake_case     ,_snake_case       )

    if weight_type is not None:
        lowercase__		       =						getattr(_snake_case     ,_snake_case       ).shape
    else:
        lowercase__		       =						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":
        lowercase__		       =						value
    elif weight_type == "weight_g":
        lowercase__		       =						value
    elif weight_type == "weight_v":
        lowercase__		       =						value
    elif weight_type == "bias":
        lowercase__		       =						value
    else:
        lowercase__		       =						value

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




def        lowerCamelCase  (				_snake_case  :						Optional[int]     ,_snake_case  :						int       ):





    '''simple docstring'''


    lowercase__		       =						[]
    lowercase__		       =						fairseq_model.state_dict()

    lowercase__		       =						hf_model.feature_extractor

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

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

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

    return proj_weight




def        lowerCamelCase  (				_snake_case  :						Tuple     ,_snake_case  :						List[Any]     ,_snake_case  :						Tuple     ,_snake_case  :						Union[str, Any]     ,_snake_case  :						Optional[int]       ):





    '''simple docstring'''


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




def        lowerCamelCase  (				_snake_case  :						Tuple       ):





    '''simple docstring'''


    lowercase__       ,       lowercase__		       =						emb.weight.shape
    lowercase__		       =						nn.Linear(_snake_case     ,_snake_case     ,bias=_snake_case       )
    lowercase__		       =						emb.weight.data
    return lin_layer




def        lowerCamelCase  (				_snake_case  :						str       ):





    '''simple docstring'''


    with open(_snake_case     ,"r"     ,encoding="utf-8"       ) as f:
        lowercase__		       =						f.readlines()
        lowercase__		       =						[line.split(" "       )[0] for line in lines]

    lowercase__		       =						len(_snake_case       )

    lowercase__		       =						{
        "<s>": 0,
        "<pad>": 1,
        "</s>": 2,
        "<unk>": 3,
    }

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




@torch.no_grad()
def        lowerCamelCase  (				_snake_case  :						int     ,_snake_case  :						Optional[int]     ,_snake_case  :						str     ,_snake_case  :						Tuple     ,_snake_case  :						Dict     ,_snake_case  :						int     ,_snake_case  :						int     ,):





    '''simple docstring'''


    lowercase__		       =						WavaVecaConfig.from_pretrained(_snake_case       )
    lowercase__		       =						SpeechaTextaConfig.from_pretrained(
        _snake_case     ,vocab_size=_snake_case     ,decoder_layers=_snake_case     ,do_stable_layer_norm=_snake_case       )

    lowercase__		       =						WavaVecaFeatureExtractor(
        feature_size=1     ,sampling_rate=16_000     ,padding_value=0     ,do_normalize=_snake_case     ,return_attention_mask=_snake_case     ,)

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

    # set weights for wav2vec2 encoder
    lowercase__		       =						WavaVecaModel(_snake_case       )
    lowercase__		       =						recursively_load_weights_wavaveca(model.encoder     ,_snake_case       )

    lowercase__		       =						SpeechaTextaForCausalLM(_snake_case       )
    lowercase__       ,       lowercase__		       =						hf_decoder.model.decoder.load_state_dict(model.decoder.state_dict()     ,strict=_snake_case       )

    # set output linear layer
    unexpected_keys.remove("embed_out"       )
    lowercase__		       =						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}'''       )

    lowercase__		       =						SpeechEncoderDecoderModel(encoder=_snake_case     ,decoder=_snake_case       )
    lowercase__		       =						False

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

    lowercase__		       =						create_vocab_dict(_snake_case       )

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

    lowercase__		       =						SpeechaTextaTokenizer(os.path.join(_snake_case     ,"vocab.json"       )       )
    tokenizer.save_pretrained(_snake_case       )

    lowercase__		       =						hf_wavavec.config.to_dict()
    lowercase__		       =						tokenizer.pad_token_id
    lowercase__		       =						tokenizer.bos_token_id
    lowercase__		       =						tokenizer.eos_token_id
    lowercase__		       =						"speech_to_text_2"
    lowercase__		       =						"wav2vec2"

    lowercase__		       =						SpeechEncoderDecoderConfig.from_dict(_snake_case       )

    hf_wavavec.save_pretrained(_snake_case       )
    feature_extractor.save_pretrained(_snake_case       )


if __name__ == "__main__":
 SCREAMING_SNAKE_CASE__      					=     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")

 SCREAMING_SNAKE_CASE__      					=     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 os
import time

import numpy as np
import onnxruntime as ort


SCREAMING_SNAKE_CASE__      					=     "1"
SCREAMING_SNAKE_CASE__      					=     "0"
SCREAMING_SNAKE_CASE__      					=     "1"

SCREAMING_SNAKE_CASE__      					=     ort.SessionOptions()
SCREAMING_SNAKE_CASE__      					=     ort.GraphOptimizationLevel.ORT_DISABLE_ALL
print("Create inference session...")
SCREAMING_SNAKE_CASE__      					=     ["TensorrtExecutionProvider", "CUDAExecutionProvider"]
SCREAMING_SNAKE_CASE__      					=     ort.InferenceSession("model.onnx", sess_options=sess_opt, providers=execution_provider)
SCREAMING_SNAKE_CASE__      					=     ort.RunOptions()

SCREAMING_SNAKE_CASE__      					=     128
SCREAMING_SNAKE_CASE__      					=     1
SCREAMING_SNAKE_CASE__      					=     np.ones((batch, sequence), dtype=np.intaa)
SCREAMING_SNAKE_CASE__      					=     np.ones((batch, sequence), dtype=np.intaa)
SCREAMING_SNAKE_CASE__      					=     np.ones((batch, sequence), dtype=np.intaa)

print("Warm up phase...")
sess.run(
    None,
    {
        sess.get_inputs()[0].name: input_ids,
        sess.get_inputs()[1].name: attention_mask,
        sess.get_inputs()[2].name: token_type_ids,
    },
    run_options=run_opt,
)

print("Start inference...")
SCREAMING_SNAKE_CASE__      					=     time.time()
SCREAMING_SNAKE_CASE__      					=     2000
SCREAMING_SNAKE_CASE__      					=     {}
for iter in range(max_iters):
 SCREAMING_SNAKE_CASE__      					=     sess.run(
     None,
     {
         sess.get_inputs()[0].name: input_ids,
         sess.get_inputs()[1].name: attention_mask,
         sess.get_inputs()[2].name: token_type_ids,
     },
     run_options=run_opt,
 )
print("Average Inference Time = {:.3f} ms".format((time.time() - start_time) * 1000 / max_iters))




