






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__			:    List[Any]         =				logging.get_logger(__name__)


A__			:    List[Any]         =				['model.decoder.embed_positions.weights']






def 						a    (		lowerCamelCase_       ):






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






def 						a    (		lowerCamelCase_	,     lowerCamelCase_       ):






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






def 						a    (		lowerCamelCase_       ):






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






@torch.no_grad()
def 						a    (		lowerCamelCase_	,     lowerCamelCase_=None	,     lowerCamelCase_=None	,     lowerCamelCase_="cpu"       ):






				'''simple docstring'''
				lowercase__     				=    MusicGen.get_pretrained(lowerCamelCase_	,     device=lowerCamelCase_       )
				lowercase__     				=    decoder_config_from_checkpoint(lowerCamelCase_       )

				lowercase__     				=    fairseq_model.lm.state_dict()
				lowercase__				,		lowercase__     				=    rename_state_dict(
				    lowerCamelCase_	,     hidden_size=decoder_config.hidden_size       )

				lowercase__     				=    TaEncoderModel.from_pretrained('''t5-base'''       )
				lowercase__     				=    EncodecModel.from_pretrained('''facebook/encodec_32khz'''       )
				lowercase__     				=    MusicgenForCausalLM(lowerCamelCase_       ).eval()

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

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

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

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

				# init the composite model
				lowercase__     				=    MusicgenForConditionalGeneration(text_encoder=lowerCamelCase_	,     audio_encoder=lowerCamelCase_	,     decoder=lowerCamelCase_       )

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

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

				with torch.no_grad():
								lowercase__     				=    model(input_ids=lowerCamelCase_	,     decoder_input_ids=lowerCamelCase_       ).logits

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

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

				lowercase__     				=    MusicgenProcessor(feature_extractor=lowerCamelCase_	,     tokenizer=lowerCamelCase_       )

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

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

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

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


if __name__ == "__main__":
							A__			:    str         =				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__			:    Optional[int]         =				parser.parse_args()
							convert_musicgen_checkpoint(args.checkpoint, args.pytorch_dump_folder, args.push_to_hub)












from functools import reduce

A__			:    Union[str, Any]         =				(
    '73167176531330624919225119674426574742355349194934'
    '96983520312774506326239578318016984801869478851843'
    '85861560789112949495459501737958331952853208805511'
    '12540698747158523863050715693290963295227443043557'
    '66896648950445244523161731856403098711121722383113'
    '62229893423380308135336276614282806444486645238749'
    '30358907296290491560440772390713810515859307960866'
    '70172427121883998797908792274921901699720888093776'
    '65727333001053367881220235421809751254540594752243'
    '52584907711670556013604839586446706324415722155397'
    '53697817977846174064955149290862569321978468622482'
    '83972241375657056057490261407972968652414535100474'
    '82166370484403199890008895243450658541227588666881'
    '16427171479924442928230863465674813919123162824586'
    '17866458359124566529476545682848912883142607690042'
    '24219022671055626321111109370544217506941658960408'
    '07198403850962455444362981230987879927244284909188'
    '84580156166097919133875499200524063689912560717606'
    '05886116467109405077541002256983155200055935729725'
    '71636269561882670428252483600823257530420752963450'
)






def 						a    (		lowerCamelCase_ = N       ):






				'''simple docstring'''
				return max(
				    # mypy cannot properly interpret reduce
				    int(reduce(lambda lowerCamelCase_	,     lowerCamelCase_       : str(int(lowerCamelCase_       ) * int(lowerCamelCase_       )       )	,     n[i : i + 13]       )       )
				    for i in range(len(lowerCamelCase_       ) - 12       )       )


if __name__ == "__main__":
							print(F"{solution() = }")




