# MiniMax Music 3

[MiniMax Music 3](https://huggingface.co/MiniMaxAI/MiniMax-Music3), sözler ve müzik açıklamasından beş dakikaya kadar tam şarkılar üreten, ifade gücü yüksek vokaller ve uzun menzilli yapıya sahip bir müzik üretim modelidir.

Model, otoregresif ve difüzyon aşamalarının bir hibrididir: 8B Qwen3 tabanlı küresel dil modeli, her kare için bir anlamsal ses tokeni öngörürken, küçük bir derinlik çözücü yedi artımsal RVQ kod kitabını doldurur ve bunların birleştirilmiş gizli durumları, üst üste binen parçacıklarda Flow-VAE latentlerini üreten 2.4B akış eşleştirme dönüştürücüsünü koşullandırır. DAC tarzı bir çözücü, latentleri 44.1 kHz stereo sese dönüştürür.

## Kullanım

MiniMax Music 3 modüler bir pipeline olarak kullanılabilir.

```py
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)
```

## Bellek kullanımını azaltın

Çeşitli bellek tasarrufu teknikleri hakkında daha fazla ayrıntı için [Bellek kullanımını azaltma](../../optimization/memory) kılavuzuna bakın.

Tam pipeline, bfloat16'da ~23 GB VRAM gerektirir. Otomatik CPU offloading ile bir üretim ~23 GB boş VRAM'de çalışır ve dil modelinin group-offloading'i ile 8 GB'a sığar.

```py
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
)
```

## İpuçları

- `[intro]`, `[verse]`, `[pre-chorus]`, `[chorus]`, `[bridge]`, `[instrumental]`, `[solo]` ve `[outro]` gibi yapı etiketlerinin her biri `lyrics` içinde kendi satırında olmalıdır. Başlangıç etiketiyle aynı satırda bulunan metin, modelin girdi sözleşmesi tarafından düşürülür.
- Müzik açıklaması vokalleri kontrol eder: vokal cinsiyetini ve timbresini açıkça belirtin (ör. "sıcak kadın vokali") ya da model enstrümantale kayabilir. İnce taneli kontrol için açıklamayı küresel meta veriler (tür, BPM, ton, duygusal ilerleme), vokal detayları ve düzenleme olarak yapılandırın.
- `audio_duration` bir üst sınırdır — dil modeli, bir durdurma belirteciyle şarkıyı daha erken bitirebilir. Otoregresif aşama, saniyede 25 kare ses üretir ve çalışma süresini belirler.
- Flow-matching aşamasının classifier-free guidance ölçeği bir guider ayarıdır (referans çıkarım değeri 1.7'dir): `pipe.update_components(guider=ClassifierFreeGuidance(guidance_scale=...))` ile değiştirin.
- Pipeline, vokoderin yerel 44,1 kHz stereo çıktısını döndürür. Referans sunucu ayrıca 32 kHz'e yeniden örnekler; bu tam hıza ihtiyacınız varsa kendi yeniden örneklemenizi uygulayın.

## MiniMaxMusic3ModularPipeline[[diffusers.MiniMaxMusic3ModularPipeline]]

#### diffusers.MiniMaxMusic3ModularPipeline[[diffusers.MiniMaxMusic3ModularPipeline]]

```python
diffusers.MiniMaxMusic3ModularPipeline(blocks: diffusers.modular_pipelines.modular_pipeline.ModularPipelineBlocks | None = None, pretrained_model_name_or_path: str | os.PathLike | None = None, components_manager: diffusers.modular_pipelines.components_manager.ComponentsManager | None = None, collection: str | None = None, workflow: str | None = None, modular_config_dict: dict[str, typing.Any] | None = None, config_dict: dict[str, typing.Any] | None = None, **kwargs)
```

[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/modular_pipelines/minimax_music3/modular_pipeline.py#L22)

MiniMax Music 3 ile söz ve başlık koşullu müzik üretimi için bir ModularPipeline.

## MiniMaxMusic3Blocks[[diffusers.MiniMaxMusic3Blocks]]

#### diffusers.MiniMaxMusic3Blocks[[diffusers.MiniMaxMusic3Blocks]]

```python
diffusers.MiniMaxMusic3Blocks()
```

[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/modular_pipelines/minimax_music3/modular_blocks_minimax_music3.py#L130)

MiniMax Music 3 kullanılarak söz ve açıklama koşullu müzik üretimi için modüler bir pipeline. Otoregresif bir Qwen3 dil modeli, sözlerden ve müzik açıklamasından kare başına semantik kodlar ve gizli durumlar üretir; bir akış eşleştirme (flow-matching) transformer'ı, gizli durumları Flow-VAE latentlerine parça parça dönüştürür; ve DAC tarzı bir vokoder bunları 44,1 kHz'de stereo bir dalga formuna çözer.

Bileşenler: tokenizer (`Qwen2Tokenizer`) language_model (`Qwen3ForCausalLM`) rvq_depth_decoder (`MiniMaxMusic3RVQDepthDecoder`) condition_encoder (`MiniMaxMusic3ConditionEncoder`) transformer (`MiniMaxMusic3Transformer1DModel`) scheduler (`FlowMatchEulerDiscreteScheduler`) guider (`ClassifierFreeGuidance`) vocoder (`MiniMaxMusic3Vocoder`)

Girdiler: prompt (`str`): Müzik açıklaması (tür, ruh hali, vokaller, enstrümantasyon, düzenleme). lyrics (`str`): Söylenecek sözler. `[verse]` veya `[chorus]` gibi yapı etiketlerinin her biri kendi satırında olmalıdır; baştaki etiketle aynı satırda bulunan metin, kontrol noktasının girdi sözleşmesi tarafından düşürülür. audio_duration (`float`, *isteğe bağlı*, varsayılan 60.0): Üretilen sesin saniye cinsinden üst sınırı. Dil modeli daha erken durabilir. 9000 kare (altı dakika) ile sınırlıdır. generator (`Generator`, *isteğe bağlı*): Belirleyici üretim için Torch üreteci. num_inference_steps (`int`, *isteğe bağlı*, varsayılan 30): Parça başına akış eşleştirme Euler adımı sayısı. output_type (`str`, *isteğe bağlı*, varsayılan np): Çıktı biçimi: 'np' veya 'pt'.

Çıktılar: sesler (`Tensor | ndarray`): `[-1, 1]` aralığında, `(batch, channels, samples)` biçiminde üretilen stereo dalga formu.

## MiniMaxMusic3ConditionEncoder[[diffusers.MiniMaxMusic3ConditionEncoder]]

#### diffusers.MiniMaxMusic3ConditionEncoder[[diffusers.MiniMaxMusic3ConditionEncoder]]

```python
diffusers.MiniMaxMusic3ConditionEncoder(condition_hidden_dim: int = 4096, num_condition_layers: int = 8, out_dim: int = 2048, input_sampling_rate: int = 24000, input_hop_length: int = 960, output_sampling_rate: int = 44100, output_hop_length: int = 512)
```

[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/condition_embedders/condition_embedder_minimax_music3.py#L23)

Otonom regresif aşamasının kare başına gizli durumlarını Flow-VAE gizli zaman çizelgesine yansıtır.

Her üretilen kare, `num_condition_layers` adet gizli durum taşır; boyutları `condition_hidden_dim`'dir (biri dil modelinden, diğeri her artımsal kod kitabı adımından gelir). Bunlar, öğrenilmiş softmax ağırlıklarıyla karıştırılır, projekte edilir ve en yakın komşu interpolasyonu kullanılarak dil modelinin kare hızından gizli kare hızına yeniden örneklenir.

#### forward[[diffusers.MiniMaxMusic3ConditionEncoder.forward]]

```python
forward(hidden_states: Tensor)
```

[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/condition_embedders/condition_embedder_minimax_music3.py#L48)

**Parametreler:**

hidden_states (`torch.Tensor`, şekli `(batch, frames, num_condition_layers * condition_hidden_dim)`) : Otoregresif aşamadan gelen, çerçeve başına birleştirilmiş gizli durumlar.

**Dönüş:** `torch.Tensor`, şekli `(batch, latent_length, out_dim)`

gizli hizalı koşullama dizisi.

## MiniMaxMusic3RVQDepthDecoder[[diffusers.MiniMaxMusic3RVQDepthDecoder]]

#### diffusers.MiniMaxMusic3RVQDepthDecoder[[diffusers.MiniMaxMusic3RVQDepthDecoder]]

```python
diffusers.MiniMaxMusic3RVQDepthDecoder(hidden_size: int = 4096, num_layers: int = 4, num_attention_heads: int = 16, intermediate_size: int = 6144, audio_vocab_size: int = 1024, num_codebooks: int = 8, max_position_embeddings: int = 16)
```

[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/transformers/minimax_music3_rvq_depth_decoder.py#L91)

MiniMax Music 3'ün yerel dil modeli. Her ses çerçevesi içinde, küresel dil modelinin gizli durumu ve çerçevenin anlamsal kodundan yedi artımsal RVQ kod kitabını (c1..c7) otoregresif olarak tahmin eder ve akış eşleştirme dönüştürücüsünü koşullandıran adım başına gizli durumları açığa çıkarır.

Ayrıca, boru hattının küresel dil modelinin geri besleme döngüsü için tam kareleri gömülebilmesi için kullanılan, kalan kod kitapları için gömme tablosunun da sahibidir.

#### forward[[diffusers.MiniMaxMusic3RVQDepthDecoder.forward]]

```python
forward(inputs_embeds: Tensor)
```

[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/transformers/minimax_music3_rvq_depth_decoder.py#L127)

**Parametreler:**

inputs_embeds (`torch.Tensor`, şekli `(batch, steps, hidden_size)`) : Projeksiyonlanmış derinlik dizisi gömme değerleri: küresel gizli durum, ardından şu ana kadar örneklenen gömülü kodlar; her biri `projection` üzerinden geçirilir.

**Dönüş:** `torch.Tensor`, şekli `(batch, steps, hidden_size)`

normalize edilmiş gizli durumlar; son adım bir sonraki kod kitabı başlığını besler.

## MiniMaxMusic3Vocoder[[diffusers.MiniMaxMusic3Vocoder]]

#### diffusers.MiniMaxMusic3Vocoder[[diffusers.MiniMaxMusic3Vocoder]]

```python
diffusers.MiniMaxMusic3Vocoder(latent_channels: int = 128, decoder_input_dim: int = 1024, decoder_hidden_dim: int = 1536, upsampling_ratios: tuple = (8, 8, 4, 2), sampling_rate: int = 44100)
```

[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/autoencoders/minimax_music3_vocoder.py#L71)

MiniMax Music 3'ün Flow-VAE dalga formu çözücü birimi (DAC tarzı bir çözücü). `(batch, latent_channels, length)` biçimindeki akış eşleşmeli (flow-matched) latentleri `sampling_rate` örnekleme hızında stereo dalga formlarına çözer; iki ses kanalı, iki katlanmış `latent_channels // 2` akışı olarak çözülür.

#### forward[[diffusers.MiniMaxMusic3Vocoder.forward]]

```python
forward(latents: Tensor)
```

[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/autoencoders/minimax_music3_vocoder.py#L100)

**Parametreler:**

latents (`torch.Tensor`, şekli `(batch, latent_channels, length)`) : Flow-matched Flow-VAE latantları.

**Dönüş:** `torch.Tensor`, şekli `(batch, 2, samples)`

`[-1, 1]` aralığındaki stereo dalga formu.