





import argparse

import torch
from saprl.hub import distilhubert

from transformers import HubertConfig, HubertModel, WavaVecaFeatureExtractor, logging


logging.set_verbosity_info()
_lowerCAmelCase  :				Tuple						=				logging.get_logger(__name__)

_lowerCAmelCase  :				Any						=				{
    "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",
    "mask_emb": "masked_spec_embed",
}



def   lowerCAmelCase						(						_lowerCAmelCase							:				Dict  ,							_lowerCAmelCase							:				Dict  ,							_lowerCAmelCase							:				List[str]  ,							_lowerCAmelCase							:				Any  ,							_lowerCAmelCase							:				str		):




 """simple docstring"""







 for attribute in key.split("."		):
  UpperCAmelCase__								=  getattr(_lowerCAmelCase  ,							_lowerCAmelCase		)

 if weight_type is not None:
  UpperCAmelCase__								=  getattr(_lowerCAmelCase  ,							_lowerCAmelCase		).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   lowerCAmelCase						(						_lowerCAmelCase							:				str  ,							_lowerCAmelCase							:				str		):




 """simple docstring"""







 UpperCAmelCase__								=  []
 UpperCAmelCase__								=  fairseq_model.state_dict()

 UpperCAmelCase__								=  hf_model.feature_extractor

 for name, value in fairseq_dict.items():
  UpperCAmelCase__								=  False
  if "conv_layers" in name:
   load_conv_layer(
       _lowerCAmelCase  ,							_lowerCAmelCase  ,							_lowerCAmelCase  ,							_lowerCAmelCase  ,							hf_model.config.feat_extract_norm == "group"  ,							)
   UpperCAmelCase__								=  True
  else:
   for key, mapped_key in MAPPING.items():
    UpperCAmelCase__								=  mapped_key

    if key in name:
     UpperCAmelCase__								=  True
     if "*" in mapped_key:
      UpperCAmelCase__								=  name.split(_lowerCAmelCase		)[0].split("."		)[-2]
      UpperCAmelCase__								=  mapped_key.replace("*"  ,							_lowerCAmelCase		)
     if "weight_g" in name:
      UpperCAmelCase__								=  "weight_g"
     elif "weight_v" in name:
      UpperCAmelCase__								=  "weight_v"
     elif "weight" in name:
      UpperCAmelCase__								=  "weight"
     elif "bias" in name:
      UpperCAmelCase__								=  "bias"
     else:
      UpperCAmelCase__								=  None
     set_recursively(_lowerCAmelCase  ,							_lowerCAmelCase  ,							_lowerCAmelCase  ,							_lowerCAmelCase  ,							_lowerCAmelCase		)
    continue
  if not is_used:
   unused_weights.append(_lowerCAmelCase		)

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



def   lowerCAmelCase						(						_lowerCAmelCase							:				Tuple  ,							_lowerCAmelCase							:				Optional[int]  ,							_lowerCAmelCase							:				Dict  ,							_lowerCAmelCase							:				Optional[int]  ,							_lowerCAmelCase							:				List[Any]		):




 """simple docstring"""







 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(_lowerCAmelCase		)



def   lowerCAmelCase						(						_lowerCAmelCase							:				Any		):




 """simple docstring"""







 UpperCAmelCase__								=  HubertConfig()
 UpperCAmelCase__								=  model.config

 UpperCAmelCase__								=  fs_config.activation_dropout
 UpperCAmelCase__								=  False
 UpperCAmelCase__								=  fs_config.attention_dropout
 UpperCAmelCase__								=  False
 UpperCAmelCase__								=  eval(fs_config.extractor_conv_feature_layers		)
 UpperCAmelCase__								=  [x[0] for x in conv_layers]
 UpperCAmelCase__								=  [x[1] for x in conv_layers]
 UpperCAmelCase__								=  [x[2] for x in conv_layers]
 UpperCAmelCase__								=  "gelu"
 UpperCAmelCase__								=  "layer" if fs_config.extractor_mode == "layer_norm" else "group"
 UpperCAmelCase__								=  False
 UpperCAmelCase__								=  0.0
 UpperCAmelCase__								=  0.0
 UpperCAmelCase__								=  fs_config.activation_fn
 UpperCAmelCase__								=  fs_config.dropout
 UpperCAmelCase__								=  fs_config.encoder_embed_dim
 UpperCAmelCase__								=  0.02
 UpperCAmelCase__								=  fs_config.encoder_ffn_embed_dim
 UpperCAmelCase__								=  1E-5
 UpperCAmelCase__								=  0.0
 UpperCAmelCase__								=  fs_config.encoder_attention_heads
 UpperCAmelCase__								=  fs_config.conv_pos_groups
 UpperCAmelCase__								=  fs_config.conv_pos
 UpperCAmelCase__								=  len(_lowerCAmelCase		)
 UpperCAmelCase__								=  fs_config.encoder_layers

 return config



@torch.no_grad()
def   lowerCAmelCase						(						_lowerCAmelCase							:				List[Any]  ,							_lowerCAmelCase							:				Dict=None		):




 """simple docstring"""







 UpperCAmelCase__								=  distilhubert().model.model

 if config_path is not None:
  UpperCAmelCase__								=  HubertConfig.from_pretrained(_lowerCAmelCase		)
 else:
  UpperCAmelCase__								=  convert_config(_lowerCAmelCase		)
 UpperCAmelCase__								=  model.eval()

 UpperCAmelCase__								=  WavaVecaFeatureExtractor(
     feature_size=1  ,							sampling_rate=1_6000  ,							padding_value=0  ,							do_normalize=_lowerCAmelCase  ,							return_attention_mask=_lowerCAmelCase  ,							)
 UpperCAmelCase__								=  HubertModel(_lowerCAmelCase		)

 recursively_load_weights(_lowerCAmelCase  ,							_lowerCAmelCase		)

 feature_extractor.save_pretrained(_lowerCAmelCase		)
 hf_model.save_pretrained(_lowerCAmelCase		)


if __name__ == "__main__":
  _lowerCAmelCase  :				Optional[Any]						=				argparse.ArgumentParser()
  parser.add_argument("--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model.")
  parser.add_argument("--config_path", default=None, type=str, help="Path to hf config.json of model to convert")
  _lowerCAmelCase  :				List[str]						=				parser.parse_args()
  convert_hubert_checkpoint(args.pytorch_dump_folder_path, args.config_path)











from __future__ import annotations



def   lowerCAmelCase						(						_lowerCAmelCase							:				int  ,							_lowerCAmelCase							:				int  ,							_lowerCAmelCase							:				int		):




 """simple docstring"""







 assert (
     c % greatest_common_divisor(_lowerCAmelCase  ,							_lowerCAmelCase		) == 0
 )  # greatest_common_divisor(a,b) function implemented below
 ((UpperCAmelCase__)	,	(UpperCAmelCase__)	,	(UpperCAmelCase__))								=  extended_gcd(_lowerCAmelCase  ,							_lowerCAmelCase		)  # extended_gcd(a,b) function implemented below
 UpperCAmelCase__								=  c / d
 return (r * x, r * y)



def   lowerCAmelCase						(						_lowerCAmelCase							:				int  ,							_lowerCAmelCase							:				int  ,							_lowerCAmelCase							:				int  ,							_lowerCAmelCase							:				int = 2		):




 """simple docstring"""







 ((UpperCAmelCase__)	,	(UpperCAmelCase__))								=  diophantine(_lowerCAmelCase  ,							_lowerCAmelCase  ,							_lowerCAmelCase		)  # Initial value
 UpperCAmelCase__								=  greatest_common_divisor(_lowerCAmelCase  ,							_lowerCAmelCase		)
 UpperCAmelCase__								=  a // d
 UpperCAmelCase__								=  b // d

 for i in range(_lowerCAmelCase		):
  UpperCAmelCase__								=  xa + i * q
  UpperCAmelCase__								=  ya - i * p
  print(_lowerCAmelCase  ,							_lowerCAmelCase		)



def   lowerCAmelCase						(						_lowerCAmelCase							:				int  ,							_lowerCAmelCase							:				int		):




 """simple docstring"""







 if a < b:
  UpperCAmelCase__	,	UpperCAmelCase__								=  b, a

 while a % b != 0:
  UpperCAmelCase__	,	UpperCAmelCase__								=  b, a % b

 return b



def   lowerCAmelCase						(						_lowerCAmelCase							:				int  ,							_lowerCAmelCase							:				int		):




 """simple docstring"""







 assert a >= 0 and b >= 0

 if b == 0:
  UpperCAmelCase__	,	UpperCAmelCase__	,	UpperCAmelCase__								=  a, 1, 0
 else:
  ((UpperCAmelCase__)	,	(UpperCAmelCase__)	,	(UpperCAmelCase__))								=  extended_gcd(_lowerCAmelCase  ,							a % b		)
  UpperCAmelCase__								=  q
  UpperCAmelCase__								=  p - q * (a // b)

 assert a % d == 0 and b % d == 0
 assert d == a * x + b * y

 return (d, x, y)


if __name__ == "__main__":
  from doctest import testmod

  testmod(name="diophantine", verbose=True)
  testmod(name="diophantine_all_soln", verbose=True)
  testmod(name="extended_gcd", verbose=True)
  testmod(name="greatest_common_divisor", verbose=True)





