




'''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()
_SCREAMING_SNAKE_CASE							:   Tuple      		= logging.get_logger(__name__)


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


def      UpperCamelCase_(	snake_case							:       List[str]     ):

							'''simple docstring'''






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


def      UpperCamelCase_(	snake_case							:       Union[str, Any]							,				snake_case							:       Union[str, Any]     ):

							'''simple docstring'''






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


def      UpperCamelCase_(	snake_case							:       List[Any]     ):

							'''simple docstring'''






							if checkpoint == "small":
														# default config values
														snake_case_						=      1_0_2_4
														snake_case_						=      2_4
														snake_case_						=      1_6
							elif checkpoint == "medium":
														snake_case_						=      1_5_3_6
														snake_case_						=      4_8
														snake_case_						=      2_4
							elif checkpoint == "large":
														snake_case_						=      2_0_4_8
														snake_case_						=      4_8
														snake_case_						=      3_2
							else:
														raise ValueError(f'Checkpoint should be one of `[\'small\', \'medium\', \'large\']`, got {checkpoint}.'     )
							snake_case_						=      MusicgenDecoderConfig(
							    hidden_size=snake_case							,				ffn_dim=hidden_size * 4							,				num_hidden_layers=snake_case							,				num_attention_heads=snake_case							,				)
							return config


@torch.no_grad()
def      UpperCamelCase_(	snake_case							:       List[Any]							,				snake_case							:       int=None							,				snake_case							:       str=None							,				snake_case							:       Optional[Any]="cpu"     ):

							'''simple docstring'''






							snake_case_						=      MusicGen.get_pretrained(snake_case							,				device=snake_case     )
							snake_case_						=      decoder_config_from_checkpoint(snake_case     )

							snake_case_						=      fairseq_model.lm.state_dict()
							snake_case_					,      snake_case_						=      rename_state_dict(
							    snake_case							,				hidden_size=decoder_config.hidden_size     )

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

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

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

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

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

							# init the composite model
							snake_case_						=      MusicgenForConditionalGeneration(text_encoder=snake_case							,				audio_encoder=snake_case							,				decoder=snake_case     )

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

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

							with torch.no_grad():
														snake_case_						=      model(input_ids=snake_case							,				decoder_input_ids=snake_case     ).logits

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

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

							snake_case_						=      MusicgenProcessor(feature_extractor=snake_case							,				tokenizer=snake_case     )

							# set the appropriate bos/pad token ids
							snake_case_						=      2_0_4_8
							snake_case_						=      2_0_4_8

							# set other default generation config params
							snake_case_						=      int(3_0 * audio_encoder.config.frame_rate     )
							snake_case_						=      True
							snake_case_						=      3.0

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

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


if __name__ == "__main__":
		_SCREAMING_SNAKE_CASE							:   Union[str, Any]      		= 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."
		)

		_SCREAMING_SNAKE_CASE							:   List[str]      		= parser.parse_args()
		convert_musicgen_checkpoint(args.checkpoint, args.pytorch_dump_folder, args.push_to_hub)








'''simple docstring'''

from __future__ import annotations

def _SCREAMING_SNAKE_CASE      (A  , A       )       ->       list[list[int]]:






       """simple docstring"""







       lowercase__      			= []
       create_all_state(1  , A  , A  , []  , A       )
       return result

def _SCREAMING_SNAKE_CASE      (A  , A  , A  , A  , A  , )       ->       None:






       """simple docstring"""







       if level == 0:
              total_list.append(current_list[:]       )
              return

       for i in range(A  , total_number - level + 2       ):
              current_list.append(A       )
              create_all_state(i + 1  , A  , level - 1  , A  , A       )
              current_list.pop()

def _SCREAMING_SNAKE_CASE      (A       )       ->       None:






       """simple docstring"""







       for i in total_list:
              print(*A       )


if __name__ == "__main__":
 lowerCamelCase							:   Tuple  						=	4
 lowerCamelCase							:   Union[str, Any]  						=	2
 lowerCamelCase							:   Dict  						=	generate_all_combinations(n, k)
 print_all_state(total_list)




