




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

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



def 							_A       (						lowerCAmelCase_					: Dict       ,    lowerCAmelCase_					: Optional[Any]       ,    lowerCAmelCase_					: Any       ,    lowerCAmelCase_					: Dict       ,    lowerCAmelCase_					: int      ):
     """simple docstring"""

     for attribute in key.split("."      ):
          lowerCAmelCase__          =			getattr(lowerCAmelCase_       ,    lowerCAmelCase_      )

     if weight_type is not None:
          lowerCAmelCase__          =			getattr(lowerCAmelCase_       ,    lowerCAmelCase_      ).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 							_A       (						lowerCAmelCase_					: str       ,    lowerCAmelCase_					: List[str]      ):
     """simple docstring"""

     lowerCAmelCase__          =			[]
     lowerCAmelCase__          =			fairseq_model.state_dict()

     lowerCAmelCase__          =			hf_model.feature_extractor

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

     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
          elif name.split("."      )[0] == "proj":
               lowerCAmelCase__          =			fairseq_model.proj
               lowerCAmelCase__          =			True
          else:
               for key, mapped_key in MAPPING.items():
                    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:
                              lowerCAmelCase__          =			"weight"
                         else:
                              lowerCAmelCase__          =			None
                         set_recursively(lowerCAmelCase_       ,    lowerCAmelCase_       ,    lowerCAmelCase_       ,    lowerCAmelCase_       ,    lowerCAmelCase_      )
                    continue
          if not is_used:
               unused_weights.append(lowerCAmelCase_      )

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

     return proj_weight



def 							_A       (						lowerCAmelCase_					: Any       ,    lowerCAmelCase_					: str       ,    lowerCAmelCase_					: List[Any]       ,    lowerCAmelCase_					: str       ,    lowerCAmelCase_					: 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:
               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(lowerCAmelCase_      )



def 							_A       (						lowerCAmelCase_					: Optional[Any]      ):
     """simple docstring"""

     lowerCAmelCase__     ,		lowerCAmelCase__          =			emb.weight.shape
     lowerCAmelCase__          =			nn.Linear(lowerCAmelCase_       ,    lowerCAmelCase_       ,    bias=lowerCAmelCase_      )
     lowerCAmelCase__          =			emb.weight.data
     return lin_layer



def 							_A       (						lowerCAmelCase_					: List[Any]      ):
     """simple docstring"""

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

     lowerCAmelCase__          =			len(lowerCAmelCase_      )

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

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



@torch.no_grad()
def 							_A       (						lowerCAmelCase_					: int       ,    lowerCAmelCase_					: List[Any]       ,    lowerCAmelCase_					: int       ,    lowerCAmelCase_					: int       ,    lowerCAmelCase_					: Any       ,    lowerCAmelCase_					: List[Any]       ,    lowerCAmelCase_					: str       ,    ):
     """simple docstring"""

     lowerCAmelCase__          =			WavaVecaConfig.from_pretrained(lowerCAmelCase_      )
     lowerCAmelCase__          =			SpeechaTextaConfig.from_pretrained(
         lowerCAmelCase_       ,    vocab_size=lowerCAmelCase_       ,    decoder_layers=lowerCAmelCase_       ,    do_stable_layer_norm=lowerCAmelCase_      )

     lowerCAmelCase__          =			WavaVecaFeatureExtractor(
         feature_size=1       ,    sampling_rate=1_6000       ,    padding_value=0       ,    do_normalize=lowerCAmelCase_       ,    return_attention_mask=lowerCAmelCase_       ,    )

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

     # set weights for wav2vec2 encoder
     lowerCAmelCase__          =			WavaVecaModel(lowerCAmelCase_      )
     lowerCAmelCase__          =			recursively_load_weights_wavaveca(model.encoder       ,    lowerCAmelCase_      )

     lowerCAmelCase__          =			SpeechaTextaForCausalLM(lowerCAmelCase_      )
     lowerCAmelCase__     ,		lowerCAmelCase__          =			hf_decoder.model.decoder.load_state_dict(model.decoder.state_dict()       ,    strict=lowerCAmelCase_      )

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

     lowerCAmelCase__          =			SpeechEncoderDecoderModel(encoder=lowerCAmelCase_       ,    decoder=lowerCAmelCase_      )
     lowerCAmelCase__          =			False

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

     lowerCAmelCase__          =			create_vocab_dict(lowerCAmelCase_      )

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

     lowerCAmelCase__          =			SpeechaTextaTokenizer(os.path.join(lowerCAmelCase_       ,    "vocab.json"      )      )
     tokenizer.save_pretrained(lowerCAmelCase_      )

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

     lowerCAmelCase__          =			SpeechEncoderDecoderConfig.from_dict(lowerCAmelCase_      )

     hf_wavavec.save_pretrained(lowerCAmelCase_      )
     feature_extractor.save_pretrained(lowerCAmelCase_      )


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

     UpperCamelCase								=					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,
     )






from __future__ import annotations

UpperCamelCase								=					[
    [-1, 0],  # left
    [0, -1],  # down
    [1, 0],  # right
    [0, 1],  # up
]



def 							_A       (						lowerCAmelCase_					: list[list[int]]       ,    lowerCAmelCase_					: list[int]       ,    lowerCAmelCase_					: list[int]       ,    lowerCAmelCase_					: int       ,    lowerCAmelCase_					: list[list[int]]       ,    ):
     """simple docstring"""

     lowerCAmelCase__          =			[
         [0 for col in range(len(grid[0]      )      )] for row in range(len(lowerCAmelCase_      )      )
     ]  # the reference grid
     lowerCAmelCase__          =			1
     lowerCAmelCase__          =			[
         [0 for col in range(len(grid[0]      )      )] for row in range(len(lowerCAmelCase_      )      )
     ]  # the action grid

     lowerCAmelCase__          =			init[0]
     lowerCAmelCase__          =			init[1]
     lowerCAmelCase__          =			0
     lowerCAmelCase__          =			g + heuristic[x][y]  # cost from starting cell to destination cell
     lowerCAmelCase__          =			[[f, g, x, y]]

     lowerCAmelCase__          =			False  # flag that is set when search is complete
     lowerCAmelCase__          =			False  # flag set if we can't find expand

     while not found and not resign:
          if len(lowerCAmelCase_      ) == 0:
               raise ValueError("Algorithm is unable to find solution"      )
          else:  # to choose the least costliest action so as to move closer to the goal
               cell.sort()
               cell.reverse()
               lowerCAmelCase__          =			cell.pop()
               lowerCAmelCase__          =			next_cell[2]
               lowerCAmelCase__          =			next_cell[3]
               lowerCAmelCase__          =			next_cell[1]

               if x == goal[0] and y == goal[1]:
                    lowerCAmelCase__          =			True
               else:
                    for i in range(len(lowerCAmelCase_      )      ):  # to try out different valid actions
                         lowerCAmelCase__          =			x + DIRECTIONS[i][0]
                         lowerCAmelCase__          =			y + DIRECTIONS[i][1]
                         if xa >= 0 and xa < len(lowerCAmelCase_      ) and ya >= 0 and ya < len(grid[0]      ):
                              if closed[xa][ya] == 0 and grid[xa][ya] == 0:
                                   lowerCAmelCase__          =			g + cost
                                   lowerCAmelCase__          =			ga + heuristic[xa][ya]
                                   cell.append([fa, ga, xa, ya]      )
                                   lowerCAmelCase__          =			1
                                   lowerCAmelCase__          =			i
     lowerCAmelCase__          =			[]
     lowerCAmelCase__          =			goal[0]
     lowerCAmelCase__          =			goal[1]
     invpath.append([x, y]      )  # we get the reverse path from here
     while x != init[0] or y != init[1]:
          lowerCAmelCase__          =			x - DIRECTIONS[action[x][y]][0]
          lowerCAmelCase__          =			y - DIRECTIONS[action[x][y]][1]
          lowerCAmelCase__          =			xa
          lowerCAmelCase__          =			ya
          invpath.append([x, y]      )

     lowerCAmelCase__          =			[]
     for i in range(len(lowerCAmelCase_      )      ):
          path.append(invpath[len(lowerCAmelCase_      ) - 1 - i]      )
     return path, action


if __name__ == "__main__":
     UpperCamelCase								=					[
         [0, 1, 0, 0, 0, 0],
         [0, 1, 0, 0, 0, 0],  # 0 are free path whereas 1's are obstacles
         [0, 1, 0, 0, 0, 0],
         [0, 1, 0, 0, 1, 0],
         [0, 0, 0, 0, 1, 0],
     ]

     UpperCamelCase								=					[0, 0]
     # all coordinates are given in format [y,x]
     UpperCamelCase								=					[len(grid) - 1, len(grid[0]) - 1]
     UpperCamelCase								=					1

     # the cost map which pushes the path closer to the goal
     UpperCamelCase								=					[[0 for row in range(len(grid[0]))] for col in range(len(grid))]
     for i in range(len(grid)):
          for j in range(len(grid[0])):
               UpperCamelCase								=					abs(i - goal[0]) + abs(j - goal[1])
               if grid[i][j] == 1:
                    # added extra penalty in the heuristic map
                    UpperCamelCase								=					99

     UpperCamelCase						,  UpperCamelCase								=					search(grid, init, goal, cost, heuristic)

     print('ACTION MAP')
     for i in range(len(action)):
          print(action[i])

     for i in range(len(path)):
          print(path[i])
