from scipy.stats import pearsonr

import datasets


lowerCAmelCase__     						=			'\nPearson correlation coefficient and p-value for testing non-correlation.\nThe Pearson correlation coefficient measures the linear relationship between two datasets. The calculation of the p-value relies on the assumption that each dataset is normally distributed. Like other correlation coefficients, this one varies between -1 and +1 with 0 implying no correlation. Correlations of -1 or +1 imply an exact linear relationship. Positive correlations imply that as x increases, so does y. Negative correlations imply that as x increases, y decreases.\nThe p-value roughly indicates the probability of an uncorrelated system producing datasets that have a Pearson correlation at least as extreme as the one computed from these datasets.\n'


lowerCAmelCase__     						=			'\nArgs:\n    predictions (`list` of `int`): Predicted class labels, as returned by a model.\n    references (`list` of `int`): Ground truth labels.\n    return_pvalue (`boolean`): If `True`, returns the p-value, along with the correlation coefficient. If `False`, returns only the correlation coefficient. Defaults to `False`.\n\nReturns:\n    pearsonr (`float`): Pearson correlation coefficient. Minimum possible value is -1. Maximum possible value is 1. Values of 1 and -1 indicate exact linear positive and negative relationships, respectively. A value of 0 implies no correlation.\n    p-value (`float`): P-value, which roughly indicates the probability of an The p-value roughly indicates the probability of an uncorrelated system producing datasets that have a Pearson correlation at least as extreme as the one computed from these datasets. Minimum possible value is 0. Maximum possible value is 1. Higher values indicate higher probabilities.\n\nExamples:\n\n    Example 1-A simple example using only predictions and references.\n        >>> pearsonr_metric = datasets.load_metric("pearsonr")\n        >>> results = pearsonr_metric.compute(predictions=[10, 9, 2.5, 6, 4], references=[1, 2, 3, 4, 5])\n        >>> print(round(results[\'pearsonr\'], 2))\n        -0.74\n\n    Example 2-The same as Example 1, but that also returns the `p-value`.\n        >>> pearsonr_metric = datasets.load_metric("pearsonr")\n        >>> results = pearsonr_metric.compute(predictions=[10, 9, 2.5, 6, 4], references=[1, 2, 3, 4, 5], return_pvalue=True)\n        >>> print(sorted(list(results.keys())))\n        [\'p-value\', \'pearsonr\']\n        >>> print(round(results[\'pearsonr\'], 2))\n        -0.74\n        >>> print(round(results[\'p-value\'], 2))\n        0.15\n'


lowerCAmelCase__     						=			'\n@article{2020SciPy-NMeth,\nauthor  = {Virtanen, Pauli and Gommers, Ralf and Oliphant, Travis E. and\n      Haberland, Matt and Reddy, Tyler and Cournapeau, David and\n      Burovski, Evgeni and Peterson, Pearu and Weckesser, Warren and\n      Bright, Jonathan and {van der Walt}, St{\'e}fan J. and\n      Brett, Matthew and Wilson, Joshua and Millman, K. Jarrod and\n      Mayorov, Nikolay and Nelson, Andrew R. J. and Jones, Eric and\n      Kern, Robert and Larson, Eric and Carey, C J and\n      Polat, Ilhan and Feng, Yu and Moore, Eric W. and\n      {VanderPlas}, Jake and Laxalde, Denis and Perktold, Josef and\n      Cimrman, Robert and Henriksen, Ian and Quintero, E. A. and\n      Harris, Charles R. and Archibald, Anne M. and\n      Ribeiro, Antonio H. and Pedregosa, Fabian and\n      {van Mulbregt}, Paul and {SciPy 1.0 Contributors}},\ntitle   = {{{SciPy} 1.0: Fundamental Algorithms for Scientific\n      Computing in Python}},\njournal = {Nature Methods},\nyear    = {2020},\nvolume  = {17},\npages   = {261--272},\nadsurl  = {https://rdcu.be/b08Wh},\ndoi = {10.1038/s41592-019-0686-2},\n}\n'


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






 '''simple docstring'''






 def 		__snake_case						(      self :  List[Any]):







        '''simple docstring'''



        return datasets.MetricInfo(
            description=_DESCRIPTION      ,   citation=_CITATION      ,   inputs_description=_KWARGS_DESCRIPTION      ,   features=datasets.Features(
                {
                    'predictions': datasets.Value('float'),
                    'references': datasets.Value('float'),
                })      ,   reference_urls=['https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.pearsonr.html']      ,   )




 def 		__snake_case						(      self :  List[Any]      ,   lowercase__ :  str      ,   lowercase__ :  Optional[Any]      ,   lowercase__ :  List[str]=False):







        '''simple docstring'''



        if return_pvalue:
               lowerCAmelCase__					     = pearsonr(lowercase__      ,   lowercase__)
               return {"pearsonr": results[0], "p-value": results[1]}
        else:
               return {"pearsonr": float(pearsonr(lowercase__      ,   lowercase__)[0])}

import argparse
import json
import os

import fairseq
import torch
from fairseq.data import Dictionary

from transformers import (
    WavaVecaConfig,
    WavaVecaCTCTokenizer,
    WavaVecaFeatureExtractor,
    WavaVecaForCTC,
    WavaVecaForPreTraining,
    WavaVecaProcessor,
    logging,
)
from transformers.models.wavaveca.modeling_wavaveca import WavaVecaForSequenceClassification


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

lowerCAmelCase__     						=			{
    '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',
    'adapter_layer': 'encoder.layers.*.adapter_layer',
    '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',
    'pooling_layer.linear': 'projector',
    'pooling_layer.projection': 'classifier',
}
lowerCAmelCase__     						=			[
    'lm_head',
    'quantizer.weight_proj',
    'quantizer.codevectors',
    'project_q',
    'project_hid',
    'projector',
    'classifier',
]






def 				__lowerCamelCase		(						lowerCAmelCase__     ):
       lowerCAmelCase__					     = {}
       with open(lowerCAmelCase__     ,  'r'     ) as file:
              for line_number, line in enumerate(lowerCAmelCase__     ):
                     lowerCAmelCase__					     = line.strip()
                     if line:
                            lowerCAmelCase__					     = line.split()
                            lowerCAmelCase__					     = line_number
                            lowerCAmelCase__					     = words[0]
                            lowerCAmelCase__					     = value
       return result






def 				__lowerCamelCase		(						lowerCAmelCase__     ,  lowerCAmelCase__     ,  lowerCAmelCase__     ,  lowerCAmelCase__     ,  lowerCAmelCase__     ):
       for attribute in key.split('.'     ):
              lowerCAmelCase__					     = getattr(lowerCAmelCase__     ,  lowerCAmelCase__     )

       lowerCAmelCase__					     = None
       for param_key in PARAM_MAPPING.keys():
              if full_name.endswith(lowerCAmelCase__     ):
                     lowerCAmelCase__					     = PARAM_MAPPING[full_name.split('.'     )[-1]]
                     lowerCAmelCase__					     = 'param'

       if weight_type is not None and weight_type != "param":
              lowerCAmelCase__					     = getattr(lowerCAmelCase__     ,  lowerCAmelCase__     ).shape
       elif weight_type is not None and weight_type == "param":
              lowerCAmelCase__					     = hf_pointer
              for attribute in hf_param_name.split('.'     ):
                     lowerCAmelCase__					     = getattr(lowerCAmelCase__     ,  lowerCAmelCase__     )
              lowerCAmelCase__					     = shape_pointer.shape

              # let's reduce dimension
              lowerCAmelCase__					     = value[0]
       else:
              lowerCAmelCase__					     = hf_pointer.shape

       if hf_shape != value.shape:
              raise ValueError(
                  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":
              lowerCAmelCase__					     = value
       elif weight_type == "weight_g":
              lowerCAmelCase__					     = value
       elif weight_type == "weight_v":
              lowerCAmelCase__					     = value
       elif weight_type == "bias":
              lowerCAmelCase__					     = value
       elif weight_type == "param":
              for attribute in hf_param_name.split('.'     ):
                     lowerCAmelCase__					     = getattr(lowerCAmelCase__     ,  lowerCAmelCase__     )
              lowerCAmelCase__					     = value
       else:
              lowerCAmelCase__					     = value

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






def 				__lowerCamelCase		(						lowerCAmelCase__     ,  lowerCAmelCase__     ,  lowerCAmelCase__     ,  lowerCAmelCase__     ,  lowerCAmelCase__     ):
       lowerCAmelCase__					     = None
       for param_key in PARAM_MAPPING.keys():
              if full_name.endswith(lowerCAmelCase__     ):
                     lowerCAmelCase__					     = PARAM_MAPPING[full_name.split('.'     )[-1]]
                     lowerCAmelCase__					     = 'param'

       if weight_type is not None and weight_type != "param":
              lowerCAmelCase__					     = '.'.join([key, weight_type]     )
       elif weight_type is not None and weight_type == "param":
              lowerCAmelCase__					     = '.'.join([key, hf_param_name]     )
       else:
              lowerCAmelCase__					     = key

       lowerCAmelCase__					     = value if 'lm_head' in full_key else value[0]


lowerCAmelCase__     						=			{
    'W_a': 'linear_1.weight',
    'W_b': 'linear_2.weight',
    'b_a': 'linear_1.bias',
    'b_b': 'linear_2.bias',
    'ln_W': 'norm.weight',
    'ln_b': 'norm.bias',
}






def 				__lowerCamelCase		(						lowerCAmelCase__     ,  lowerCAmelCase__     ,  lowerCAmelCase__=None     ,  lowerCAmelCase__=None     ):
       lowerCAmelCase__					     = False
       for key, mapped_key in MAPPING.items():
              lowerCAmelCase__					     = 'wav2vec2.' + mapped_key if mapped_key not in TOP_LEVEL_KEYS else mapped_key
              if key in name or key.split('w2v_model.'     )[-1] == name.split('.'     )[0]:
                     lowerCAmelCase__					     = True
                     if "*" in mapped_key:
                            lowerCAmelCase__					     = name.split(lowerCAmelCase__     )[0].split('.'     )[-2]
                            lowerCAmelCase__					     = mapped_key.replace('*'     ,  lowerCAmelCase__     )
                     if "weight_g" in name:
                            lowerCAmelCase__					     = 'weight_g'
                     elif "weight_v" in name:
                            lowerCAmelCase__					     = 'weight_v'
                     elif "bias" in name:
                            lowerCAmelCase__					     = 'bias'
                     elif "weight" in name:
                            # TODO: don't match quantizer.weight_proj
                            lowerCAmelCase__					     = 'weight'
                     else:
                            lowerCAmelCase__					     = None
                     if hf_dict is not None:
                            rename_dict(lowerCAmelCase__     ,  lowerCAmelCase__     ,  lowerCAmelCase__     ,  lowerCAmelCase__     ,  lowerCAmelCase__     )
                     else:
                            set_recursively(lowerCAmelCase__     ,  lowerCAmelCase__     ,  lowerCAmelCase__     ,  lowerCAmelCase__     ,  lowerCAmelCase__     )
                     return is_used
       return is_used






def 				__lowerCamelCase		(						lowerCAmelCase__     ,  lowerCAmelCase__     ,  lowerCAmelCase__     ):
       lowerCAmelCase__					     = []
       lowerCAmelCase__					     = fairseq_model.state_dict()

       lowerCAmelCase__					     = hf_model.wavaveca.feature_extractor

       for name, value in fairseq_dict.items():
              lowerCAmelCase__					     = False
              if "conv_layers" in name:
                     load_conv_layer(
                         lowerCAmelCase__     ,  lowerCAmelCase__     ,  lowerCAmelCase__     ,  lowerCAmelCase__     ,  hf_model.config.feat_extract_norm == 'group'     ,  )
                     lowerCAmelCase__					     = True
              else:
                     lowerCAmelCase__					     = load_wavaveca_layer(lowerCAmelCase__     ,  lowerCAmelCase__     ,  lowerCAmelCase__     )
              if not is_used:
                     unused_weights.append(lowerCAmelCase__     )

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






def 				__lowerCamelCase		(						lowerCAmelCase__     ,  lowerCAmelCase__     ,  lowerCAmelCase__     ,  lowerCAmelCase__     ,  lowerCAmelCase__     ):
       lowerCAmelCase__					     = full_name.split('conv_layers.'     )[-1]
       lowerCAmelCase__					     = name.split('.'     )
       lowerCAmelCase__					     = int(items[0]     )
       lowerCAmelCase__					     = int(items[1]     )

       if type_id == 0:
              if "bias" in name:
                     if value.shape != feature_extractor.conv_layers[layer_id].conv.bias.data.shape:
                            raise ValueError(
                                F"""{full_name} has size {value.shape}, but"""
                                F""" {feature_extractor.conv_layers[layer_id].conv.bias.data.shape} was found."""     )
                     lowerCAmelCase__					     = value
                     logger.info(F"""Feat extract conv layer {layer_id} was initialized from {full_name}."""     )
              elif "weight" in name:
                     if value.shape != feature_extractor.conv_layers[layer_id].conv.weight.data.shape:
                            raise ValueError(
                                F"""{full_name} has size {value.shape}, but"""
                                F""" {feature_extractor.conv_layers[layer_id].conv.weight.data.shape} was found."""     )
                     lowerCAmelCase__					     = 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:
                     if value.shape != feature_extractor.conv_layers[layer_id].layer_norm.bias.data.shape:
                            raise ValueError(
                                F"""{full_name} has size {value.shape}, but"""
                                F""" {feature_extractor.conv_layers[layer_id].layer_norm.bias.data.shape} was found."""     )
                     lowerCAmelCase__					     = value
                     logger.info(F"""Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}."""     )
              elif "weight" in name:
                     if value.shape != feature_extractor.conv_layers[layer_id].layer_norm.weight.data.shape:
                            raise ValueError(
                                F"""{full_name} has size {value.shape}, but"""
                                F""" {feature_extractor.conv_layers[layer_id].layer_norm.weight.data.shape} was found."""     )
                     lowerCAmelCase__					     = value
                     logger.info(F"""Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}."""     )
       else:
              unused_weights.append(lowerCAmelCase__     )






@torch.no_grad()
def 				__lowerCamelCase		(						lowerCAmelCase__     ,  lowerCAmelCase__     ,  lowerCAmelCase__=None     ,  lowerCAmelCase__=None     ,  lowerCAmelCase__=True     ,  lowerCAmelCase__=False     ):
       if config_path is not None:
              lowerCAmelCase__					     = WavaVecaConfig.from_pretrained(lowerCAmelCase__     )
       else:
              lowerCAmelCase__					     = WavaVecaConfig()

       if is_seq_class:
              lowerCAmelCase__					     = read_txt_into_dict(lowerCAmelCase__     )
              lowerCAmelCase__					     = idalabel
              lowerCAmelCase__					     = WavaVecaForSequenceClassification(lowerCAmelCase__     )
              lowerCAmelCase__					     = WavaVecaFeatureExtractor(
                  feature_size=1     ,  sampling_rate=1_6_0_0_0     ,  padding_value=0     ,  do_normalize=lowerCAmelCase__     ,  return_attention_mask=lowerCAmelCase__     ,  )
              feature_extractor.save_pretrained(lowerCAmelCase__     )

       elif is_finetuned:
              if dict_path:
                     lowerCAmelCase__					     = Dictionary.load(lowerCAmelCase__     )

                     # important change bos & pad token id since CTC symbol is <pad> and
                     # not <s> as in fairseq
                     lowerCAmelCase__					     = target_dict.pad_index
                     lowerCAmelCase__					     = target_dict.bos_index
                     lowerCAmelCase__					     = target_dict.eos_index
                     lowerCAmelCase__					     = len(target_dict.symbols     )
                     lowerCAmelCase__					     = os.path.join(lowerCAmelCase__     ,  'vocab.json'     )
                     if not os.path.isdir(lowerCAmelCase__     ):
                            logger.error('--pytorch_dump_folder_path ({}) should be a directory'.format(lowerCAmelCase__     )     )
                            return
                     os.makedirs(lowerCAmelCase__     ,  exist_ok=lowerCAmelCase__     )
                     lowerCAmelCase__					     = target_dict.indices

                     # fairseq has the <pad> and <s> switched
                     lowerCAmelCase__					     = 0
                     lowerCAmelCase__					     = 1
                     with open(lowerCAmelCase__     ,  'w'     ,  encoding='utf-8'     ) as vocab_handle:
                            json.dump(lowerCAmelCase__     ,  lowerCAmelCase__     )
                     lowerCAmelCase__					     = WavaVecaCTCTokenizer(
                         lowerCAmelCase__     ,  unk_token=target_dict.unk_word     ,  pad_token=target_dict.pad_word     ,  bos_token=target_dict.bos_word     ,  eos_token=target_dict.eos_word     ,  word_delimiter_token='|'     ,  do_lower_case=lowerCAmelCase__     ,  )
                     lowerCAmelCase__					     = True if config.feat_extract_norm == 'layer' else False
                     lowerCAmelCase__					     = WavaVecaFeatureExtractor(
                         feature_size=1     ,  sampling_rate=1_6_0_0_0     ,  padding_value=0     ,  do_normalize=lowerCAmelCase__     ,  return_attention_mask=lowerCAmelCase__     ,  )
                     lowerCAmelCase__					     = WavaVecaProcessor(feature_extractor=lowerCAmelCase__     ,  tokenizer=lowerCAmelCase__     )
                     processor.save_pretrained(lowerCAmelCase__     )

              lowerCAmelCase__					     = WavaVecaForCTC(lowerCAmelCase__     )
       else:
              lowerCAmelCase__					     = WavaVecaForPreTraining(lowerCAmelCase__     )

       if is_finetuned or is_seq_class:
              lowerCAmelCase__     , lowerCAmelCase__     , lowerCAmelCase__					     = fairseq.checkpoint_utils.load_model_ensemble_and_task(
                  [checkpoint_path]     ,  arg_overrides={'data': '/'.join(dict_path.split('/'     )[:-1]     )}     )
       else:
              lowerCAmelCase__					     = argparse.Namespace(task='audio_pretraining'     )
              lowerCAmelCase__					     = fairseq.tasks.setup_task(lowerCAmelCase__     )

              lowerCAmelCase__     , lowerCAmelCase__     , lowerCAmelCase__					     = fairseq.checkpoint_utils.load_model_ensemble_and_task([checkpoint_path]     ,  task=lowerCAmelCase__     )

       lowerCAmelCase__					     = model[0].eval()

       recursively_load_weights(lowerCAmelCase__     ,  lowerCAmelCase__     ,  not is_finetuned     )

       hf_wavavec.save_pretrained(lowerCAmelCase__     )


if __name__ == "__main__":
    lowerCAmelCase__     						=			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('--config_path', default=None, type=str, help='Path to hf config.json of model to convert')
    parser.add_argument(
        '--not_finetuned', action='store_true', help='Whether the model to convert is a fine-tuned model or not'
    )
    parser.add_argument(
        '--is_seq_class',
        action='store_true',
        help='Whether the model to convert is a fine-tuned sequence classification model or not',
    )
    lowerCAmelCase__     						=			parser.parse_args()

    lowerCAmelCase__     						=			not args.not_finetuned and not args.is_seq_class
    convert_wavaveca_checkpoint(
        args.checkpoint_path,
        args.pytorch_dump_folder_path,
        args.config_path,
        args.dict_path,
        is_finetuned,
        args.is_seq_class,
    )
