





'''simple docstring'''

import argparse
from pathlib import Path
from typing import Dict, OrderedDict, Tuple

import torch
from audiocraft.models import MusicGen

from transformers import (
    AutoFeatureExtractor,
    AutoTokenizer,
    EncodecModel,
    MusicgenDecoderConfig,
    MusicgenForConditionalGeneration,
    MusicgenProcessor,
    TaEncoderModel,
)
from transformers.models.musicgen.modeling_musicgen import MusicgenForCausalLM
from transformers.utils import logging


logging.set_verbosity_info()
a   	=    logging.get_logger(__name__)


a   	=    ["model.decoder.embed_positions.weights"]

def     __magic_name__							(				__UpperCAmelCase   )    ->       Any:

   '''simple docstring'''







   if "emb" in name:
      __SCREAMING_SNAKE_CASE   				=							name.replace("""emb"""				,						"""model.decoder.embed_tokens"""   )
   if "transformer" in name:
      __SCREAMING_SNAKE_CASE   				=							name.replace("""transformer"""				,						"""model.decoder"""   )
   if "cross_attention" in name:
      __SCREAMING_SNAKE_CASE   				=							name.replace("""cross_attention"""				,						"""encoder_attn"""   )
   if "linear1" in name:
      __SCREAMING_SNAKE_CASE   				=							name.replace("""linear1"""				,						"""fc1"""   )
   if "linear2" in name:
      __SCREAMING_SNAKE_CASE   				=							name.replace("""linear2"""				,						"""fc2"""   )
   if "norm1" in name:
      __SCREAMING_SNAKE_CASE   				=							name.replace("""norm1"""				,						"""self_attn_layer_norm"""   )
   if "norm_cross" in name:
      __SCREAMING_SNAKE_CASE   				=							name.replace("""norm_cross"""				,						"""encoder_attn_layer_norm"""   )
   if "norm2" in name:
      __SCREAMING_SNAKE_CASE   				=							name.replace("""norm2"""				,						"""final_layer_norm"""   )
   if "out_norm" in name:
      __SCREAMING_SNAKE_CASE   				=							name.replace("""out_norm"""				,						"""model.decoder.layer_norm"""   )
   if "linears" in name:
      __SCREAMING_SNAKE_CASE   				=							name.replace("""linears"""				,						"""lm_heads"""   )
   if "condition_provider.conditioners.description.output_proj" in name:
      __SCREAMING_SNAKE_CASE   				=							name.replace("""condition_provider.conditioners.description.output_proj"""				,						"""enc_to_dec_proj"""   )
   return name

def     __magic_name__							(				__UpperCAmelCase				,						__UpperCAmelCase   )    ->       Tuple[Dict, Dict]:

   '''simple docstring'''







   __SCREAMING_SNAKE_CASE   				=							list(state_dict.keys()   )
   __SCREAMING_SNAKE_CASE   				=							{}
   for key in keys:
      __SCREAMING_SNAKE_CASE   				=							state_dict.pop(__UpperCAmelCase   )
      __SCREAMING_SNAKE_CASE   				=							rename_keys(__UpperCAmelCase   )
      if "in_proj_weight" in key:
         # split fused qkv proj
         __SCREAMING_SNAKE_CASE   				=							val[:hidden_size, :]
         __SCREAMING_SNAKE_CASE   				=							val[hidden_size : 2 * hidden_size, :]
         __SCREAMING_SNAKE_CASE   				=							val[-hidden_size:, :]
      elif "enc_to_dec_proj" in key:
         __SCREAMING_SNAKE_CASE   				=							val
      else:
         __SCREAMING_SNAKE_CASE   				=							val
   return state_dict, enc_dec_proj_state_dict

def     __magic_name__							(				__UpperCAmelCase   )    ->       MusicgenDecoderConfig:

   '''simple docstring'''







   if checkpoint == "small":
      # default config values
      __SCREAMING_SNAKE_CASE   				=							1024
      __SCREAMING_SNAKE_CASE   				=							24
      __SCREAMING_SNAKE_CASE   				=							16
   elif checkpoint == "medium":
      __SCREAMING_SNAKE_CASE   				=							1536
      __SCREAMING_SNAKE_CASE   				=							48
      __SCREAMING_SNAKE_CASE   				=							24
   elif checkpoint == "large":
      __SCREAMING_SNAKE_CASE   				=							2048
      __SCREAMING_SNAKE_CASE   				=							48
      __SCREAMING_SNAKE_CASE   				=							32
   else:
      raise ValueError(f"""Checkpoint should be one of `['small', 'medium', 'large']`, got {checkpoint}."""   )
   __SCREAMING_SNAKE_CASE   				=							MusicgenDecoderConfig(
       hidden_size=__UpperCAmelCase				,						ffn_dim=hidden_size * 4				,						num_hidden_layers=__UpperCAmelCase				,						num_attention_heads=__UpperCAmelCase				,						)
   return config

@torch.no_grad()
def     __magic_name__							(				__UpperCAmelCase				,						__UpperCAmelCase=None				,						__UpperCAmelCase=None				,						__UpperCAmelCase="cpu"   )    ->       List[str]:

   '''simple docstring'''







   __SCREAMING_SNAKE_CASE   				=							MusicGen.get_pretrained(__UpperCAmelCase				,						device=__UpperCAmelCase   )
   __SCREAMING_SNAKE_CASE   				=							decoder_config_from_checkpoint(__UpperCAmelCase   )

   __SCREAMING_SNAKE_CASE   				=							fairseq_model.lm.state_dict()
   __SCREAMING_SNAKE_CASE				,  __SCREAMING_SNAKE_CASE   				=							rename_state_dict(
       __UpperCAmelCase				,						hidden_size=decoder_config.hidden_size   )

   __SCREAMING_SNAKE_CASE   				=							TaEncoderModel.from_pretrained("""t5-base"""   )
   __SCREAMING_SNAKE_CASE   				=							EncodecModel.from_pretrained("""facebook/encodec_32khz"""   )
   __SCREAMING_SNAKE_CASE   				=							MusicgenForCausalLM(__UpperCAmelCase   ).eval()

   # load all decoder weights - expect that we'll be missing embeddings and enc-dec projection
   __SCREAMING_SNAKE_CASE				,  __SCREAMING_SNAKE_CASE   				=							decoder.load_state_dict(__UpperCAmelCase				,						strict=__UpperCAmelCase   )

   for key in missing_keys.copy():
      if key.startswith(("""text_encoder""", """audio_encoder""")   ) or key in EXPECTED_MISSING_KEYS:
         missing_keys.remove(__UpperCAmelCase   )

   if len(__UpperCAmelCase   ) > 0:
      raise ValueError(f"""Missing key(s) in state_dict: {missing_keys}"""   )

   if len(__UpperCAmelCase   ) > 0:
      raise ValueError(f"""Unexpected key(s) in state_dict: {unexpected_keys}"""   )

   # init the composite model
   __SCREAMING_SNAKE_CASE   				=							MusicgenForConditionalGeneration(text_encoder=__UpperCAmelCase				,						audio_encoder=__UpperCAmelCase				,						decoder=__UpperCAmelCase   )

   # load the pre-trained enc-dec projection (from the decoder state dict)
   model.enc_to_dec_proj.load_state_dict(__UpperCAmelCase   )

   # check we can do a forward pass
   __SCREAMING_SNAKE_CASE   				=							torch.arange(0				,						8				,						dtype=torch.long   ).reshape(2				,						-1   )
   __SCREAMING_SNAKE_CASE   				=							input_ids.reshape(2 * 4				,						-1   )

   with torch.no_grad():
      __SCREAMING_SNAKE_CASE   				=							model(input_ids=__UpperCAmelCase				,						decoder_input_ids=__UpperCAmelCase   ).logits

   if logits.shape != (8, 1, 2048):
      raise ValueError("""Incorrect shape for logits"""   )

   # now construct the processor
   __SCREAMING_SNAKE_CASE   				=							AutoTokenizer.from_pretrained("""t5-base"""   )
   __SCREAMING_SNAKE_CASE   				=							AutoFeatureExtractor.from_pretrained("""facebook/encodec_32khz"""				,						padding_side="""left"""   )

   __SCREAMING_SNAKE_CASE   				=							MusicgenProcessor(feature_extractor=__UpperCAmelCase				,						tokenizer=__UpperCAmelCase   )

   # set the appropriate bos/pad token ids
   __SCREAMING_SNAKE_CASE   				=							2048
   __SCREAMING_SNAKE_CASE   				=							2048

   # set other default generation config params
   __SCREAMING_SNAKE_CASE   				=							int(30 * audio_encoder.config.frame_rate   )
   __SCREAMING_SNAKE_CASE   				=							True
   __SCREAMING_SNAKE_CASE   				=							3.0

   if pytorch_dump_folder is not None:
      Path(__UpperCAmelCase   ).mkdir(exist_ok=__UpperCAmelCase   )
      logger.info(f"""Saving model {checkpoint} to {pytorch_dump_folder}"""   )
      model.save_pretrained(__UpperCAmelCase   )
      processor.save_pretrained(__UpperCAmelCase   )

   if repo_id:
      logger.info(f"""Pushing model {checkpoint} to {repo_id}"""   )
      model.push_to_hub(__UpperCAmelCase   )
      processor.push_to_hub(__UpperCAmelCase   )


if __name__ == "__main__":
    a   	=    argparse.ArgumentParser()
    # Required parameters
    parser.add_argument(
        "--checkpoint",
        default="small",
        type=str,
        help="Checkpoint size of the MusicGen model you'd like to convert. Can be one of: `['small', 'medium', 'large']`.",
    )
    parser.add_argument(
        "--pytorch_dump_folder",
        required=True,
        default=None,
        type=str,
        help="Path to the output PyTorch model directory.",
    )
    parser.add_argument(
        "--push_to_hub", default=None, type=str, help="Where to upload the converted model on the 🤗 hub."
    )
    parser.add_argument(
        "--device", default="cpu", type=str, help="Torch device to run the conversion, either cpu or cuda."
    )

    a   	=    parser.parse_args()
    convert_musicgen_checkpoint(args.checkpoint, args.pytorch_dump_folder, args.push_to_hub)












def   __snake_case    (       _lowerCAmelCase			:			int						)			->    bool:
   if num < 0:
      return False

   A_       :					int        =      num
   A_       :					int        =      0
   while num > 0:
      A_       :					str        =      rev_num * 10 + (num % 10)
      num //= 10

   return num_copy == rev_num


if __name__ == "__main__":
 import doctest

 doctest.testmod()
