



"""simple docstring"""
import gc
import math
import unittest

import torch

from diffusers import UNetaDModel
from diffusers.utils import floats_tensor, logging, slow, torch_all_close, torch_device
from diffusers.utils.testing_utils import enable_full_determinism

from .test_modeling_common import ModelTesterMixin, UNetTesterMixin


A:   str								=		logging.get_logger(__name__)

enable_full_determinism()



class       SCREAMING_SNAKE_CASE__  (					UpperCAmelCase__      ,			UpperCAmelCase__      ,			unittest.TestCase ):
   __lowerCAmelCase  :   Optional[Any]						=						UNetaDModel
   __lowerCAmelCase  :   Tuple						=						'sample'

   @property
   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      Union[str, Any]:





    '''simple docstring'''




    UpperCAmelCase	:					Optional[int]	=	4
    UpperCAmelCase	:					Dict	=	3
    UpperCAmelCase	:					Optional[Any]	=	(32, 32)

    UpperCAmelCase	:					Optional[int]	=	floats_tensor((batch_size, num_channels) + sizes						).to(_SCREAMING_SNAKE_CASE						)
    UpperCAmelCase	:					List[str]	=	torch.tensor([10]						).to(_SCREAMING_SNAKE_CASE						)

    return {"sample": noise, "timestep": time_step}

   @property
   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      Any:





    '''simple docstring'''




    return (3, 32, 32)

   @property
   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      Optional[Any]:





    '''simple docstring'''




    return (3, 32, 32)




   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      List[Any]:





    '''simple docstring'''




    UpperCAmelCase	:					int	=	{
        """block_out_channels""": (32, 64),
        """down_block_types""": ("""DownBlock2D""", """AttnDownBlock2D"""),
        """up_block_types""": ("""AttnUpBlock2D""", """UpBlock2D"""),
        """attention_head_dim""": 3,
        """out_channels""": 3,
        """in_channels""": 3,
        """layers_per_block""": 2,
        """sample_size""": 32,
    }
    UpperCAmelCase	:					List[str]	=	self.dummy_input
    return init_dict, inputs_dict



class       SCREAMING_SNAKE_CASE__  (					UpperCAmelCase__      ,			UpperCAmelCase__      ,			unittest.TestCase ):
   __lowerCAmelCase  :   int						=						UNetaDModel
   __lowerCAmelCase  :   List[str]						=						'sample'

   @property
   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      str:





    '''simple docstring'''




    UpperCAmelCase	:					str	=	4
    UpperCAmelCase	:					str	=	4
    UpperCAmelCase	:					Any	=	(32, 32)

    UpperCAmelCase	:					int	=	floats_tensor((batch_size, num_channels) + sizes						).to(_SCREAMING_SNAKE_CASE						)
    UpperCAmelCase	:					str	=	torch.tensor([10]						).to(_SCREAMING_SNAKE_CASE						)

    return {"sample": noise, "timestep": time_step}

   @property
   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      Tuple:





    '''simple docstring'''




    return (4, 32, 32)

   @property
   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      Tuple:





    '''simple docstring'''




    return (4, 32, 32)

   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      Any:





    '''simple docstring'''




    UpperCAmelCase	:					int	=	{
        """sample_size""": 32,
        """in_channels""": 4,
        """out_channels""": 4,
        """layers_per_block""": 2,
        """block_out_channels""": (32, 64),
        """attention_head_dim""": 32,
        """down_block_types""": ("""DownBlock2D""", """DownBlock2D"""),
        """up_block_types""": ("""UpBlock2D""", """UpBlock2D"""),
    }
    UpperCAmelCase	:					Tuple	=	self.dummy_input
    return init_dict, inputs_dict

   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      Any:





    '''simple docstring'''




    UpperCAmelCase	,		UpperCAmelCase	:					List[Any]	=	UNetaDModel.from_pretrained("""fusing/unet-ldm-dummy-update"""      ,     output_loading_info=_SCREAMING_SNAKE_CASE						)

    self.assertIsNotNone(_SCREAMING_SNAKE_CASE						)
    self.assertEqual(len(loading_info["""missing_keys"""]						)      ,     0						)

    model.to(_SCREAMING_SNAKE_CASE						)
    UpperCAmelCase	:					Optional[Any]	=	model(**self.dummy_input						).sample

    assert image is not None, "Make sure output is not None"

   @unittest.skipIf(torch_device != """cuda"""      ,     """This test is supposed to run on GPU"""						)
   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      str:





    '''simple docstring'''




    UpperCAmelCase	,		UpperCAmelCase	:					Dict	=	UNetaDModel.from_pretrained("""fusing/unet-ldm-dummy-update"""      ,     output_loading_info=_SCREAMING_SNAKE_CASE						)
    model.to(_SCREAMING_SNAKE_CASE						)
    UpperCAmelCase	:					str	=	model(**self.dummy_input						).sample

    assert image is not None, "Make sure output is not None"

   @unittest.skipIf(torch_device != """cuda"""      ,     """This test is supposed to run on GPU"""						)
   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      Tuple:





    '''simple docstring'''




    UpperCAmelCase	,		UpperCAmelCase	:					Optional[Any]	=	UNetaDModel.from_pretrained("""fusing/unet-ldm-dummy-update"""      ,     output_loading_info=_SCREAMING_SNAKE_CASE						)
    model_accelerate.to(_SCREAMING_SNAKE_CASE						)
    model_accelerate.eval()

    UpperCAmelCase	:					Union[str, Any]	=	torch.randn(
        1      ,     model_accelerate.config.in_channels      ,     model_accelerate.config.sample_size      ,     model_accelerate.config.sample_size      ,     generator=torch.manual_seed(0						)      ,     )
    UpperCAmelCase	:					Dict	=	noise.to(_SCREAMING_SNAKE_CASE						)
    UpperCAmelCase	:					Optional[int]	=	torch.tensor([10] * noise.shape[0]						).to(_SCREAMING_SNAKE_CASE						)

    UpperCAmelCase	:					int	=	model_accelerate(_SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE						)["""sample"""]

    # two models don't need to stay in the device at the same time
    del model_accelerate
    torch.cuda.empty_cache()
    gc.collect()

    UpperCAmelCase	,		UpperCAmelCase	:					Union[str, Any]	=	UNetaDModel.from_pretrained(
        """fusing/unet-ldm-dummy-update"""      ,     output_loading_info=_SCREAMING_SNAKE_CASE      ,     low_cpu_mem_usage=_SCREAMING_SNAKE_CASE						)
    model_normal_load.to(_SCREAMING_SNAKE_CASE						)
    model_normal_load.eval()
    UpperCAmelCase	:					int	=	model_normal_load(_SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE						)["""sample"""]

    assert torch_all_close(_SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     rtol=1E-3						)




   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      Dict:





    '''simple docstring'''




    UpperCAmelCase	:					int	=	UNetaDModel.from_pretrained("""fusing/unet-ldm-dummy-update"""						)
    model.eval()
    model.to(_SCREAMING_SNAKE_CASE						)

    UpperCAmelCase	:					Tuple	=	torch.randn(
        1      ,     model.config.in_channels      ,     model.config.sample_size      ,     model.config.sample_size      ,     generator=torch.manual_seed(0						)      ,     )
    UpperCAmelCase	:					Optional[Any]	=	noise.to(_SCREAMING_SNAKE_CASE						)
    UpperCAmelCase	:					Optional[Any]	=	torch.tensor([10] * noise.shape[0]						).to(_SCREAMING_SNAKE_CASE						)

    with torch.no_grad():
     UpperCAmelCase	:					List[Any]	=	model(_SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE						).sample

    UpperCAmelCase	:					Tuple	=	output[0, -1, -3:, -3:].flatten().cpu()
    # fmt: off
    UpperCAmelCase	:					List[Any]	=	torch.tensor([-13.3258, -20.1100, -15.9873, -17.6617, -23.0596, -17.9419, -13.3675, -16.1889, -12.3800]						)
    # fmt: on

    self.assertTrue(torch_all_close(_SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     rtol=1E-3						)						)



class       SCREAMING_SNAKE_CASE__  (					UpperCAmelCase__      ,			UpperCAmelCase__      ,			unittest.TestCase ):
   __lowerCAmelCase  :   List[str]						=						UNetaDModel
   __lowerCAmelCase  :   List[str]						=						'sample'

   @property
   def 	SCREAMING_SNAKE_CASE     (   self      ,     _SCREAMING_SNAKE_CASE=(32, 32)						)  ->      str:





    '''simple docstring'''




    UpperCAmelCase	:					Optional[Any]	=	4
    UpperCAmelCase	:					Tuple	=	3

    UpperCAmelCase	:					List[str]	=	floats_tensor((batch_size, num_channels) + sizes						).to(_SCREAMING_SNAKE_CASE						)
    UpperCAmelCase	:					Dict	=	torch.tensor(batch_size * [10]						).to(dtype=torch.intaa      ,     device=_SCREAMING_SNAKE_CASE						)

    return {"sample": noise, "timestep": time_step}

   @property
   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      Any:





    '''simple docstring'''




    return (3, 32, 32)

   @property
   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      str:





    '''simple docstring'''




    return (3, 32, 32)

   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      int:





    '''simple docstring'''




    UpperCAmelCase	:					int	=	{
        """block_out_channels""": [32, 64, 64, 64],
        """in_channels""": 3,
        """layers_per_block""": 1,
        """out_channels""": 3,
        """time_embedding_type""": """fourier""",
        """norm_eps""": 1E-6,
        """mid_block_scale_factor""": math.sqrt(2.0						),
        """norm_num_groups""": None,
        """down_block_types""": [
            """SkipDownBlock2D""",
            """AttnSkipDownBlock2D""",
            """SkipDownBlock2D""",
            """SkipDownBlock2D""",
        ],
        """up_block_types""": [
            """SkipUpBlock2D""",
            """SkipUpBlock2D""",
            """AttnSkipUpBlock2D""",
            """SkipUpBlock2D""",
        ],
    }
    UpperCAmelCase	:					Optional[Any]	=	self.dummy_input
    return init_dict, inputs_dict

   @slow
   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      Any:





    '''simple docstring'''




    UpperCAmelCase	,		UpperCAmelCase	:					List[Any]	=	UNetaDModel.from_pretrained("""google/ncsnpp-celebahq-256"""      ,     output_loading_info=_SCREAMING_SNAKE_CASE						)
    self.assertIsNotNone(_SCREAMING_SNAKE_CASE						)
    self.assertEqual(len(loading_info["""missing_keys"""]						)      ,     0						)

    model.to(_SCREAMING_SNAKE_CASE						)
    UpperCAmelCase	:					Dict	=	self.dummy_input
    UpperCAmelCase	:					int	=	floats_tensor((4, 3) + (256, 256)						).to(_SCREAMING_SNAKE_CASE						)
    UpperCAmelCase	:					Optional[Any]	=	noise
    UpperCAmelCase	:					Optional[int]	=	model(**_SCREAMING_SNAKE_CASE						)

    assert image is not None, "Make sure output is not None"

   @slow
   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      Tuple:





    '''simple docstring'''




    UpperCAmelCase	:					int	=	UNetaDModel.from_pretrained("""google/ncsnpp-celebahq-256"""						)
    model.to(_SCREAMING_SNAKE_CASE						)

    UpperCAmelCase	:					Optional[Any]	=	4
    UpperCAmelCase	:					Optional[Any]	=	3
    UpperCAmelCase	:					List[Any]	=	(256, 256)

    UpperCAmelCase	:					int	=	torch.ones((batch_size, num_channels) + sizes						).to(_SCREAMING_SNAKE_CASE						)
    UpperCAmelCase	:					Optional[Any]	=	torch.tensor(batch_size * [1E-4]						).to(_SCREAMING_SNAKE_CASE						)

    with torch.no_grad():
     UpperCAmelCase	:					Dict	=	model(_SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE						).sample

    UpperCAmelCase	:					str	=	output[0, -3:, -3:, -1].flatten().cpu()
    # fmt: off
    UpperCAmelCase	:					Optional[int]	=	torch.tensor([-4842.8691, -6499.6631, -3800.1953, -7978.2686, -1_0980.7129, -2_0028.8535, 8148.2822, 2342.2905, 567.7608]						)
    # fmt: on

    self.assertTrue(torch_all_close(_SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     rtol=1E-2						)						)

   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      Dict:





    '''simple docstring'''




    UpperCAmelCase	:					int	=	UNetaDModel.from_pretrained("""fusing/ncsnpp-ffhq-ve-dummy-update"""						)
    model.to(_SCREAMING_SNAKE_CASE						)

    UpperCAmelCase	:					Dict	=	4
    UpperCAmelCase	:					Optional[int]	=	3
    UpperCAmelCase	:					Optional[Any]	=	(32, 32)

    UpperCAmelCase	:					List[Any]	=	torch.ones((batch_size, num_channels) + sizes						).to(_SCREAMING_SNAKE_CASE						)
    UpperCAmelCase	:					int	=	torch.tensor(batch_size * [1E-4]						).to(_SCREAMING_SNAKE_CASE						)

    with torch.no_grad():
     UpperCAmelCase	:					int	=	model(_SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE						).sample

    UpperCAmelCase	:					Any	=	output[0, -3:, -3:, -1].flatten().cpu()
    # fmt: off
    UpperCAmelCase	:					int	=	torch.tensor([-0.0325, -0.0900, -0.0869, -0.0332, -0.0725, -0.0270, -0.0101, 0.0227, 0.0256]						)
    # fmt: on

    self.assertTrue(torch_all_close(_SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     rtol=1E-2						)						)




   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      Union[str, Any]:





    '''simple docstring'''




    pass





"""simple docstring"""
import argparse

import torch

# Step 1. clone https://github.com/microsoft/unilm
# Step 2. git checkout to https://github.com/microsoft/unilm/commit/b94ec76c36f02fb2b0bf0dcb0b8554a2185173cd
# Step 3. cd unilm
# Step 4. ln -s $(realpath wavlm/modules.py) ./  # create simlink
# import classes
from unilm.wavlm.WavLM import WavLM as WavLMOrig
from unilm.wavlm.WavLM import WavLMConfig as WavLMConfigOrig

from transformers import WavLMConfig, WavLMModel, logging


logging.set_verbosity_info()
A:   Optional[int]								=		logging.get_logger(__name__)

A:   Tuple								=		{
    "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.grep_linear": "encoder.layers.*.attention.gru_rel_pos_linear",
    "self_attn.relative_attention_bias": "encoder.layers.*.attention.rel_attn_embed",
    "self_attn.grep_a": "encoder.layers.*.attention.gru_rel_pos_const",
    "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": "ctc_proj",
    "mask_emb": "masked_spec_embed",
}
A:   List[str]								=		[
    "ctc_proj",
    "quantizer.weight_proj",
    "quantizer.codevectors",
    "project_q",
    "project_hid",
]

def       _snake_case						(						UpperCamelCase						:		str			,		UpperCamelCase						:		Tuple			,		UpperCamelCase						:		Optional[int]			,		UpperCamelCase						:		Tuple			,		UpperCamelCase						:		Any						):
 for attribute in key.split("""."""						):
  UpperCAmelCase	:					Optional[Any]	=	getattr(UpperCamelCase			,		UpperCamelCase						)

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

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

def       _snake_case						(						UpperCamelCase						:		List[Any]			,		UpperCamelCase						:		Optional[Any]						):
 UpperCAmelCase	:					Tuple	=	[]
 UpperCAmelCase	:					Any	=	fairseq_model.state_dict()

 UpperCAmelCase	:					Tuple	=	hf_model.feature_extractor

 for name, value in fairseq_dict.items():
  UpperCAmelCase	:					str	=	False
  if "conv_layers" in name:
   load_conv_layer(
       UpperCamelCase			,		UpperCamelCase			,		UpperCamelCase			,		UpperCamelCase			,		hf_model.config.feat_extract_norm == """group"""			,		)
   UpperCAmelCase	:					Union[str, Any]	=	True
  else:
   for key, mapped_key in MAPPING.items():
    if key in name or key.split("""w2v_model."""						)[-1] == name.split("""."""						)[0]:
     UpperCAmelCase	:					Dict	=	True
     if "*" in mapped_key:
      UpperCAmelCase	:					str	=	name.split(UpperCamelCase						)[0].split("""."""						)[-2]
      UpperCAmelCase	:					Tuple	=	mapped_key.replace("""*"""			,		UpperCamelCase						)
     if "weight_g" in name:
      UpperCAmelCase	:					Any	=	"""weight_g"""
     elif "weight_v" in name:
      UpperCAmelCase	:					Optional[Any]	=	"""weight_v"""
     elif "bias" in name and "relative_attention_bias" not in name:
      UpperCAmelCase	:					Union[str, Any]	=	"""bias"""
     elif "weight" in name:
      # TODO: don't match quantizer.weight_proj
      UpperCAmelCase	:					str	=	"""weight"""
     else:
      UpperCAmelCase	:					Optional[Any]	=	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       _snake_case						(						UpperCamelCase						:		Optional[Any]			,		UpperCamelCase						:		Dict			,		UpperCamelCase						:		Tuple			,		UpperCamelCase						:		Any			,		UpperCamelCase						:		Any						):
 UpperCAmelCase	:					str	=	full_name.split("""conv_layers."""						)[-1]
 UpperCAmelCase	:					Dict	=	name.split("""."""						)
 UpperCAmelCase	:					List[str]	=	int(items[0]						)
 UpperCAmelCase	:					Any	=	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	:					Optional[Any]	=	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	:					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."
   )
   UpperCAmelCase	:					str	=	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	:					Optional[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       _snake_case						(						UpperCamelCase						:		int			,		UpperCamelCase						:		List[Any]			,		UpperCamelCase						:		List[Any]=None						):
 # load the pre-trained checkpoints
 UpperCAmelCase	:					List[Any]	=	torch.load(UpperCamelCase						)
 UpperCAmelCase	:					List[str]	=	WavLMConfigOrig(checkpoint["""cfg"""]						)
 UpperCAmelCase	:					Optional[int]	=	WavLMOrig(UpperCamelCase						)
 model.load_state_dict(checkpoint["""model"""]						)
 model.eval()

 if config_path is not None:
  UpperCAmelCase	:					List[str]	=	WavLMConfig.from_pretrained(UpperCamelCase						)
 else:
  UpperCAmelCase	:					List[Any]	=	WavLMConfig()

 UpperCAmelCase	:					Any	=	WavLMModel(UpperCamelCase						)

 recursively_load_weights(UpperCamelCase			,		UpperCamelCase						)

 hf_wavlm.save_pretrained(UpperCamelCase						)


if __name__ == "__main__":
      A:   int								=		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("--config_path", default=None, type=str, help="Path to hf config.json of model to convert")
      A:   Tuple								=		parser.parse_args()
      convert_wavlm_checkpoint(args.checkpoint_path, args.pytorch_dump_folder_path, args.config_path)
