



'''simple docstring'''





import argparse
import json
import os

import fairseq
import torch
from fairseq.data import Dictionary

from transformers import (
    WavaVecaConformerConfig,
    WavaVecaConformerForCTC,
    WavaVecaConformerForPreTraining,
    WavaVecaCTCTokenizer,
    WavaVecaFeatureExtractor,
    WavaVecaProcessor,
    logging,
)


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.linear_k''': '''encoder.layers.*.self_attn.linear_k''',
    '''self_attn.linear_v''': '''encoder.layers.*.self_attn.linear_v''',
    '''self_attn.linear_q''': '''encoder.layers.*.self_attn.linear_q''',
    '''self_attn.pos_bias_u''': '''encoder.layers.*.self_attn.pos_bias_u''',
    '''self_attn.pos_bias_v''': '''encoder.layers.*.self_attn.pos_bias_v''',
    '''self_attn.linear_out''': '''encoder.layers.*.self_attn.linear_out''',
    '''self_attn.linear_pos''': '''encoder.layers.*.self_attn.linear_pos''',
    '''self_attn.rotary_emb''': '''encoder.embed_positions''',
    '''self_attn_layer_norm''': '''encoder.layers.*.self_attn_layer_norm''',
    '''conv_module.pointwise_conv1''': '''encoder.layers.*.conv_module.pointwise_conv1''',
    '''conv_module.pointwise_conv2''': '''encoder.layers.*.conv_module.pointwise_conv2''',
    '''conv_module.depthwise_conv''': '''encoder.layers.*.conv_module.depthwise_conv''',
    '''conv_module.batch_norm''': '''encoder.layers.*.conv_module.batch_norm''',
    '''conv_module.layer_norm''': '''encoder.layers.*.conv_module.layer_norm''',
    '''ffn1.w_1''': '''encoder.layers.*.ffn1.intermediate_dense''',
    '''ffn1.w_2''': '''encoder.layers.*.ffn1.output_dense''',
    '''ffn1.layer_norm''': '''encoder.layers.*.ffn1_layer_norm''',
    '''ffn2.w_1''': '''encoder.layers.*.ffn2.intermediate_dense''',
    '''ffn2.w_2''': '''encoder.layers.*.ffn2.output_dense''',
    '''ffn2.layer_norm''': '''encoder.layers.*.ffn2_layer_norm''',
    '''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''',
}
_lowerCAmelCase      						=	[
    '''lm_head''',
    '''quantizer.weight_proj''',
    '''quantizer.codevectors''',
    '''project_q''',
    '''project_hid''',
]
def    _SCREAMING_SNAKE_CASE  (       UpperCamelCase							,    UpperCamelCase							,    UpperCamelCase							,    UpperCamelCase							,    UpperCamelCase			):



    """simple docstring"""





    for attribute in key.split("""."""			):
        lowerCAmelCase__ :  Optional[Any]							      =					getattr(UpperCamelCase							,    UpperCamelCase			)

    if weight_type is not None:
        lowerCAmelCase__ :  int							      =					getattr(UpperCamelCase							,    UpperCamelCase			).shape
    else:
        lowerCAmelCase__ :  int							      =					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__ :  Union[str, Any]							      =					value
    elif weight_type == "weight_g":
        lowerCAmelCase__ :  Any							      =					value
    elif weight_type == "weight_v":
        lowerCAmelCase__ :  Optional[int]							      =					value
    elif weight_type == "bias":
        lowerCAmelCase__ :  List[str]							      =					value
    elif weight_type == "running_mean":
        lowerCAmelCase__ :  List[str]							      =					value
    elif weight_type == "running_var":
        lowerCAmelCase__ :  int							      =					value
    elif weight_type == "num_batches_tracked":
        lowerCAmelCase__ :  Tuple							      =					value
    elif weight_type == "inv_freq":
        lowerCAmelCase__ :  str							      =					value
    else:
        lowerCAmelCase__ :  str							      =					value

    logger.info(f"""{key + '.' + weight_type if weight_type is not None else ''} was initialized from {full_name}."""			)
def    _SCREAMING_SNAKE_CASE  (       UpperCamelCase							,    UpperCamelCase							,    UpperCamelCase			):



    """simple docstring"""





    lowerCAmelCase__ :  List[str]							      =					[]
    lowerCAmelCase__ :  List[str]							      =					fairseq_model.state_dict()

    lowerCAmelCase__ :  Any							      =					hf_model.wavaveca_conformer.feature_extractor

    for name, value in fairseq_dict.items():
        lowerCAmelCase__ :  int							      =					False
        if "conv_layers" in name:
            load_conv_layer(
                UpperCamelCase							,    UpperCamelCase							,    UpperCamelCase							,    UpperCamelCase							,    hf_model.config.feat_extract_norm == """group"""							,    )
            lowerCAmelCase__ :  Optional[int]							      =					True
        else:
            for key, mapped_key in MAPPING.items():
                lowerCAmelCase__ :  List[Any]							      =					"""wav2vec2_conformer.""" + 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__ :  List[Any]							      =					True
                    if "*" in mapped_key:
                        lowerCAmelCase__ :  str							      =					name.split(UpperCamelCase			)[0].split("""."""			)[-2]
                        lowerCAmelCase__ :  List[str]							      =					mapped_key.replace("""*"""							,    UpperCamelCase			)
                    if "pos_bias_u" in name:
                        lowerCAmelCase__ :  List[str]							      =					None
                    elif "pos_bias_v" in name:
                        lowerCAmelCase__ :  List[str]							      =					None
                    elif "weight_g" in name:
                        lowerCAmelCase__ :  Optional[int]							      =					"""weight_g"""
                    elif "weight_v" in name:
                        lowerCAmelCase__ :  Union[str, Any]							      =					"""weight_v"""
                    elif "bias" in name:
                        lowerCAmelCase__ :  Union[str, Any]							      =					"""bias"""
                    elif "weight" in name:
                        # TODO: don't match quantizer.weight_proj
                        lowerCAmelCase__ :  Union[str, Any]							      =					"""weight"""
                    elif "running_mean" in name:
                        lowerCAmelCase__ :  List[Any]							      =					"""running_mean"""
                    elif "inv_freq" in name:
                        lowerCAmelCase__ :  int							      =					"""inv_freq"""
                    elif "running_var" in name:
                        lowerCAmelCase__ :  Any							      =					"""running_var"""
                    elif "num_batches_tracked" in name:
                        lowerCAmelCase__ :  Union[str, Any]							      =					"""num_batches_tracked"""
                    else:
                        lowerCAmelCase__ :  str							      =					None
                    set_recursively(UpperCamelCase							,    UpperCamelCase							,    UpperCamelCase							,    UpperCamelCase							,    UpperCamelCase			)
                continue
        if not is_used:
            unused_weights.append(UpperCamelCase			)

    logger.warning(f"""Unused weights: {unused_weights}"""			)
def    _SCREAMING_SNAKE_CASE  (       UpperCamelCase							,    UpperCamelCase							,    UpperCamelCase							,    UpperCamelCase							,    UpperCamelCase			):



    """simple docstring"""





    lowerCAmelCase__ :  Optional[Any]							      =					full_name.split("""conv_layers."""			)[-1]
    lowerCAmelCase__ :  Any							      =					name.split("""."""			)
    lowerCAmelCase__ :  Optional[int]							      =					int(items[0]			)
    lowerCAmelCase__ :  Tuple							      =					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__ :  List[str]							      =					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__ :  Any							      =					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__ :  int							      =					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__ :  Union[str, Any]							      =					value
            logger.info(f"""Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}."""			)
    else:
        unused_weights.append(UpperCamelCase			)
@torch.no_grad()
def    _SCREAMING_SNAKE_CASE  (       UpperCamelCase							,    UpperCamelCase							,    UpperCamelCase=None							,    UpperCamelCase=None							,    UpperCamelCase=True			):



    """simple docstring"""





    if config_path is not None:
        lowerCAmelCase__ :  Tuple							      =					WavaVecaConformerConfig.from_pretrained(UpperCamelCase							,    hidden_act="""swish"""			)
    else:
        lowerCAmelCase__ :  Union[str, Any]							      =					WavaVecaConformerConfig()

    if "rope" in checkpoint_path:
        lowerCAmelCase__ :  Tuple							      =					"""rotary"""

    if is_finetuned:
        if dict_path:
            lowerCAmelCase__ :  int							      =					Dictionary.load(UpperCamelCase			)

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

            # fairseq has the <pad> and <s> switched
            lowerCAmelCase__ :  Optional[int]							      =					0
            lowerCAmelCase__ :  int							      =					1
            with open(UpperCamelCase							,    """w"""							,    encoding="""utf-8"""			) as vocab_handle:
                json.dump(UpperCamelCase							,    UpperCamelCase			)
            lowerCAmelCase__ :  Tuple							      =					WavaVecaCTCTokenizer(
                UpperCamelCase							,    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=UpperCamelCase							,    )
            lowerCAmelCase__ :  int							      =					True if config.feat_extract_norm == """layer""" else False
            lowerCAmelCase__ :  Union[str, Any]							      =					WavaVecaFeatureExtractor(
                feature_size=1							,    sampling_rate=16000							,    padding_value=0							,    do_normalize=UpperCamelCase							,    return_attention_mask=UpperCamelCase							,    )
            lowerCAmelCase__ :  List[Any]							      =					WavaVecaProcessor(feature_extractor=UpperCamelCase							,    tokenizer=UpperCamelCase			)
            processor.save_pretrained(UpperCamelCase			)

        lowerCAmelCase__ :  List[str]							      =					WavaVecaConformerForCTC(UpperCamelCase			)
    else:
        lowerCAmelCase__ :  Tuple							      =					WavaVecaConformerForPreTraining(UpperCamelCase			)

    if is_finetuned:
        lowerCAmelCase__      ,   lowerCAmelCase__      ,   lowerCAmelCase__ :  Optional[int]							      =					fairseq.checkpoint_utils.load_model_ensemble_and_task(
            [checkpoint_path]							,    arg_overrides={"""data""": """/""".join(dict_path.split("""/"""			)[:-1]			)}			)
    else:
        lowerCAmelCase__ :  List[Any]							      =					argparse.Namespace(task="""audio_pretraining"""			)
        lowerCAmelCase__ :  List[str]							      =					fairseq.tasks.setup_task(UpperCamelCase			)

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

    lowerCAmelCase__ :  Union[str, Any]							      =					model[0].eval()

    recursively_load_weights(UpperCamelCase							,    UpperCamelCase							,    not is_finetuned			)

    hf_wavavec.save_pretrained(UpperCamelCase			)


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'''
 )
 _lowerCAmelCase      						=	parser.parse_args()
 convert_wavaveca_conformer_checkpoint(
     args.checkpoint_path, args.pytorch_dump_folder_path, args.config_path, args.dict_path, not args.not_finetuned
 )







'''simple docstring'''





from ...configuration_utils import PretrainedConfig
from ...utils import logging
from ...utils.backbone_utils import BackboneConfigMixin, get_aligned_output_features_output_indices


_lowerCAmelCase      						=	logging.get_logger(__name__)

_lowerCAmelCase      						=	{
    '''microsoft/focalnet-tiny''': '''https://huggingface.co/microsoft/focalnet-tiny/resolve/main/config.json''',
}






class        lowerCAmelCase_(				SCREAMING_SNAKE_CASE_						, SCREAMING_SNAKE_CASE_     ):
  '''simple docstring'''




  __lowercase							:      Optional[Any]				=      '''focalnet'''




  def __init__(    self  ,__UpperCAmelCase=224  ,__UpperCAmelCase=4  ,__UpperCAmelCase=3  ,__UpperCAmelCase=96  ,__UpperCAmelCase=False  ,__UpperCAmelCase=[192, 384, 768, 768]  ,__UpperCAmelCase=[2, 2, 6, 2]  ,__UpperCAmelCase=[2, 2, 2, 2]  ,__UpperCAmelCase=[3, 3, 3, 3]  ,__UpperCAmelCase="gelu"  ,__UpperCAmelCase=4.0  ,__UpperCAmelCase=0.0  ,__UpperCAmelCase=0.1  ,__UpperCAmelCase=False  ,__UpperCAmelCase=1E-4  ,__UpperCAmelCase=False  ,__UpperCAmelCase=False  ,__UpperCAmelCase=False  ,__UpperCAmelCase=0.0_2  ,__UpperCAmelCase=1E-5  ,__UpperCAmelCase=32  ,__UpperCAmelCase=None  ,__UpperCAmelCase=None  ,**__UpperCAmelCase  ,)    ->		Optional[Any]:
      super().__init__(**__UpperCAmelCase      )

      lowerCAmelCase__ :  Dict							      =					image_size
      lowerCAmelCase__ :  int							      =					patch_size
      lowerCAmelCase__ :  str							      =					num_channels
      lowerCAmelCase__ :  Dict							      =					embed_dim
      lowerCAmelCase__ :  List[str]							      =					use_conv_embed
      lowerCAmelCase__ :  List[Any]							      =					hidden_sizes
      lowerCAmelCase__ :  Dict							      =					depths
      lowerCAmelCase__ :  List[str]							      =					focal_levels
      lowerCAmelCase__ :  List[str]							      =					focal_windows
      lowerCAmelCase__ :  Dict							      =					hidden_act
      lowerCAmelCase__ :  Dict							      =					mlp_ratio
      lowerCAmelCase__ :  Tuple							      =					hidden_dropout_prob
      lowerCAmelCase__ :  Tuple							      =					drop_path_rate
      lowerCAmelCase__ :  Dict							      =					use_layerscale
      lowerCAmelCase__ :  Optional[Any]							      =					layerscale_value
      lowerCAmelCase__ :  str							      =					use_post_layernorm
      lowerCAmelCase__ :  Union[str, Any]							      =					use_post_layernorm_in_modulation
      lowerCAmelCase__ :  int							      =					normalize_modulator
      lowerCAmelCase__ :  Optional[Any]							      =					initializer_range
      lowerCAmelCase__ :  List[str]							      =					layer_norm_eps
      lowerCAmelCase__ :  List[Any]							      =					encoder_stride
      lowerCAmelCase__ :  Dict							      =					["""stem"""] + [F"""stage{idx}""" for idx in range(1  ,len(self.depths      ) + 1      )]
      lowerCAmelCase__      ,   lowerCAmelCase__ :  Any							      =					get_aligned_output_features_output_indices(
          out_features=__UpperCAmelCase  ,out_indices=__UpperCAmelCase  ,stage_names=self.stage_names      )


