
"""simple docstring"""







import ast
import os
import re
import shutil
import tempfile
import unittest
from unittest import mock

import torch

from accelerate.test_utils.examples import compare_against_test
from accelerate.test_utils.testing import TempDirTestCase, require_trackers, run_command, slow
from accelerate.utils import write_basic_config


# DataLoaders built from `test_samples/MRPC` for quick testing
# Should mock `{script_name}.get_dataloaders` via:
# @mock.patch("{script_name}.get_dataloaders", mocked_dataloaders)

_UpperCamelCase					      =  [
    '''cross_validation.py''',
    '''gradient_accumulation.py''',
    '''local_sgd.py''',
    '''multi_process_metrics.py''',
    '''memory.py''',
    '''automatic_gradient_accumulation.py''',
    '''fsdp_with_peak_mem_tracking.py''',
    '''deepspeed_with_config_support.py''',
    '''megatron_lm_gpt_pretraining.py''',
]







class  lowerCamelCase__ (	unittest.TestCase			):






    def     _UpperCamelCase							(			self     ,A     ,A     ,A = None     ,A = None ):
          UpperCAmelCase          =	None
          UpperCAmelCase          =	os.path.abspath(os.path.join("""examples"""     ,"""by_feature""" ) )
          UpperCAmelCase          =	os.path.abspath("""examples""" )
          for item in os.listdir(__lowerCamelCase ):
                if item not in EXCLUDE_EXAMPLES:
                      UpperCAmelCase          =	os.path.join(__lowerCamelCase     ,__lowerCamelCase )
                      if os.path.isfile(__lowerCamelCase ) and ".py" in item_path:
                            with self.subTest(
                                tested_script=__lowerCamelCase     ,feature_script=__lowerCamelCase     ,tested_section="""main()""" if parser_only else """training_function()"""     ,):
                                  UpperCAmelCase          =	compare_against_test(
                                      os.path.join(__lowerCamelCase     ,__lowerCamelCase )     ,__lowerCamelCase     ,__lowerCamelCase     ,__lowerCamelCase )
                                  UpperCAmelCase          =	"""\n""".join(__lowerCamelCase )
                                  if special_strings is not None:
                                        for string in special_strings:
                                              UpperCAmelCase          =	diff.replace(__lowerCamelCase     ,"""""" )
                                  self.assertEqual(__lowerCamelCase     ,"""""" )






    def     _UpperCamelCase							(			self ):
          self.one_complete_example("""complete_nlp_example.py"""     ,__lowerCamelCase )
          self.one_complete_example("""complete_nlp_example.py"""     ,__lowerCamelCase )






    def     _UpperCamelCase							(			self ):
          UpperCAmelCase          =	os.path.abspath(os.path.join("""examples"""     ,"""cv_example.py""" ) )
          UpperCAmelCase          =	[
              """ """ * 16 + """{\n\n""",
              """ """ * 20 + """\"accuracy\": eval_metric[\"accuracy\"],\n\n""",
              """ """ * 20 + """\"f1\": eval_metric[\"f1\"],\n\n""",
              """ """ * 20 + """\"train_loss\": total_loss.item() / len(train_dataloader),\n\n""",
              """ """ * 20 + """\"epoch\": epoch,\n\n""",
              """ """ * 16 + """},\n\n""",
              """ """ * 16 + """step=epoch,\n""",
              """ """ * 12,
              """ """ * 8 + """for step, batch in enumerate(active_dataloader):\n""",
          ]
          self.one_complete_example("""complete_cv_example.py"""     ,__lowerCamelCase     ,__lowerCamelCase     ,__lowerCamelCase )
          self.one_complete_example("""complete_cv_example.py"""     ,__lowerCamelCase     ,__lowerCamelCase     ,__lowerCamelCase )







@mock.patch.dict(os.environ   ,					{'''TESTING_MOCKED_DATALOADERS''': '''1'''}			)
class  lowerCamelCase__ (	_a			):
    SCREAMING_SNAKE_CASE		=      False






    @classmethod
    def     _UpperCamelCase							(			cls ):
          super().setUpClass()
          UpperCAmelCase          =	tempfile.mkdtemp()
          UpperCAmelCase          =	os.path.join(cls._tmpdir     ,"""default_config.yml""" )

          write_basic_config(save_location=cls.configPath )
          UpperCAmelCase          =	["""accelerate""", """launch""", """--config_file""", cls.configPath]






    @classmethod
    def     _UpperCamelCase							(			cls ):
          super().tearDownClass()
          shutil.rmtree(cls._tmpdir )






    def     _UpperCamelCase							(			self ):
          UpperCAmelCase          =	F'''
        examples/by_feature/checkpointing.py
        --checkpointing_steps epoch
        --output_dir {self.tmpdir}
        '''.split()
          run_command(self._launch_args + testargs )
          self.assertTrue(os.path.exists(os.path.join(self.tmpdir     ,"""epoch_0""" ) ) )






    def     _UpperCamelCase							(			self ):
          UpperCAmelCase          =	F'''
        examples/by_feature/checkpointing.py
        --checkpointing_steps 1
        --output_dir {self.tmpdir}
        '''.split()
          UpperCAmelCase          =	run_command(self._launch_args + testargs )
          self.assertTrue(os.path.exists(os.path.join(self.tmpdir     ,"""step_2""" ) ) )






    def     _UpperCamelCase							(			self ):
          UpperCAmelCase          =	F'''
        examples/by_feature/checkpointing.py
        --resume_from_checkpoint {os.path.join(self.tmpdir     ,'epoch_0' )}
        '''.split()
          UpperCAmelCase          =	run_command(self._launch_args + testargs     ,return_stdout=__lowerCamelCase )
          self.assertNotIn("""epoch 0:"""     ,__lowerCamelCase )
          self.assertIn("""epoch 1:"""     ,__lowerCamelCase )






    def     _UpperCamelCase							(			self ):
          UpperCAmelCase          =	F'''
        examples/by_feature/checkpointing.py
        --resume_from_checkpoint {os.path.join(self.tmpdir     ,'step_2' )}
        '''.split()
          UpperCAmelCase          =	run_command(self._launch_args + testargs     ,return_stdout=__lowerCamelCase )
          if torch.cuda.is_available():
                UpperCAmelCase          =	torch.cuda.device_count()
          else:
                UpperCAmelCase          =	1
          if num_processes > 1:
                self.assertNotIn("""epoch 0:"""     ,__lowerCamelCase )
                self.assertIn("""epoch 1:"""     ,__lowerCamelCase )
          else:
                self.assertIn("""epoch 0:"""     ,__lowerCamelCase )
                self.assertIn("""epoch 1:"""     ,__lowerCamelCase )






    @slow
    def     _UpperCamelCase							(			self ):
          UpperCAmelCase          =	"""
        examples/by_feature/cross_validation.py
        --num_folds 2
        """.split()
          with mock.patch.dict(os.environ     ,{"""TESTING_MOCKED_DATALOADERS""": """0"""} ):
                UpperCAmelCase          =	run_command(self._launch_args + testargs     ,return_stdout=__lowerCamelCase )
                UpperCAmelCase          =	re.findall("""({.+})"""     ,__lowerCamelCase )
                UpperCAmelCase          =	[r for r in results if """accuracy""" in r][-1]
                UpperCAmelCase          =	ast.literal_eval(__lowerCamelCase )
                self.assertGreaterEqual(results["""accuracy"""]     ,0.75 )






    def     _UpperCamelCase							(			self ):
          UpperCAmelCase          =	["""examples/by_feature/multi_process_metrics.py"""]
          run_command(self._launch_args + testargs )






    @require_trackers
    @mock.patch.dict(os.environ     ,{"""WANDB_MODE""": """offline"""} )
    def     _UpperCamelCase							(			self ):
          with tempfile.TemporaryDirectory() as tmpdir:
                UpperCAmelCase          =	F'''
            examples/by_feature/tracking.py
            --with_tracking
            --project_dir {tmpdir}
            '''.split()
                run_command(self._launch_args + testargs )
                self.assertTrue(os.path.exists(os.path.join(__lowerCamelCase     ,"""tracking""" ) ) )






    def     _UpperCamelCase							(			self ):
          UpperCAmelCase          =	["""examples/by_feature/gradient_accumulation.py"""]
          run_command(self._launch_args + testargs )






    def     _UpperCamelCase							(			self ):
          UpperCAmelCase          =	["""examples/by_feature/local_sgd.py"""]
          run_command(self._launch_args + testargs )











"""simple docstring"""







import argparse

import fairseq
import torch

from transformers import UniSpeechSatConfig, UniSpeechSatForCTC, UniSpeechSatForPreTraining, 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""",
    """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""",
}
_UpperCamelCase					      =  [
    """lm_head""",
    """quantizer.weight_proj""",
    """quantizer.codevectors""",
    """project_q""",
    """project_hid""",
    """label_embeddings_concat""",
    """speaker_proj""",
    """layer_norm_for_extract""",
]

def _a			(		_snake_case				,	_snake_case				,	_snake_case				,	_snake_case				,	_snake_case							):







      """simple docstring"""






      for attribute in key.split("""."""							):
            UpperCAmelCase          =	getattr(_snake_case				,	_snake_case							)

      if weight_type is not None:
            UpperCAmelCase          =	getattr(_snake_case				,	_snake_case							).shape
      else:
            UpperCAmelCase          =	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":
            UpperCAmelCase          =	value
      elif weight_type == "weight_g":
            UpperCAmelCase          =	value
      elif weight_type == "weight_v":
            UpperCAmelCase          =	value
      elif weight_type == "bias":
            UpperCAmelCase          =	value
      else:
            UpperCAmelCase          =	value

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

def _a			(		_snake_case				,	_snake_case							):







      """simple docstring"""






      UpperCAmelCase          =	[]
      UpperCAmelCase          =	fairseq_model.state_dict()

      UpperCAmelCase          =	hf_model.unispeech_sat.feature_extractor

      for name, value in fairseq_dict.items():
            UpperCAmelCase          =	False
            if "conv_layers" in name:
                  load_conv_layer(
                      _snake_case				,	_snake_case				,	_snake_case				,	_snake_case				,	hf_model.config.feat_extract_norm == """group"""				,	)
                  UpperCAmelCase          =	True
            else:
                  for key, mapped_key in MAPPING.items():
                        UpperCAmelCase          =	"""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
                              UpperCAmelCase          =	True
                              if "*" in mapped_key:
                                    UpperCAmelCase          =	name.split(_snake_case							)[0].split("""."""							)[-2]
                                    UpperCAmelCase          =	mapped_key.replace("""*"""				,	_snake_case							)
                              if "weight_g" in name:
                                    UpperCAmelCase          =	"""weight_g"""
                              elif "weight_v" in name:
                                    UpperCAmelCase          =	"""weight_v"""
                              elif "bias" in name:
                                    UpperCAmelCase          =	"""bias"""
                              elif "weight" in name:
                                    # TODO: don't match quantizer.weight_proj
                                    UpperCAmelCase          =	"""weight"""
                              else:
                                    UpperCAmelCase          =	None
                              set_recursively(_snake_case				,	_snake_case				,	_snake_case				,	_snake_case				,	_snake_case							)
                        continue
            if not is_used:
                  unused_weights.append(_snake_case							)

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

def _a			(		_snake_case				,	_snake_case				,	_snake_case				,	_snake_case				,	_snake_case							):







      """simple docstring"""






      UpperCAmelCase          =	full_name.split("""conv_layers."""							)[-1]
      UpperCAmelCase          =	name.split("""."""							)
      UpperCAmelCase          =	int(items[0]							)
      UpperCAmelCase          =	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.'''							)
                  UpperCAmelCase          =	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.'''							)
                  UpperCAmelCase          =	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.'''							)
                  UpperCAmelCase          =	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.'''							)
                  UpperCAmelCase          =	value
                  logger.info(F'''Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}.'''							)
      else:
            unused_weights.append(_snake_case							)

@torch.no_grad()
def _a			(		_snake_case				,	_snake_case				,	_snake_case=None				,	_snake_case=None				,	_snake_case=True							):







      """simple docstring"""






      if config_path is not None:
            UpperCAmelCase          =	UniSpeechSatConfig.from_pretrained(_snake_case							)
      else:
            UpperCAmelCase          =	UniSpeechSatConfig()

      UpperCAmelCase          =	""""""

      if is_finetuned:
            UpperCAmelCase          =	UniSpeechSatForCTC(_snake_case							)
      else:
            UpperCAmelCase          =	UniSpeechSatForPreTraining(_snake_case							)

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

      recursively_load_weights(_snake_case				,	_snake_case							)

      hf_wavavec.save_pretrained(_snake_case							)


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("""--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"""
  )
  _UpperCamelCase					      =  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
  )



