

import argparse

import torch
from saprl.hub import distilhubert

from transformers import HubertConfig, HubertModel, WavaVecaFeatureExtractor, logging


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

lowerCAmelCase       :				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',
    'mask_emb': 'masked_spec_embed',
}

def 				A_					(							a   ,				a   ,				a   ,				a   ,				a					):

      """simple docstring"""



      for attribute in key.split('.'					):
            SCREAMING_SNAKE_CASE_			:					int          =       getattr(__UpperCamelCase   ,				__UpperCamelCase					)

      if weight_type is not None:
            SCREAMING_SNAKE_CASE_			:					List[Any]          =       getattr(__UpperCamelCase   ,				__UpperCamelCase					).shape
      else:
            SCREAMING_SNAKE_CASE_			:					Optional[Any]          =       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":
            SCREAMING_SNAKE_CASE_			:					List[str]          =       value
      elif weight_type == "weight_g":
            SCREAMING_SNAKE_CASE_			:					List[str]          =       value
      elif weight_type == "weight_v":
            SCREAMING_SNAKE_CASE_			:					Tuple          =       value
      elif weight_type == "bias":
            SCREAMING_SNAKE_CASE_			:					int          =       value
      else:
            SCREAMING_SNAKE_CASE_			:					int          =       value

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

def 				A_					(							a   ,				a					):

      """simple docstring"""



      SCREAMING_SNAKE_CASE_			:					List[str]          =       []
      SCREAMING_SNAKE_CASE_			:					Dict          =       fairseq_model.state_dict()

      SCREAMING_SNAKE_CASE_			:					Optional[Any]          =       hf_model.feature_extractor

      for name, value in fairseq_dict.items():
            SCREAMING_SNAKE_CASE_			:					Optional[int]          =       False
            if "conv_layers" in name:
                  load_conv_layer(
                      __UpperCamelCase   ,				__UpperCamelCase   ,				__UpperCamelCase   ,				__UpperCamelCase   ,				hf_model.config.feat_extract_norm == 'group'   ,				)
                  SCREAMING_SNAKE_CASE_			:					Tuple          =       True
            else:
                  for key, mapped_key in MAPPING.items():
                        SCREAMING_SNAKE_CASE_			:					Tuple          =       mapped_key

                        if key in name:
                              SCREAMING_SNAKE_CASE_			:					str          =       True
                              if "*" in mapped_key:
                                    SCREAMING_SNAKE_CASE_			:					Any          =       name.split(__UpperCamelCase					)[0].split('.'					)[-2]
                                    SCREAMING_SNAKE_CASE_			:					List[str]          =       mapped_key.replace('*'   ,				__UpperCamelCase					)
                              if "weight_g" in name:
                                    SCREAMING_SNAKE_CASE_			:					int          =       'weight_g'
                              elif "weight_v" in name:
                                    SCREAMING_SNAKE_CASE_			:					int          =       'weight_v'
                              elif "weight" in name:
                                    SCREAMING_SNAKE_CASE_			:					Any          =       'weight'
                              elif "bias" in name:
                                    SCREAMING_SNAKE_CASE_			:					str          =       'bias'
                              else:
                                    SCREAMING_SNAKE_CASE_			:					List[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 				A_					(							a   ,				a   ,				a   ,				a   ,				a					):

      """simple docstring"""



      SCREAMING_SNAKE_CASE_			:					Dict          =       full_name.split('conv_layers.'					)[-1]
      SCREAMING_SNAKE_CASE_			:					int          =       name.split('.'					)
      SCREAMING_SNAKE_CASE_			:					Optional[Any]          =       int(items[0]					)
      SCREAMING_SNAKE_CASE_			:					int          =       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."
                  )
                  SCREAMING_SNAKE_CASE_			:					Dict          =       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."
                  )
                  SCREAMING_SNAKE_CASE_			:					Tuple          =       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."
                  )
                  SCREAMING_SNAKE_CASE_			:					Optional[int]          =       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."
                  )
                  SCREAMING_SNAKE_CASE_			:					List[str]          =       value
                  logger.info(f"Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}."					)
      else:
            unused_weights.append(__UpperCamelCase					)

def 				A_					(							a					):

      """simple docstring"""



      SCREAMING_SNAKE_CASE_			:					Optional[int]          =       HubertConfig()
      SCREAMING_SNAKE_CASE_			:					Tuple          =       model.config

      SCREAMING_SNAKE_CASE_			:					Tuple          =       fs_config.activation_dropout
      SCREAMING_SNAKE_CASE_			:					List[str]          =       False
      SCREAMING_SNAKE_CASE_			:					Optional[Any]          =       fs_config.attention_dropout
      SCREAMING_SNAKE_CASE_			:					int          =       False
      SCREAMING_SNAKE_CASE_			:					Union[str, Any]          =       eval(fs_config.extractor_conv_feature_layers					)
      SCREAMING_SNAKE_CASE_			:					str          =       [x[0] for x in conv_layers]
      SCREAMING_SNAKE_CASE_			:					Optional[int]          =       [x[1] for x in conv_layers]
      SCREAMING_SNAKE_CASE_			:					List[Any]          =       [x[2] for x in conv_layers]
      SCREAMING_SNAKE_CASE_			:					Optional[int]          =       'gelu'
      SCREAMING_SNAKE_CASE_			:					List[Any]          =       'layer' if fs_config.extractor_mode == 'layer_norm' else 'group'
      SCREAMING_SNAKE_CASE_			:					str          =       False
      SCREAMING_SNAKE_CASE_			:					Dict          =       0.0
      SCREAMING_SNAKE_CASE_			:					List[str]          =       0.0
      SCREAMING_SNAKE_CASE_			:					str          =       fs_config.activation_fn
      SCREAMING_SNAKE_CASE_			:					Tuple          =       fs_config.dropout
      SCREAMING_SNAKE_CASE_			:					Union[str, Any]          =       fs_config.encoder_embed_dim
      SCREAMING_SNAKE_CASE_			:					Union[str, Any]          =       0.02
      SCREAMING_SNAKE_CASE_			:					List[Any]          =       fs_config.encoder_ffn_embed_dim
      SCREAMING_SNAKE_CASE_			:					Any          =       1e-5
      SCREAMING_SNAKE_CASE_			:					str          =       0.0
      SCREAMING_SNAKE_CASE_			:					Any          =       fs_config.encoder_attention_heads
      SCREAMING_SNAKE_CASE_			:					Optional[int]          =       fs_config.conv_pos_groups
      SCREAMING_SNAKE_CASE_			:					Union[str, Any]          =       fs_config.conv_pos
      SCREAMING_SNAKE_CASE_			:					Optional[Any]          =       len(__UpperCamelCase					)
      SCREAMING_SNAKE_CASE_			:					str          =       fs_config.encoder_layers

      return config

@torch.no_grad()
def 				A_					(							a   ,				a=None					):

      """simple docstring"""



      SCREAMING_SNAKE_CASE_			:					Tuple          =       distilhubert().model.model

      if config_path is not None:
            SCREAMING_SNAKE_CASE_			:					Tuple          =       HubertConfig.from_pretrained(__UpperCamelCase					)
      else:
            SCREAMING_SNAKE_CASE_			:					Tuple          =       convert_config(__UpperCamelCase					)
      SCREAMING_SNAKE_CASE_			:					int          =       model.eval()

      SCREAMING_SNAKE_CASE_			:					int          =       WavaVecaFeatureExtractor(
          feature_size=1   ,				sampling_rate=1_6_0_0_0   ,				padding_value=0   ,				do_normalize=__UpperCamelCase   ,				return_attention_mask=__UpperCamelCase   ,				)
      SCREAMING_SNAKE_CASE_			:					int          =       HubertModel(__UpperCamelCase					)

      recursively_load_weights(__UpperCamelCase   ,				__UpperCamelCase					)

      feature_extractor.save_pretrained(__UpperCamelCase					)
      hf_model.save_pretrained(__UpperCamelCase					)


if __name__ == "__main__":
    lowerCAmelCase       :				Tuple         =					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       :				int         =					parser.parse_args()
    convert_hubert_checkpoint(args.pytorch_dump_folder_path, args.config_path)





from math import factorial

def 				A_					(							a   ,				a					):

      """simple docstring"""



      return factorial(a					) / (factorial(a					) * factorial(n - r					))

def 				A_					(							):

      """simple docstring"""



      SCREAMING_SNAKE_CASE_			:					Union[str, Any]          =       0

      for i in range(1   ,				1_0_1					):
            for j in range(1   ,				i + 1					):
                  if combinations(a   ,				a					) > 1e6:
                        total += 1
      return total


if __name__ == "__main__":
    print(solution())






