Diffusers documentation
MiniMax Music 3
MiniMax Music 3
MiniMax Music 3 est un modèle de génération musicale qui produit des chansons complètes d’une durée maximale de cinq minutes à partir de paroles et d’une description musicale, avec des voix expressives et une structure à long terme.
Le modèle est un hybride d'une étape autorégressive et d'une étape de diffusion : un modèle de langage global de 8B basé sur Qwen3 prédit un jeton audio sémantique par trame, tandis qu'un petit décodeur de profondeur remplit sept codebooks résiduels RVQ, et leurs états cachés fusionnés conditionnent un transformateur de correspondance de flux de 2,4B qui produit des latents Flow-VAE dans des blocs superposés. Un décodeur de type DAC convertit les latents en audio stéréo à 44,1 kHz.
Utilisation
MiniMax Music 3 est disponible sous forme de pipeline modulaire.
import soundfile as sf
import torch
from diffusers import ModularPipeline
pipe = ModularPipeline.from_pretrained("MiniMaxAI/MiniMax-Music3")
pipe.load_components(dtype=torch.bfloat16)
pipe.to("cuda") # or "mps", "xpu", "cpu"
lyrics = """[verse]
Morning light filtering through the pine
Every quiet street is yours and mine
[chorus]
Softly the world begins to breathe"""
prompt = (
"Genre: acoustic pop. BPM: 96. Key: C major. Warm and intimate, building gently into the chorus. "
"Vocals: soft female lead, close and breathy, light stacked harmonies in the chorus. "
"Arrangement: fingerpicked guitar and soft piano; brushed drums and upright bass enter in the chorus."
)
audio = pipe(
prompt=prompt,
lyrics=lyrics,
audio_duration=60.0,
generator=torch.Generator("cuda").manual_seed(7),
output="audios",
)[0]
sf.write("minimax_music3.wav", audio.T, pipe.sampling_rate)Réduire l'utilisation de la mémoire
Reportez-vous au guide Réduire l'utilisation de la mémoire pour plus de détails sur les différentes techniques d'économie de mémoire.
Le pipeline complet nécessite environ 23 Go de VRAM en bfloat16. Avec le déchargement automatique sur CPU, une génération s'exécute avec environ 22 Go de VRAM libre, et le déchargement par groupe du modèle de langage permet de tenir dans 8 Go.
import torch
from diffusers import ComponentsManager, ModularPipeline
from diffusers.hooks.group_offloading import apply_group_offloading
manager = ComponentsManager()
manager.enable_auto_cpu_offload(device="cuda") # or "mps", "xpu", "cpu"
pipe = ModularPipeline.from_pretrained("MiniMaxAI/MiniMax-Music3", components_manager=manager)
pipe.load_components(dtype=torch.bfloat16)
# Only needed below ~22 GB of free VRAM — slower, but fits in 8 GB.
apply_group_offloading(
pipe.language_model, onload_device=torch.device("cuda"), offload_type="leaf_level", use_stream=True
)Astuces
- Les balises de structure telles que
[intro],[verse],[pre-chorus],[chorus],[bridge],[instrumental],[solo]et[outro]doivent chacune être placées sur leur propre ligne danslyrics. Le texte situé sur la même ligne qu’une balise d’ouverture est ignoré par le contrat d’entrée du modèle. - La description musicale contrôle les voix : décrivez explicitement le genre et le timbre vocal (par exemple « voix féminine chaleureuse »), sinon le modèle peut dériver vers un rendu instrumental. Pour un contrôle fin, structurez la description en métadonnées globales (genre, BPM, tonalité, progression émotionnelle), détails vocaux et arrangement.
audio_durationest une limite supérieure — le modèle de langage peut mettre fin à la chanson plus tôt à l'aide d'un jeton d'arrêt. L'étape autorégressive génère 25 images par seconde d'audio et domine le temps d'exécution.- L'échelle de guidage sans classifieur de l'étape de flow-matching est un paramètre de guider (la valeur de référence pour l'inférence est 1.7) : remplacez-le par
pipe.update_components(guider=ClassifierFreeGuidance(guidance_scale=...)). - Le pipeline renvoie la sortie stéréo native du vocodeur à 44,1 kHz. Le serveur de référence effectue en outre un rééchantillonnage à 32 kHz ; appliquez votre propre rééchantillonnage si vous avez besoin de cette fréquence exacte.
MiniMaxMusic3ModularPipeline
classe diffusers.MiniMaxMusic3ModularPipeline
< source >( blocks: diffusers.modular_pipelines.modular_pipeline.ModularPipelineBlocks | None = Nonepretrained_model_name_or_path: str | os.PathLike | None = Nonecomponents_manager: diffusers.modular_pipelines.components_manager.ComponentsManager | None = Nonecollection: str | None = Noneworkflow: str | None = Nonemodular_config_dict: dict[str, typing.Any] | None = Noneconfig_dict: dict[str, typing.Any] | None = None**kwargs )
Un ModularPipeline pour la génération de musique conditionnée par des paroles et des légendes avec MiniMax Music 3.
MiniMaxMusic3Blocks
Pipeline modulaire pour la génération de musique conditionnée par des paroles et des légendes à l'aide de MiniMax Music 3. Un modèle de langage autoregressive Qwen3 génère des codes sémantiques par image et des états cachés à partir des paroles et de la description musicale ; un transformer flow-matching transforme les états cachés en latents Flow-VAE par blocs ; et un vocoder de type DAC les décode en une forme d'onde stéréo à 44,1 kHz.
Composants :
tokenizer (Qwen2Tokenizer) language_model (Qwen3ForCausalLM) rvq_depth_decoder
(MiniMaxMusic3RVQDepthDecoder) condition_encoder (MiniMaxMusic3ConditionEncoder) transformer
(MiniMaxMusic3Transformer1DModel) scheduler (FlowMatchEulerDiscreteScheduler) guider
(ClassifierFreeGuidance) vocoder (MiniMaxMusic3Vocoder)
Entrées :
prompt (str) :
La description de la musique (genre, ambiance, voix, instrumentation, arrangement).
lyrics (str) :
Les paroles à chanter. Les balises de structure telles que [verse] ou [chorus] doivent chacune être sur leur propre ligne ; le texte
sur la même ligne qu'une balise initiale est ignoré par le contrat d'entrée du point de contrôle.
audio_duration (float, facultatif, valeur par défaut 60.0) :
Limite supérieure de la durée de l'audio généré, en secondes. Le modèle de langage peut s'arrêter plus tôt. Plafonné à 9000
images (six minutes).
generator (Generator, facultatif) :
Générateur Torch pour une génération déterministe.
num_inference_steps (int, facultatif, valeur par défaut 30) :
Nombre d'étapes d'Euler de flow-matching par bloc.
output_type (str, facultatif, valeur par défaut np) :
Format de sortie : ‘np’ ou ‘pt’.
Sorties :
audios (Tensor | ndarray) :
La forme d'onde stéréo générée de forme (batch, channels, samples) dans [-1, 1].
MiniMaxMusic3ConditionEncoder
classe diffusers.MiniMaxMusic3ConditionEncoder
< source >( condition_hidden_dim: int = 4096num_condition_layers: int = 8out_dim: int = 2048input_sampling_rate: int = 24000input_hop_length: int = 960output_sampling_rate: int = 44100output_hop_length: int = 512 )
Projette les états cachés par image de l'étape autorégressive sur la chronologie latente du Flow-VAE.
Chaque image générée porte num_condition_layers états cachés de taille condition_hidden_dim (un provenant du modèle de langage et un par étape de codebook résiduel). Ils sont mélangés avec des poids softmax appris, projetés, puis rééchantillonnés du taux d’images du modèle de langage au taux d’images latent par interpolation du plus proche voisin.
forward
< source >( hidden_states: Tensor ) → torch.Tensor of shape (batch, latent_length, out_dim)
Paramètres
- hidden_states (
torch.Tensorde forme(batch, frames, num_condition_layers * condition_hidden_dim)) — États cachés par image concaténés issus de l'étape autorégressive.
Retourne
torch.Tensor de forme (batch, latent_length, out_dim)
la séquence de conditionnement alignée sur les latents.
MiniMaxMusic3RVQDepthDecoder
classe diffusers.MiniMaxMusic3RVQDepthDecoder
< source >( hidden_size: int = 4096num_layers: int = 4num_attention_heads: int = 16intermediate_size: int = 6144audio_vocab_size: int = 1024num_codebooks: int = 8max_position_embeddings: int = 16 )
Le modèle de langage local de MiniMax Music 3. Au sein de chaque trame audio, il prédit de manière auto-régressive les sept codebooks RVQ résiduels (c1..c7) à partir de l'état caché du modèle de langage global et du code sémantique de la trame, et expose les états cachés par étape qui conditionnent le transformateur de flow-matching.
Il possède également la table d’incorporation pour les codebooks résiduels, que le pipeline utilise pour incorporer des images complètes dans la boucle de rétroaction du modèle de langage global.
forward
< source >( inputs_embeds: Tensor ) → torch.Tensor of shape (batch, steps, hidden_size)
Paramètres
- inputs_embeds (
torch.Tensorde forme(batch, steps, hidden_size)) — Embeddings de séquences de profondeur projetés : l'état caché global suivi des codes intégrés échantillonnés jusqu'à présent, chacun passé à traversprojection.
Retourne
torch.Tensor de forme (batch, steps, hidden_size)
états cachés normalisés ; l'étape suivante alimente la tête de codebook suivante.
MiniMaxMusic3Vocoder
classe diffusers.MiniMaxMusic3Vocoder
< source >( latent_channels: int = 128decoder_input_dim: int = 1024decoder_hidden_dim: int = 1536upsampling_ratios: tuple = (8, 8, 4, 2)sampling_rate: int = 44100 )
Le décodeur d’ondes Flow-VAE de MiniMax Music 3 (un décodeur de type DAC). Il décode des latents appariés par flux de forme (batch, latent_channels, length) en ondes stéréo à sampling_rate ; les deux canaux audio sont décodés en tant que deux flux pliés de latent_channels // 2.
forward
< source >( latents: Tensor ) → torch.Tensor of shape (batch, 2, samples)