





"""simple docstring"""





import argparse

import fairseq
import torch

from transformers import UniSpeechSatConfig, UniSpeechSatForCTC, UniSpeechSatForPreTraining, 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",
    "encoder.layer_norm_for_extract": "layer_norm_for_extract",
    "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",
    "label_embs_concat": "label_embeddings_concat",
    "mask_emb": "masked_spec_embed",
    "spk_proj": "speaker_proj",
}
SCREAMING_SNAKE_CASE__   =  [
    "lm_head",
    "quantizer.weight_proj",
    "quantizer.codevectors",
    "project_q",
    "project_hid",
    "label_embeddings_concat",
    "speaker_proj",
    "layer_norm_for_extract",
]


def      UpperCAmelCase__				(    SCREAMING_SNAKE_CASE	:		Union[str, Any]				,		SCREAMING_SNAKE_CASE	:		List[str]				,		SCREAMING_SNAKE_CASE	:		Union[str, Any]				,		SCREAMING_SNAKE_CASE	:		List[str]				,		SCREAMING_SNAKE_CASE	:		List[Any]     ):







      '''simple docstring'''




      for attribute in key.split("""."""     ):
            lowerCAmelCase    		=			getattr(SCREAMING_SNAKE_CASE				,		SCREAMING_SNAKE_CASE     )

      if weight_type is not None:
            lowerCAmelCase    		=			getattr(SCREAMING_SNAKE_CASE				,		SCREAMING_SNAKE_CASE     ).shape
      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
      else:
            lowerCAmelCase    		=			value

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


def      UpperCAmelCase__				(    SCREAMING_SNAKE_CASE	:		Tuple				,		SCREAMING_SNAKE_CASE	:		Optional[Any]     ):







      '''simple docstring'''




      lowerCAmelCase    		=			[]
      lowerCAmelCase    		=			fairseq_model.state_dict()

      lowerCAmelCase    		=			hf_model.unispeech_sat.feature_extractor

      for name, value in fairseq_dict.items():
            lowerCAmelCase    		=			False
            if "conv_layers" in name:
                  load_conv_layer(
                      SCREAMING_SNAKE_CASE				,		SCREAMING_SNAKE_CASE				,		SCREAMING_SNAKE_CASE				,		SCREAMING_SNAKE_CASE				,		hf_model.config.feat_extract_norm == """group"""				,		)
                  lowerCAmelCase    		=			True
            else:
                  for key, mapped_key in MAPPING.items():
                        lowerCAmelCase    		=			"""unispeech_sat.""" + 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]:
                              if "layer_norm_for_extract" in name and (".".join(name.split("""."""     )[:-1]     ) != key):
                                    # special case since naming is very similar
                                    continue
                              lowerCAmelCase    		=			True
                              if "*" in mapped_key:
                                    lowerCAmelCase    		=			name.split(SCREAMING_SNAKE_CASE     )[0].split("""."""     )[-2]
                                    lowerCAmelCase    		=			mapped_key.replace("""*"""				,		SCREAMING_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(SCREAMING_SNAKE_CASE				,		SCREAMING_SNAKE_CASE				,		SCREAMING_SNAKE_CASE				,		SCREAMING_SNAKE_CASE				,		SCREAMING_SNAKE_CASE     )
                        continue
            if not is_used:
                  unused_weights.append(SCREAMING_SNAKE_CASE     )

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


def      UpperCAmelCase__				(    SCREAMING_SNAKE_CASE	:		Any				,		SCREAMING_SNAKE_CASE	:		str				,		SCREAMING_SNAKE_CASE	:		List[Any]				,		SCREAMING_SNAKE_CASE	:		Optional[int]				,		SCREAMING_SNAKE_CASE	:		Union[str, Any]     ):







      '''simple docstring'''




      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[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[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(SCREAMING_SNAKE_CASE     )


@torch.no_grad()
def      UpperCAmelCase__				(    SCREAMING_SNAKE_CASE	:		Dict				,		SCREAMING_SNAKE_CASE	:		Dict				,		SCREAMING_SNAKE_CASE	:		Dict=None				,		SCREAMING_SNAKE_CASE	:		Tuple=None				,		SCREAMING_SNAKE_CASE	:		List[str]=True     ):







      '''simple docstring'''




      if config_path is not None:
            lowerCAmelCase    		=			UniSpeechSatConfig.from_pretrained(SCREAMING_SNAKE_CASE     )
      else:
            lowerCAmelCase    		=			UniSpeechSatConfig()

      lowerCAmelCase    		=			""""""

      if is_finetuned:
            lowerCAmelCase    		=			UniSpeechSatForCTC(SCREAMING_SNAKE_CASE     )
      else:
            lowerCAmelCase    		=			UniSpeechSatForPreTraining(SCREAMING_SNAKE_CASE     )

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

      recursively_load_weights(SCREAMING_SNAKE_CASE				,		SCREAMING_SNAKE_CASE     )

      hf_wavavec.save_pretrained(SCREAMING_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("--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"
       )
       SCREAMING_SNAKE_CASE__   =  parser.parse_args()
       convert_unispeech_sat_checkpoint(
           args.checkpoint_path, args.pytorch_dump_folder_path, args.config_path, args.dict_path, not args.not_finetuned
       )













"""simple docstring"""





class 						lowercase   :





      def __init__(			self					)						->	Any:
            lowerCAmelCase    		=			""""""
            lowerCAmelCase    		=			""""""
            lowerCAmelCase    		=			[]





      def        _snake_case     (			self ,		lowercase ,		lowercase					)						->	int:
            if m == -1:
                  return n + 1
            elif n == -1:
                  return m + 1
            elif self.dp[m][n] > -1:
                  return self.dp[m][n]
            else:
                  if self.worda[m] == self.worda[n]:
                        lowerCAmelCase    		=			self.__min_dist_top_down_dp(m - 1 ,		n - 1					)
                  else:
                        lowerCAmelCase    		=			self.__min_dist_top_down_dp(lowercase ,		n - 1					)
                        lowerCAmelCase    		=			self.__min_dist_top_down_dp(m - 1 ,		lowercase					)
                        lowerCAmelCase    		=			self.__min_dist_top_down_dp(m - 1 ,		n - 1					)
                        lowerCAmelCase    		=			1 + min(lowercase ,		lowercase ,		lowercase					)

                  return self.dp[m][n]





      def        _snake_case     (			self ,		lowercase ,		lowercase					)						->	int:
            lowerCAmelCase    		=			worda
            lowerCAmelCase    		=			worda
            lowerCAmelCase    		=			[[-1 for _ in range(len(lowercase					)					)] for _ in range(len(lowercase					)					)]

            return self.__min_dist_top_down_dp(len(lowercase					) - 1 ,		len(lowercase					) - 1					)





      def        _snake_case     (			self ,		lowercase ,		lowercase					)						->	int:
            lowerCAmelCase    		=			worda
            lowerCAmelCase    		=			worda
            lowerCAmelCase    		=			len(lowercase					)
            lowerCAmelCase    		=			len(lowercase					)
            lowerCAmelCase    		=			[[0 for _ in range(n + 1					)] for _ in range(m + 1					)]

            for i in range(m + 1					):
                  for j in range(n + 1					):
                        if i == 0:  # first string is empty
                              lowerCAmelCase    		=			j
                        elif j == 0:  # second string is empty
                              lowerCAmelCase    		=			i
                        elif worda[i - 1] == worda[j - 1]:  # last characters are equal
                              lowerCAmelCase    		=			self.dp[i - 1][j - 1]
                        else:
                              lowerCAmelCase    		=			self.dp[i][j - 1]
                              lowerCAmelCase    		=			self.dp[i - 1][j]
                              lowerCAmelCase    		=			self.dp[i - 1][j - 1]
                              lowerCAmelCase    		=			1 + min(lowercase ,		lowercase ,		lowercase					)
            return self.dp[m][n]


if __name__ == "__main__":
       SCREAMING_SNAKE_CASE__   =  EditDistance()

       print("****************** Testing Edit Distance DP Algorithm ******************")
       print()

       SCREAMING_SNAKE_CASE__   =  input("Enter the first string: ").strip()
       SCREAMING_SNAKE_CASE__   =  input("Enter the second string: ").strip()

       print()
       print(f'The minimum edit distance is: {solver.min_dist_top_down(Sa, Sa)}')
       print(f'The minimum edit distance is: {solver.min_dist_bottom_up(Sa, Sa)}')
       print()
       print("*************** End of Testing Edit Distance DP Algorithm ***************")






