


"""simple docstring"""




__UpperCamelCase		= '''
# Installazione di Transformers
! pip install transformers datasets
# Per installare dalla fonte invece dell\'ultima versione rilasciata, commenta il comando sopra e
# rimuovi la modalità commento al comando seguente.
# ! pip install git+https://github.com/huggingface/transformers.git
'''

__UpperCamelCase		= [{'''type''': '''code''', '''content''': INSTALL_CONTENT}]
__UpperCamelCase		= {
    '''{processor_class}''': '''FakeProcessorClass''',
    '''{model_class}''': '''FakeModelClass''',
    '''{object_class}''': '''FakeObjectClass''',
}



'''simple docstring'''

import argparse
import json
import os

import fairseq
import torch
from fairseq.data import Dictionary

from transformers import (
    UniSpeechConfig,
    UniSpeechForCTC,
    UniSpeechForPreTraining,
    WavaVecaFeatureExtractor,
    WavaVecaPhonemeCTCTokenizer,
    WavaVecaProcessor,
    logging,
)


logging.set_verbosity_info()
A_     :						List[Any]    							=logging.get_logger(__name__)

A_     :						Optional[int]    							={
    '''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''': '''ctc_proj''',
    '''mask_emb''': '''masked_spec_embed''',
}
A_     :						Tuple    							=[
    '''ctc_proj''',
    '''quantizer.weight_proj''',
    '''quantizer.codevectors''',
    '''project_q''',
    '''project_hid''',
]



def snake_case_      (					__snake_case  :							List[str]	,   __snake_case  :							Tuple	,   __snake_case  :							Union[str, Any]	,   __snake_case  :							Union[str, Any]	,   __snake_case  :							int	,   __snake_case  :							Dict)			->					Optional[Any]:
   for attribute in key.split('''.'''):
      if is_finetuned:
         if attribute in ["quantizer", "project_q", "project_hid"]:
            # those layers are only relevant for pretraining and should be dropped
            return

         if attribute == "ctc_proj":
            # we should rename `ctc_proj` to `lm_head` for fine-tuned phoneme models
            lowerCAmelCase_			=      '''lm_head'''

      lowerCAmelCase_			=      getattr(__snake_case	,   __snake_case)

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

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



def snake_case_      (					__snake_case  :							Tuple	,   __snake_case  :							Any	,   __snake_case  :							Any)			->					Tuple:
   lowerCAmelCase_			=      []
   lowerCAmelCase_			=      fairseq_model.state_dict()

   lowerCAmelCase_			=      hf_model.unispeech.feature_extractor

   for name, value in fairseq_dict.items():
      lowerCAmelCase_			=      False
      if "conv_layers" in name:
         load_conv_layer(
             __snake_case	,   __snake_case	,   __snake_case	,   __snake_case	,   hf_model.config.feat_extract_norm == '''group'''	,   )
         lowerCAmelCase_			=      True
      else:
         for key, mapped_key in MAPPING.items():
            lowerCAmelCase_			=      '''unispeech.''' + 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(__snake_case)[0].split('''.''')[-2]
                  lowerCAmelCase_			=      mapped_key.replace('''*'''	,   __snake_case)
               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
               set_recursively(__snake_case	,   __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}''')



def snake_case_      (					__snake_case  :							Optional[int]	,   __snake_case  :							int	,   __snake_case  :							Tuple	,   __snake_case  :							List[str]	,   __snake_case  :							Dict)			->					str:
   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:
         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.'''
         )
         lowerCAmelCase_			=      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.'''
         )
         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:
         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."
         )
         lowerCAmelCase_			=      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.'''
         )
         lowerCAmelCase_			=      value
         logger.info(F'''Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}.''')
   else:
      unused_weights.append(__snake_case)



@torch.no_grad()
def snake_case_      (					__snake_case  :							Tuple	,   __snake_case  :							Tuple	,   __snake_case  :							str=None	,   __snake_case  :							Union[str, Any]=None	,   __snake_case  :							Union[str, Any]=True)			->					Any:
   if config_path is not None:
      lowerCAmelCase_			=      UniSpeechConfig.from_pretrained(__snake_case)
   else:
      lowerCAmelCase_			=      UniSpeechConfig()

   if is_finetuned:
      if dict_path:
         lowerCAmelCase_			=      Dictionary.load_from_json(__snake_case)

         # 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(__snake_case	,   '''vocab.json''')
         if not os.path.isdir(__snake_case):
            logger.error('''--pytorch_dump_folder_path ({}) should be a directory'''.format(__snake_case))
            return
         os.makedirs(__snake_case	,   exist_ok=__snake_case)
         lowerCAmelCase_			=      target_dict.indices

         # fairseq has the <pad> and <s> switched
         lowerCAmelCase_			=      42
         lowerCAmelCase_			=      43
         with open(__snake_case	,   '''w'''	,   encoding='''utf-8''') as vocab_handle:
            json.dump(__snake_case	,   __snake_case)
         lowerCAmelCase_			=      WavaVecaPhonemeCTCTokenizer(
             __snake_case	,   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=__snake_case	,   )
         lowerCAmelCase_			=      True if config.feat_extract_norm == '''layer''' else False
         lowerCAmelCase_			=      WavaVecaFeatureExtractor(
             feature_size=1	,   sampling_rate=16000	,   padding_value=0	,   do_normalize=__snake_case	,   return_attention_mask=__snake_case	,   )
         lowerCAmelCase_			=      WavaVecaProcessor(feature_extractor=__snake_case	,   tokenizer=__snake_case)
         processor.save_pretrained(__snake_case)

      lowerCAmelCase_			=      UniSpeechForCTC(__snake_case)
   else:
      lowerCAmelCase_			=      UniSpeechForPreTraining(__snake_case)

   if is_finetuned:
      lowerCAmelCase_	,lowerCAmelCase_	,lowerCAmelCase_			=      fairseq.checkpoint_utils.load_model_ensemble_and_task(
          [checkpoint_path]	,   arg_overrides={'''data''': '''/'''.join(dict_path.split('''/''')[:-1]), '''w2v_path''': checkpoint_path})
   else:
      lowerCAmelCase_	,lowerCAmelCase_	,lowerCAmelCase_			=      fairseq.checkpoint_utils.load_model_ensemble_and_task([checkpoint_path])

   lowerCAmelCase_			=      model[0].eval()

   recursively_load_weights(__snake_case	,   __snake_case	,   __snake_case)

   hf_unispeech.save_pretrained(__snake_case)


if __name__ == "__main__":
 A_     :						List[Any]    							=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'''
 )
 A_     :						Optional[Any]    							=parser.parse_args()
 convert_unispeech_checkpoint(
     args.checkpoint_path, args.pytorch_dump_folder_path, args.config_path, args.dict_path, not args.not_finetuned
 )





