# MusicGen

## Genel Bakış

MusicGen modeli, Jade Copet, Felix Kreuk, Itai Gat, Tal Remez, David Kant, Gabriel Synnaeve, Yossi Adi ve Alexandre Défossez tarafından kaleme alınan [Simple and Controllable Music Generation](https://huggingface.co/papers/2306.05284) makalesinde önerilmiştir.

MusicGen, metin açıklamalarına veya ses istemlerine koşullu olarak yüksek kaliteli müzik örnekleri üretebilen tek aşamalı otoregresif bir Transformer modelidir. Metin açıklamaları, gizli durum temsilcileri dizisini elde etmek için dondurulmuş bir metin kodlayıcı modelinden geçirilir. MusicGen, bu gizli durumlara koşullu olarak ayrık ses jetonlarını, yani *ses kodlarını* tahmin edecek şekilde eğitilir. Bu ses jetonları, ardından EnCodec gibi bir ses sıkıştırma modeli kullanılarak ses dalgası formu geri kazanılmak üzere çözümlenir.

Verimli bir token iç içe geçirme deseni sayesinde MusicGen, metin/ses istemleri için kendiliğinden denetimli bir semantik temsil gerektirmez; bu da kod kitapları kümesinin (örneğin hiyerarşik olarak veya örnekleme artırma yoluyla) tahmin edilmesi için birden fazla modelin ardışık olarak kullanılma ihtiyacını ortadan kaldırır. Bunun yerine, tüm kod kitaplarını tek bir ileri geçişte üretebilir.

Makalenin özeti aşağıdaki gibidir:

*Koşullu müzik üretimi görevini ele alıyoruz. Sıkıştırılmış ayrık müzik temsili akışları, yani token'lar üzerinde çalışan tek bir Dil Modeli (LM) olan MusicGen'i tanıtıyoruz. Önceki çalışmalardan farklı olarak MusicGen, tek aşamalı bir transformer LM ve verimli token iç içe geçirme desenlerinden oluşmakta olup, hiyerarşik olarak veya örneklemeyi artırarak birden fazla modeli kademeli olarak kullanma ihtiyacını ortadan kaldırır. Bu yaklaşım doğrultusunda, MusicGen'in metin açıklaması veya melodik özelliklere koşullu olarak yüksek kaliteli örnekler üretebildiğini ve bu sayede üretilen çıktı üzerinde daha iyi kontroller sağlanabildiğini gösteriyoruz. Hem otomatik hem de insan çalışmaları dikkate alınarak kapsamlı bir ampirik değerlendirme yapılmış ve önerilen yaklaşımın standart bir metinden müziğe dönüştürme kriterinde değerlendirilen baz çizgilerden üstün olduğu gösterilmiştir. Ablasyon çalışmaları aracılığıyla, MusicGen'i oluşturan her bir bileşenin önemini aydınlatıyoruz.*

Bu model [sanchit-gandhi](https://huggingface.co/sanchit-gandhi) tarafından katkıda bulunmuştur. Orijinal kod [burada](https://github.com/facebookresearch/audiocraft) bulunabilir. Ön eğitilmiş denetim noktaları [Hugging Face Hub](https://huggingface.co/models?sort=downloads&search=facebook%2Fmusicgen-)'da bulunabilir.

## Kullanım ipuçları

- [buradan](https://github.com/facebookresearch/audiocraft/blob/main/docs/MUSICGEN.md#importing--exporting-models) orijinal kontrol noktalarını indirdikten sonra, **dönüştürme betiğini** kullanarak dönüştürebilirsiniz
Aşağıdaki komutla `src/transformers/models/musicgen/convert_musicgen_transformers.py` dosyasını çalıştırın:

```bash
python src/transformers/models/musicgen/convert_musicgen_transformers.py \
    --checkpoint small --pytorch_dump_folder /output/path
```

## Üretim

MusicGen, iki üretim moduyla uyumludur: greedy ve sampling. Uygulamada, sampling, greedy'ye kıyasla belirgin şekilde daha iyi sonuçlar verdiğinden, mümkün olan her yerde sampling modunun kullanılmasını öneriyoruz. Sampling varsayılan olarak etkinleştirilmiştir ve `MusicgenForConditionalGeneration.generate()` çağrısında `do_sample=True` olarak ayarlanarak veya modelin üretim yapılandırmasının üzerine yazılarak (aşağıya bakınız) açıkça belirtilebilir.

Üretim, sinüzoidal konumsal gömme (positional embeddings) nedeniyle 30 saniyelik girdilerle sınırlıdır. Bu, MusicGen'in 30 saniyeden (1503 token) fazla ses üretemediği anlamına gelir ve Sesle İletilen Üretim (Audio-Prompted Generation) ile geçirilen girdi sesi bu sınıra dahildir; dolayısıyla 20 saniyelik bir ses girdisi verildiğinde, MusicGen 10 saniyeden fazla ek ses üretemez.

Transformers, MusicGen'in hem mono (1 kanal) hem de stereo (2 kanal) varyantlarını destekler. Mono kanal sürümleri tek bir kod kitabı seti üretir. Stereo sürümleri ise 2 kod kitabı seti üretir; bunlardan her biri bir kanala (sol/sağ) aittir ve her kod kitabı seti, ses sıkıştırma modeli üzerinden bağımsız olarak çözümlenir. Her kanalın ses akışları birleştirilerek nihai stereo çıktısı elde edilir.

### Koşulsuz Üretim

Koşulsuz (veya 'null') üretim için girdiler, `MusicgenForConditionalGeneration.get_unconditional_inputs()` yöntemi üzerinden elde edilebilir:

```python
from transformers import MusicgenForConditionalGeneration

model = MusicgenForConditionalGeneration.from_pretrained("facebook/musicgen-small", device_map="auto")
unconditional_inputs = model.get_unconditional_inputs(num_samples=1)

audio_values = model.generate(**unconditional_inputs, do_sample=True, max_new_tokens=256)
```

Ses çıktıları, `(batch_size, num_channels, sequence_length)` biçiminde üç boyutlu bir Torch tensörüdür. Üretilen ses örneklerini dinlemek için bunları bir ipynb defterinde oynatabilirsiniz:

```python
from IPython.display import Audio

sampling_rate = model.config.audio_encoder.sampling_rate
Audio(audio_values[0].numpy(), rate=sampling_rate)
```

Veya üçüncü taraf bir kütüphane kullanarak, örneğin `scipy` ile, bunları `.wav` dosyası olarak kaydedin:

```python
import scipy

sampling_rate = model.config.audio_encoder.sampling_rate
scipy.io.wavfile.write("musicgen_out.wav", rate=sampling_rate, data=audio_values[0, 0].numpy())
```

### Metin Koşullu Üretim

Model, [MusicgenProcessor](/docs/transformers/main/tr/model_doc/musicgen#transformers.MusicgenProcessor) kullanarak girdileri ön işlemeye tabi tutarak bir metin istemine koşullu bir ses örneği üretebilir:

```python
from transformers import AutoProcessor, MusicgenForConditionalGeneration

processor = AutoProcessor.from_pretrained("facebook/musicgen-small")
model = MusicgenForConditionalGeneration.from_pretrained("facebook/musicgen-small", device_map="auto")

inputs = processor(
    text=["80s pop track with bassy drums and synth", "90s rock song with loud guitars and heavy drums"],
    padding=True,
    return_tensors="pt",
)
audio_values = model.generate(**inputs, do_sample=True, guidance_scale=3, max_new_tokens=256)
```

`guidance_scale`, sınıflandırıcı serbest yönlendirme (CFG) içinde kullanılır ve koşullu logitler (metin istemlerinden tahmin edilenler) ile koşulsuz logitler (koşulsuz veya 'boş' istemden tahmin edilenler) arasındaki ağırlıklandırmayı belirler. Daha yüksek yönlendirme ölçeği, modelin girdi istemiyle daha yakından ilişkili örnekler üretmesini teşvik eder; bu genellikle daha düşük ses kalitesi pahasına gerçekleşir. CFG, `guidance_scale > 1` olarak ayarlanarak etkinleştirilir. En iyi sonuçlar için `guidance_scale=3` (varsayılan) kullanın.

### Sesle Tetiklenen Üretim

Aynı [MusicgenProcessor](/docs/transformers/main/tr/model_doc/musicgen#transformers.MusicgenProcessor), ses devamı için kullanılan bir ses komutunu ön işlemek için kullanılabilir. Aşağıdaki örnekte, 🤗 Datasets kütüphanesini kullanarak bir ses dosyası yüklenir; bu kütüphane aşağıdaki komutla pip üzerinden kurulabilir:

```bash
pip install --upgrade pip
pip install datasets[audio]
```

```python
from datasets import load_dataset

from transformers import AutoProcessor, MusicgenForConditionalGeneration

processor = AutoProcessor.from_pretrained("facebook/musicgen-small")
model = MusicgenForConditionalGeneration.from_pretrained("facebook/musicgen-small", device_map="auto")

dataset = load_dataset("sanchit-gandhi/gtzan", split="train", streaming=True)
sample = next(iter(dataset))["audio"]

# take the first half of the audio sample
sample["array"] = sample["array"][: len(sample["array"]) // 2]

inputs = processor(
    audio=sample["array"],
    sampling_rate=sample["sampling_rate"],
    text=["80s blues track with groovy saxophone"],
    padding=True,
    return_tensors="pt",
)
audio_values = model.generate(**inputs, do_sample=True, guidance_scale=3, max_new_tokens=256)
```

Toplu sesle tetiklenen üretimde, üretilen `audio_values`, [MusicgenProcessor](/docs/transformers/main/tr/model_doc/musicgen#transformers.MusicgenProcessor) sınıfı kullanılarak dolgu (padding) kaldırılacak şekilde son işleme tabi tutulabilir:

```python
from datasets import load_dataset

from transformers import AutoProcessor, MusicgenForConditionalGeneration

processor = AutoProcessor.from_pretrained("facebook/musicgen-small")
model = MusicgenForConditionalGeneration.from_pretrained("facebook/musicgen-small", device_map="auto")

dataset = load_dataset("sanchit-gandhi/gtzan", split="train", streaming=True)
sample = next(iter(dataset))["audio"]

# take the first quarter of the audio sample
sample_1 = sample["array"][: len(sample["array"]) // 4]

# take the first half of the audio sample
sample_2 = sample["array"][: len(sample["array"]) // 2]

inputs = processor(
    audio=[sample_1, sample_2],
    sampling_rate=sample["sampling_rate"],
    text=["80s blues track with groovy saxophone", "90s rock song with loud guitars and heavy drums"],
    padding=True,
    return_tensors="pt",
)
audio_values = model.generate(**inputs, do_sample=True, guidance_scale=3, max_new_tokens=256)

# post-process to remove padding from the batched audio
audio_values = processor.batch_decode(audio_values, padding_mask=inputs.padding_mask)
```

### Üretim Yapılandırması

Örnekleme, yönlendirme ölçeği ve üretilen token sayısı gibi üretim sürecini kontrol eden varsayılan parametreler, modelin üretim yapılandırmasında bulunur ve istenildiği gibi güncellenebilir:

```python
from transformers import MusicgenForConditionalGeneration

model = MusicgenForConditionalGeneration.from_pretrained("facebook/musicgen-small", device_map="auto")

# inspect the default generation config
model.generation_config

# increase the guidance scale to 4.0
model.generation_config.guidance_scale = 4.0

# decrease the max length to 256 tokens
model.generation_config.max_length = 256
```

generate metoduna iletilen herhangi bir argümanın, generation config içindeki ilgili ayarları **geçersiz kılacağını** unutmayın; bu nedenle generate çağrısında `do_sample=False` olarak ayarlanırsa, bu değer generation config içindeki `model.generation_config.do_sample` ayarını geçersiz kılar.

## Model Yapısı

MusicGen modeli üç ayrı aşamaya ayrılabilir:

1. Metin kodlayıcı: metin girdilerini gizli durum temsilcileri dizisine eşler. Ön eğitilmiş MusicGen modelleri, T5 veya Flan-T5'ten dondurulmuş bir metin kodlayıcı kullanır.
2. MusicGen decoder: encoder gizli durum temsillerine koşullu olarak ses tokenlarını (veya kodlarını) otomatik regresif olarak üreten bir dil modeli (LM)
3. Ses kodlayıcı/çözücü: bir ses istemini, istem belirteçleri olarak kullanmak için kodlamak ve çözücünün tahmin ettiği ses belirteçlerinden ses dalgasını geri getirmek için kullanılır

Böylece MusicGen modeli, [MusicgenForCausalLM](/docs/transformers/main/tr/model_doc/musicgen#transformers.MusicgenForCausalLM) sınıfına karşılık gelen bağımsız bir çözücü modeli olarak ya da metin kodlayıcı ile ses kodlayıcı/çözücüyü içeren, [MusicgenForConditionalGeneration](/docs/transformers/main/tr/model_doc/musicgen#transformers.MusicgenForConditionalGeneration) sınıfına karşılık gelen bileşik bir model olarak kullanılabilir. Yalnızca çözücünün önceden eğitilmiş kontrol noktasından yüklenmesi gerekiyorsa, önce doğru yapılandırmanın belirtilmesiyle yüklenebilir veya bileşik modelin `.decoder` özniteliği üzerinden erişilebilir:

```python
from transformers import AutoConfig, MusicgenForCausalLM, MusicgenForConditionalGeneration

# Option 1: get decoder config and pass to `.from_pretrained`
decoder_config = AutoConfig.from_pretrained("facebook/musicgen-small").decoder
decoder = MusicgenForCausalLM.from_pretrained("facebook/musicgen-small", **decoder_config, device_map="auto")

# Option 2: load the entire composite model, but only return the decoder
decoder = MusicgenForConditionalGeneration.from_pretrained("facebook/musicgen-small", device_map="auto").decoder
```

Eğitim sırasında metin kodlayıcı ve ses kodlayıcı/kod çözücü modelleri dondurulduğundan, MusicGen kod çözücü [MusicgenForCausalLM](/docs/transformers/main/tr/model_doc/musicgen#transformers.MusicgenForCausalLM), kodlayıcı gizli durumları ve ses kodlarından oluşan bir veri setinde bağımsız olarak eğitilebilir. Çıkarım sırasında, eğitilmiş kod çözücü, dondurulmuş metin kodlayıcı ve ses kodlayıcı/kod çözücülerle birleştirilerek bileşik [MusicgenForConditionalGeneration](/docs/transformers/main/tr/model_doc/musicgen#transformers.MusicgenForConditionalGeneration) modeli elde edilebilir.

İpuçları:

* MusicGen, Encodec'in 32kHz checkpoint'i üzerinde eğitilmiştir. Encodec modelinin uyumlu bir sürümünü kullandığınızdan emin olmalısınız.
* Örnekleme modu, açgözlü (greedy) yöntemden genellikle daha iyi sonuçlar verir; `MusicgenForConditionalGeneration.generate()` çağrısında `do_sample` değişkenini değiştirerek örnekleme işlevini açabilirsiniz.

## MusicgenDecoderConfig[[transformers.MusicgenDecoderConfig]]

#### transformers.MusicgenDecoderConfig[[transformers.MusicgenDecoderConfig]]

```python
transformers.MusicgenDecoderConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, vocab_size: int = 2048, max_position_embeddings: int = 2048, num_hidden_layers: int = 24, ffn_dim: int = 4096, num_attention_heads: int = 16, layerdrop: float | int = 0.0, use_cache: bool = True, activation_function: str = 'gelu', hidden_size: int = 1024, dropout: float | int = 0.1, attention_dropout: float | int = 0.0, activation_dropout: float | int = 0.0, initializer_factor: float = 0.02, scale_embedding: bool = False, num_codebooks: int = 4, audio_channels: int = 1, pad_token_id: int | None = 2048, bos_token_id: int | None = 2048, eos_token_id: int | list[int] | None = None, tie_word_embeddings: bool = False, is_decoder: bool = False, add_cross_attention: bool = False, cross_attention_hidden_size: int | None = None)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/musicgen/configuration_musicgen.py#L30)

**Parametreler:**

vocab_size (`int`, *isteğe bağlı*, varsayılan `2048`) : Modelin sözlük boyutu. `input_ids` tarafından temsil edilebilecek farklı token sayısını tanımlar.

max_position_embeddings (`int`, *isteğe bağlı*, varsayılan `2048`) : Bu modelin kullanılabileceği maksimum dizi uzunluğu.

num_hidden_layers (`int`, *isteğe bağlı*, varsayılan `24`) : Transformer decoder'ındaki gizli katman sayısı.

ffn_dim (`int`, *isteğe bağlı*, varsayılan `4096`) : MLP temsillerinin boyutu.

num_attention_heads (`int`, *isteğe bağlı*, varsayılan `16`) : Transformer decoder'ındaki her dikkat katmanı için dikkat başı sayısı.

layerdrop (`Union[float, int]`, *isteğe bağlı*, varsayılan `0.0`) : LayerDrop olasılığı. Daha fazla ayrıntı için [LayerDrop makalesine](see https://huggingface.co/papers/1909.11556) bakın.

use_cache (`bool`, *isteğe bağlı*, varsayılan `True`) : Modelin son anahtar/değer dikkatlerini döndürüp döndürmeyeceğini belirtir (tüm modellerde kullanılmaz). Yalnızca `config.is_decoder=True` olduğunda veya model yalnızca çözücü tabanlı üretken bir model olduğunda geçerlidir.

activation_function (`str`, *isteğe bağlı*, varsayılan `gelu`) : Çözücüdeki doğrusal olmayan aktivasyon fonksiyonu (fonksiyon veya dize). Örneğin, `"gelu"`, `"relu"`, `"silu"` vb.

hidden_size (`int`, *isteğe bağlı*, varsayılan `1024`) : Gizli temsillerin boyutu.

dropout (`Union[float, int]`, *isteğe bağlı*, varsayılan `0.1`) : Tüm dropout katmanları için oran.

attention_dropout (`Union[float, int]`, *isteğe bağlı*, varsayılan `0.0`) : Dikkat olasılıkları için dropout oranı.

activation_dropout (`Union[float, int]`, *isteğe bağlı*, varsayılan `0.0`) : Tamamen bağlı katmandaki aktivasyonlar için dropout oranı.

initializer_factor (`float`, *opsiyonel*, varsayılan `0.02`) : Tüm ağırlık matrislerini başlatmak için kullanılan bir çarpan (1 olarak tutulmalıdır, başlatma testleri için dahili olarak kullanılır).

scale_embedding (`bool`, *isteğe bağlı*, varsayılan `False`) : Gömme değerlerinin sqrt(d_model) değerine bölünerek ölçeklendirilip ölçeklendirilmeyeceğini belirtir.

num_codebooks (`int`, *isteğe bağlı*, varsayılan `4`) : Modelin kullandığı paralel kod kitaplarının sayısı.

audio_channels (`int`, *isteğe bağlı*, varsayılan `1`) : Girdi kanal sayısı.

pad_token_id (`int`, *isteğe bağlı*, varsayılan `2048`) : Sözlükte dolgu için kullanılan token kimliği.

bos_token_id (`int`, *isteğe bağlı*, varsayılan `2048`) : Sözlükte akış başlangıcı için kullanılan token kimliği.

eos_token_id (`Union[int, list[int]]`, *isteğe bağlı*) : Sözlükte akış sonu için kullanılan token kimliği.

tie_word_embeddings (`bool`, *isteğe bağlı*, varsayılan `False`) : Ağırlık gömme bağlamalarının, modelin `tied_weights_keys` eşlemesine göre yapılıp yapılmayacağını belirtir.

is_decoder (`bool`, *isteğe bağlı*, varsayılan `False`) : Modelin bir çözücü olarak kullanılıp kullanılmadığı. `False` ise model, bir kodlayıcı olarak kullanılır.

add_cross_attention (`bool`, *isteğe bağlı*, varsayılan `False`) : Modelde çapraz dikkat katmanlarının eklenip eklenmeyeceğini belirtir.

cross_attention_hidden_size (`int`, *isteğe bağlı*) : Kodlayıcı çıktılarının, kodlayıcının çapraz dikkat anahtar/değer uzayına yansıtılmış gizli boyutu. Kodlayıcı ve çözücü farklı gizli boyutlara sahip olduğunda kullanılır.

Bu, bir MusicgenModel yapılandırmasını depolamak için kullanılan yapılandırma sınıfıdır. Belirtilen argümanlara göre bir Musicgen modelinin örneklenmesi ve model mimarisinin tanımlanması için kullanılır. Varsayılanlarla bir yapılandırma örneklendiğinde, [facebook/musicgen-small](https://huggingface.co/facebook/musicgen-small) ile benzer bir yapılandırma elde edilir.

Yapılandırma nesneleri [PreTrainedConfig](/docs/transformers/main/tr/main_classes/configuration#transformers.PreTrainedConfig) sınıfından türetilir ve model çıktılarını kontrol etmek için kullanılabilir. Daha fazla bilgi için [PreTrainedConfig](/docs/transformers/main/tr/main_classes/configuration#transformers.PreTrainedConfig) belgesini okuyun.

## MusicgenConfig[[transformers.MusicgenConfig]]

#### transformers.MusicgenConfig[[transformers.MusicgenConfig]]

```python
transformers.MusicgenConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, text_encoder: dict | transformers.configuration_utils.PreTrainedConfig | None = None, audio_encoder: dict | transformers.configuration_utils.PreTrainedConfig | None = None, decoder: dict | transformers.configuration_utils.PreTrainedConfig | None = None, initializer_factor: float = 0.02)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/musicgen/configuration_musicgen.py#L83)

**Parametreler:**

text_encoder (`Union[dict, `PretrainedConfig`]`) : Metin kodlayıcı yapılandırmasını tanımlayan bir yapılandırma nesnesi örneği.

audio_encoder (`Union[dict, `PretrainedConfig`]`) : Ses kodlayıcı yapılandırmasını tanımlayan bir yapılandırma nesnesi örneği.

decoder (`Union[dict, `PretrainedConfig`]`) : Dekoder yapılandırmasını tanımlayan bir yapılandırma nesnesi örneği.

initializer_factor (`float`, *opsiyonel*, varsayılan `0.02`) : Tüm ağırlık matrislerini başlatmak için kullanılan bir çarpan (1 olarak tutulmalıdır, başlatma testleri için dahili olarak kullanılır).

Bu, bir MusicgenModel yapılandırmasını depolamak için kullanılan yapılandırma sınıfıdır. Belirtilen argümanlara göre bir Musicgen modelinin örneklenmesi ve model mimarisinin tanımlanması için kullanılır. Varsayılanlarla bir yapılandırma örneklendiğinde, [facebook/musicgen-small](https://huggingface.co/facebook/musicgen-small) ile benzer bir yapılandırma elde edilir.

Yapılandırma nesneleri [PreTrainedConfig](/docs/transformers/main/tr/main_classes/configuration#transformers.PreTrainedConfig) sınıfından türetilir ve model çıktılarını kontrol etmek için kullanılabilir. Daha fazla bilgi için [PreTrainedConfig](/docs/transformers/main/tr/main_classes/configuration#transformers.PreTrainedConfig) belgesini okuyun.

Örnek:

```python
>>> from transformers import (
...     MusicgenConfig,
...     MusicgenDecoderConfig,
...     T5Config,
...     EncodecConfig,
...     MusicgenForConditionalGeneration,
... )

>>> # Initializing text encoder, audio encoder, and decoder model configurations
>>> text_encoder_config = T5Config()
>>> audio_encoder_config = EncodecConfig()
>>> decoder_config = MusicgenDecoderConfig()

>>> configuration = MusicgenConfig(
...     text_encoder=text_encoder_config,
...     audio_encoder=audio_encoder_config,
...     decoder=decoder_config,
... )

>>> # Initializing a MusicgenForConditionalGeneration (with random weights) from the facebook/musicgen-small style configuration
>>> model = MusicgenForConditionalGeneration(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config
>>> config_text_encoder = model.config.text_encoder
>>> config_audio_encoder = model.config.audio_encoder
>>> config_decoder = model.config.decoder

>>> # Saving the model, including its configuration
>>> model.save_pretrained("musicgen-model")

>>> # loading model and config from pretrained folder
>>> musicgen_config = MusicgenConfig.from_pretrained("musicgen-model")
>>> model = MusicgenForConditionalGeneration.from_pretrained("musicgen-model", config=musicgen_config)
```

## MusicgenProcessor[[transformers.MusicgenProcessor]]

#### transformers.MusicgenProcessor[[transformers.MusicgenProcessor]]

```python
transformers.MusicgenProcessor(feature_extractor, tokenizer)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/musicgen/processing_musicgen.py#L27)

**Parametreler:**

feature_extractor (`EncodecFeatureExtractor`) : Özellik çıkarıcı zorunlu bir girdidir.

tokenizer (`T5Tokenizer`) : Tokenizer zorunlu bir girdidir.

Bir özellik çıkarıcıyı ve bir belirteçleyiciyi tek bir işlemciye saran bir MusicgenProcessor oluşturur.

[MusicgenProcessor](/docs/transformers/main/tr/model_doc/musicgen#transformers.MusicgenProcessor), [EncodecFeatureExtractor](/docs/transformers/main/tr/model_doc/encodec#transformers.EncodecFeatureExtractor) ve [T5Tokenizer](/docs/transformers/main/tr/model_doc/t5#transformers.T5Tokenizer) sınıflarının tüm işlevlerini sunar. Daha fazla bilgi için [~EncodecFeatureExtractor](/docs/transformers/main/tr/model_doc/encodec#transformers.EncodecFeatureExtractor) ve [~T5Tokenizer](/docs/transformers/main/tr/model_doc/t5#transformers.T5Tokenizer) belgelerini inceleyin.

#### __call__[[transformers.MusicgenProcessor.__call__]]

```python
__call__(*args, **kwargs)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/musicgen/processing_musicgen.py#L34)

**Parametreler:**

return_tensors (`str` veya [TensorType](/docs/transformers/main/tr/internal/file_utils#transformers.TensorType), *opsiyonel*) : Ayarlanırsa, belirli bir çerçeveye ait tensörleri döndürür. Kabul edilen değerler:  - `'pt'`: PyTorch `torch.Tensor` nesnelerini döndürür. - `'np'`: NumPy `np.ndarray` nesnelerini döndürür.

## MusicgenModel[[transformers.MusicgenModel]]

#### transformers.MusicgenModel[[transformers.MusicgenModel]]

```python
transformers.MusicgenModel(config: MusicgenDecoderConfig)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/musicgen/modeling_musicgen.py#L555)

**Parametreler:**

config ([MusicgenDecoderConfig](/docs/transformers/main/tr/model_doc/musicgen#transformers.MusicgenDecoderConfig)) : Modelin tüm parametrelerini içeren model yapılandırma sınıfı. Bir yapılandırma dosyasıyla başlatmak, modelle ilişkili ağırlıkları yüklemez, yalnızca yapılandırmayı yükler. Model ağırlıklarını yüklemek için [from_pretrained()](/docs/transformers/main/tr/main_classes/model#transformers.PreTrainedModel.from_pretrained) yöntemine göz atın.

Üzerinde herhangi bir özel head olmadan ham hidden-states üreten çıplak Musicgen Model.

Bu model [PreTrainedModel](/docs/transformers/main/tr/main_classes/model#transformers.PreTrainedModel) sınıfından devralır. Kütüphanenin tüm modelleri için uyguladığı genel yöntemler (indirme veya kaydetme, giriş gömme boyutlarını yeniden ayarlama, başları budama vb.) için üst sınıf belgelendirmesine bakın.

Bu model aynı zamanda bir PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) alt sınıfıdır. Bunu standart bir PyTorch Module olarak kullanın ve genel kullanım ve davranışla ilgili tüm konular için PyTorch dokümantasyonuna başvurun.

#### forward[[transformers.MusicgenModel.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, encoder_hidden_states: typing.Optional[torch.Tensor] = None, encoder_attention_mask: typing.Optional[torch.LongTensor] = None, cache: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, use_cache: bool | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/musicgen/modeling_musicgen.py#L568)

**Parametreler:**

input_ids (`torch.LongTensor`, şekli `(batch_size * num_codebooks, sequence_length)`) : Sözlükteki girdi dizisi token'larının, ses kodları dizisine karşılık gelen dizinleri. Dizinler, [EncodecModel](/docs/transformers/main/tr/model_doc/encodec#transformers.EncodecModel) gibi bir ses kodlayıcı modeliyle bir ses girdisini kodlayarak ses kodlarını tahmin etmek suretiyle elde edilebilir. Ayrıntılar için [EncodecModel.encode()](/docs/transformers/main/tr/model_doc/encodec#transformers.EncodecModel.encode) bölümüne bakın.  [Girdi kimlikları nelerdir?](../glossary#input-ids)    `input_ids`, ileri geçişte otomatik olarak `(batch_size * num_codebooks, target_sequence_length)` şeklinden `(batch_size, num_codebooks, target_sequence_length)` şekline dönüştürülür. [EncodecModel](/docs/transformers/main/tr/model_doc/encodec#transformers.EncodecModel) gibi bir ses kodlama modelinden ses kodları elde ediyorsanız, kare sayısının 1'e eşit olduğundan ve ses kodlarını `(frames, batch_size, num_codebooks, target_sequence_length)` şeklinden `(batch_size * num_codebooks, target_sequence_length)` şekline yeniden boyutlandırdığınızdan emin olun, ardından bunları `input_ids` olarak iletin.

attention_mask (`torch.Tensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Dolgu (padding) token indekslerinde dikkat (attention) işleminin uygulanmamasını sağlayan maske. `[0, 1]` aralığında seçilen maske değerleri:  - **maske uygulanmayan** tokenlar için 1, - **maske uygulanan** tokenlar için 0.  [Dikkat maskeleri nelerdir?](../glossary#attention-mask)

encoder_hidden_states (`torch.Tensor`, şekli `(batch_size, encoder_sequence_length, hidden_size)`, *isteğe bağlı*) : Kodlayıcının son katmanının çıktısındaki gizli durumlar dizisi. Kodlayıcının çapraz dikkat (cross-attention) mekanizmasında kullanılır.

encoder_attention_mask (`torch.LongTensor`, şekli `(batch_size, encoder_sequence_length)`, *isteğe bağlı*) : encoder input_ids'indeki dolgu token indekslerinde çapraz dikkat (cross-attention) işleminin uygulanmasını önlemek için kullanılan maske. `[0, 1]` aralığında seçilen maske değerleri:  - **maske uygulanmamış** tokenlar için 1, - **maske uygulanmış** tokenlar için 0.  [Dikkat maskeleri nelerdir?](../glossary#attention-mask)

cache (`~cache_utils.Cache`, *isteğe bağlı*) : Sıralı çözümlemeyi hızlandırmak için kullanılabilen, önceden hesaplanmış gizli durumlar (self-attention bloklarındaki ve cross-attention bloklarındaki anahtar ve değerler). Bu genellikle, `use_cache=True` veya `config.use_cache=True` olduğunda, çözümlemenin önceki bir aşamasında modelin döndürdüğü `cache`'den oluşur. Girdi olarak yalnızca [Cache](/docs/transformers/main/tr/internal/generation_utils#transformers.Cache) örneği kabul edilir, bkz. [kv cache kılavuzu](https://huggingface.co/docs/transformers/en/kv_cache). `cache` geçirilmezse, varsayılan olarak [DynamicCache](/docs/transformers/main/tr/internal/generation_utils#transformers.DynamicCache) başlatılır. Model, girdi olarak verilen aynı cache biçimini çıktı olarak üretir. `cache` kullanılıyorsa, kullanıcının, bu modele geçmiş anahtar-değer durumları verilmemiş olan, yalnızca işlenmemiş `input_ids`'leri (şekli `(batch_size, unprocessed_length)`) girmesi beklenir; bunun yerine, şekli `(batch_size, sequence_length)` olan tüm `input_ids` girilmez.

inputs_embeds (`torch.Tensor`, şekli `(batch_size, sequence_length, hidden_size)`, *isteğe bağlı*) : `input_ids` parametresini iletmek yerine, gömülü bir temsil doğrudan iletmeyi tercih edebilirsiniz. Bu, `input_ids` indekslerini ilgili vektörlere dönüştürme biçimi üzerinde modelin dahili gömme arama matrisine kıyasla daha fazla kontrol sahibi olmak istiyorsanız faydalıdır.

use_cache (`bool`, *isteğe bağlı*) : `True` olarak ayarlanırsa, `cache` anahtar değer durumları döndürülür ve çözümlemeyi hızlandırmak için kullanılabilir (bkz. `cache`).

**Dönüş:** [BaseModelOutputWithPastAndCrossAttentions](/docs/transformers/main/tr/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPastAndCrossAttentions) veya `tuple(torch.Tensor)`

Bir [BaseModelOutputWithPastAndCrossAttentions](/docs/transformers/main/tr/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPastAndCrossAttentions) veya bir `torch.Tensor` demeti (`return_dict=False` geçirildiğinde veya `config.return_dict=False` olduğunda), yapılandırmaya (`None`) ve girdilere bağlı olarak çeşitli öğelerden oluşur.

[MusicgenModel](/docs/transformers/main/tr/model_doc/musicgen#transformers.MusicgenModel) forward metodu, `__call__` özel metodunu geçersiz kılar.

İleri geçiş tarifi bu fonksiyon içinde tanımlanmalı olsa da, sonrasında bunun yerine `Module` örneğini çağırmak gerekir; çünkü ilki ön ve son işleme adımlarını çalıştırmaktan sorumluyken ikincisi bunları sessizce yok sayar.

- **last_hidden_state** (`torch.Tensor`, şekli `(batch_size, sequence_length, hidden_size)`) -- Modelin son katmanının çıktısındaki gizli durumlar dizisi.

  `cache` kullanılırsa, yalnızca `(batch_size, 1, hidden_size)` biçimindeki dizilerin son gizli durumu (hidden-state) çıktı olarak verilir.
- **cache** (`Cache`, *isteğe bağlı*, `use_cache=True` geçirildiğinde veya `config.use_cache=True` olduğunda döndürülür) -- Bir [Cache](/docs/transformers/main/tr/internal/generation_utils#transformers.Cache) örneğidir. Daha fazla ayrıntı için [kv cache kılavuzumuza](https://huggingface.co/docs/transformers/en/kv_cache) bakın.

  Sıralı çözümlemeyi hızlandırmak için (bkz. `cache` girdisi) kullanılabilen, önceden hesaplanmış gizli durumları (self-attention bloklarındaki anahtar ve değerler ve isteğe bağlı olarak `config.is_encoder_decoder=True` ise cross-attention bloklarındaki anahtar ve değerler) içerir.
- **hidden_states** (`tuple(torch.Tensor)`, *isteğe bağlı*, `output_hidden_states=True` geçirildiğinde veya `config.output_hidden_states=True` olduğunda döndürülür) -- `torch.Tensor` (gömme katmanı varsa gömme katmanının çıktısı için bir tane + her katmanın çıktısı için bir tane) içeren, `(batch_size, sequence_length, hidden_size)` biçiminde bir demet.

  Her katmanın çıktısında modelin gizli durumları ve isteğe bağlı başlangıç gömme çıktıları.
- **attentions** (`tuple(torch.Tensor)`, *isteğe bağlı*, `output_attentions=True` geçirildiğinde veya `config.output_attentions=True` olduğunda döndürülür) -- `torch.Tensor` (her katman için bir tane) içeren bir tuple, şekli `(batch_size, num_heads, sequence_length, sequence_length)`.

  Dikkat softmax'ı sonrası dikkat ağırlıkları, öz-dikkat kafalarında ağırlıklı ortalamanın hesaplanmasında kullanılır.
- **cross_attentions** (`tuple(torch.Tensor)`, *isteğe bağlı*, `output_attentions=True` ve `config.add_cross_attention=True` geçirildiğinde veya `config.output_attentions=True` olduğunda döndürülür) -- `(batch_size, num_heads, sequence_length, sequence_length)` biçiminde, her katman için bir adet içeren `torch.Tensor` demeti.

  Dekoderin çapraz dikkat katmanının dikkat ağırlıkları, dikkat softmax'ından sonra, çapraz dikkat başlıklarında ağırlıklı ortalamanın hesaplanmasında kullanılır.

## MusicgenForCausalLM[[transformers.MusicgenForCausalLM]]

#### transformers.MusicgenForCausalLM[[transformers.MusicgenForCausalLM]]

```python
transformers.MusicgenForCausalLM(config: MusicgenDecoderConfig)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/musicgen/modeling_musicgen.py#L633)

**Parametreler:**

config ([MusicgenDecoderConfig](/docs/transformers/main/tr/model_doc/musicgen#transformers.MusicgenDecoderConfig)) : Modelin tüm parametrelerini içeren model yapılandırma sınıfı. Bir yapılandırma dosyasıyla başlatmak, modelle ilişkili ağırlıkları yüklemez, yalnızca yapılandırmayı yükler. Model ağırlıklarını yüklemek için [from_pretrained()](/docs/transformers/main/tr/main_classes/model#transformers.PreTrainedModel.from_pretrained) yöntemine göz atın.

Üzerinde bir dil modelleme başlığı bulunan MusicGen çözücü modeli.

Bu model [PreTrainedModel](/docs/transformers/main/tr/main_classes/model#transformers.PreTrainedModel) sınıfından devralır. Kütüphanenin tüm modelleri için uyguladığı genel yöntemler (indirme veya kaydetme, giriş gömme boyutlarını yeniden ayarlama, başları budama vb.) için üst sınıf belgelendirmesine bakın.

Bu model aynı zamanda bir PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) alt sınıfıdır. Bunu standart bir PyTorch Module olarak kullanın ve genel kullanım ve davranışla ilgili tüm konular için PyTorch dokümantasyonuna başvurun.

#### forward[[transformers.MusicgenForCausalLM.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, encoder_hidden_states: typing.Optional[torch.Tensor] = None, encoder_attention_mask: typing.Optional[torch.LongTensor] = None, cache: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, use_cache: bool | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/musicgen/modeling_musicgen.py#L661)

**Parametreler:**

input_ids (`torch.LongTensor`, şekli `(batch_size * num_codebooks, sequence_length)`) : Sözlükteki girdi dizisi token'larının, ses kodları dizisine karşılık gelen dizinleri. Dizinler, [EncodecModel](/docs/transformers/main/tr/model_doc/encodec#transformers.EncodecModel) gibi bir ses kodlayıcı modeliyle bir ses girdisini kodlayarak ses kodlarını tahmin etmek suretiyle elde edilebilir. Ayrıntılar için [EncodecModel.encode()](/docs/transformers/main/tr/model_doc/encodec#transformers.EncodecModel.encode) bölümüne bakın.  [Girdi kimlikları nelerdir?](../glossary#input-ids)    `input_ids`, ileri geçişte otomatik olarak `(batch_size * num_codebooks, target_sequence_length)` şeklinden `(batch_size, num_codebooks, target_sequence_length)` şekline dönüştürülür. [EncodecModel](/docs/transformers/main/tr/model_doc/encodec#transformers.EncodecModel) gibi bir ses kodlama modelinden ses kodları elde ediyorsanız, kare sayısının 1'e eşit olduğundan ve ses kodlarını `(frames, batch_size, num_codebooks, target_sequence_length)` şeklinden `(batch_size * num_codebooks, target_sequence_length)` şekline yeniden boyutlandırdığınızdan emin olun, ardından bunları `input_ids` olarak iletin.

attention_mask (`torch.Tensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Dolgu (padding) token indekslerinde dikkat (attention) işleminin uygulanmamasını sağlayan maske. `[0, 1]` aralığında seçilen maske değerleri:  - **maske uygulanmayan** tokenlar için 1, - **maske uygulanan** tokenlar için 0.  [Dikkat maskeleri nelerdir?](../glossary#attention-mask)

encoder_hidden_states (`torch.Tensor`, şekli `(batch_size, encoder_sequence_length, hidden_size)`, *isteğe bağlı*) : Kodlayıcının son katmanının çıktısındaki gizli durumlar dizisi. Kodlayıcının çapraz dikkat (cross-attention) mekanizmasında kullanılır.

encoder_attention_mask (`torch.LongTensor`, şekli `(batch_size, encoder_sequence_length)`, *isteğe bağlı*) : encoder input_ids'indeki dolgu token indekslerinde çapraz dikkat (cross-attention) işleminin uygulanmasını önlemek için kullanılan maske. `[0, 1]` aralığında seçilen maske değerleri:  - **maske uygulanmamış** tokenlar için 1, - **maske uygulanmış** tokenlar için 0.  [Dikkat maskeleri nelerdir?](../glossary#attention-mask)

cache (`~cache_utils.Cache`, *isteğe bağlı*) : Sıralı çözümlemeyi hızlandırmak için kullanılabilen, önceden hesaplanmış gizli durumlar (self-attention bloklarındaki ve cross-attention bloklarındaki anahtar ve değerler). Bu genellikle, `use_cache=True` veya `config.use_cache=True` olduğunda, çözümlemenin önceki bir aşamasında modelin döndürdüğü `cache`'den oluşur. Girdi olarak yalnızca [Cache](/docs/transformers/main/tr/internal/generation_utils#transformers.Cache) örneği kabul edilir, bkz. [kv cache kılavuzu](https://huggingface.co/docs/transformers/en/kv_cache). `cache` geçirilmezse, varsayılan olarak [DynamicCache](/docs/transformers/main/tr/internal/generation_utils#transformers.DynamicCache) başlatılır. Model, girdi olarak verilen aynı cache biçimini çıktı olarak üretir. `cache` kullanılıyorsa, kullanıcının, bu modele geçmiş anahtar-değer durumları verilmemiş olan, yalnızca işlenmemiş `input_ids`'leri (şekli `(batch_size, unprocessed_length)`) girmesi beklenir; bunun yerine, şekli `(batch_size, sequence_length)` olan tüm `input_ids` girilmez.

inputs_embeds (`torch.Tensor`, şekli `(batch_size, sequence_length, hidden_size)`, *isteğe bağlı*) : `input_ids` parametresini iletmek yerine, gömülü bir temsil doğrudan iletmeyi tercih edebilirsiniz. Bu, `input_ids` indekslerini ilgili vektörlere dönüştürme biçimi üzerinde modelin dahili gömme arama matrisine kıyasla daha fazla kontrol sahibi olmak istiyorsanız faydalıdır.

labels (`torch.LongTensor`, şekli `(batch_size, sequence_length, num_codebooks)`, *isteğe bağlı*) : Dil modelleme için etiketler. Not: Etiketler model içinde **kaydırılır**, yani `labels = input_ids` olarak ayarlayabilirsiniz. İndisler `[-100, 0, ..., config.vocab_size]` aralığından seçilir. `-100` olarak ayarlanan tüm etiketler yok sayılır (maske uygulanır), kayıp yalnızca `[0, ..., config.vocab_size]` aralığındaki etiketler için hesaplanır.

use_cache (`bool`, *isteğe bağlı*) : `True` olarak ayarlanırsa, `cache` anahtar değer durumları döndürülür ve çözümlemeyi hızlandırmak için kullanılabilir (bkz. `cache`).

**Dönüş:** [CausalLMOutputWithCrossAttentions](/docs/transformers/main/tr/main_classes/output#transformers.modeling_outputs.CausalLMOutputWithCrossAttentions) veya `tuple(torch.Tensor)`

Bir [CausalLMOutputWithCrossAttentions](/docs/transformers/main/tr/main_classes/output#transformers.modeling_outputs.CausalLMOutputWithCrossAttentions) veya `torch.Tensor` demeti (`return_dict=False` geçirildiğinde veya `config.return_dict=False` olduğunda), yapılandırmaya (`None`) ve girdilere bağlı olarak çeşitli öğelerden oluşur.

[MusicgenForCausalLM](/docs/transformers/main/tr/model_doc/musicgen#transformers.MusicgenForCausalLM) forward metodu, `__call__` özel metodunu geçersiz kılar.

İleri geçiş tarifi bu fonksiyon içinde tanımlanmalı olsa da, sonrasında bunun yerine `Module` örneğini çağırmak gerekir; çünkü ilki ön ve son işleme adımlarını çalıştırmaktan sorumluyken ikincisi bunları sessizce yok sayar.

- **loss** (`torch.Tensor`, şekli `(1,)`, *isteğe bağlı*, `labels` sağlandığında döndürülür) -- Dil modelleme kaybı (sonraki token tahmini için).
- **logits** (`torch.Tensor`, şekli `(batch_size, sequence_length, config.vocab_size)`) -- Dil modelleme başlığının tahmin puanları (SoftMax öncesi her sözlük jetonu için puanlar).
- **hidden_states** (`tuple(torch.Tensor)`, *isteğe bağlı*, `output_hidden_states=True` geçirildiğinde veya `config.output_hidden_states=True` olduğunda döndürülür) -- `torch.Tensor` (gömme katmanı varsa gömme katmanının çıktısı için bir tane + her katmanın çıktısı için bir tane) içeren, `(batch_size, sequence_length, hidden_size)` biçiminde bir demet.

  Her katmanın çıktısında modelin gizli durumları ve isteğe bağlı başlangıç gömme çıktıları.
- **attentions** (`tuple(torch.Tensor)`, *isteğe bağlı*, `output_attentions=True` geçirildiğinde veya `config.output_attentions=True` olduğunda döndürülür) -- `torch.Tensor` (her katman için bir tane) içeren bir tuple, şekli `(batch_size, num_heads, sequence_length, sequence_length)`.

  Dikkat softmax'ı sonrası dikkat ağırlıkları, öz-dikkat kafalarında ağırlıklı ortalamanın hesaplanmasında kullanılır.
- **cross_attentions** (`tuple(torch.Tensor)`, *isteğe bağlı*, `output_attentions=True` geçirildiğinde veya `config.output_attentions=True` olduğunda döndürülür) -- `(batch_size, num_heads, sequence_length, sequence_length)` biçiminde, her katman için bir adet içeren `torch.Tensor` demeti.

  Dikkat softmax'ı sonrası çapraz dikkat ağırlıkları, çapraz dikkat başlıklarında ağırlıklı ortalamanın hesaplanmasında kullanılır.
- **cache** (`Cache`, *isteğe bağlı*, `use_cache=True` geçirildiğinde veya `config.use_cache=True` olduğunda döndürülür) -- Bir [Cache](/docs/transformers/main/tr/internal/generation_utils#transformers.Cache) örneğidir. Daha fazla ayrıntı için [kv cache kılavuzumuza](https://huggingface.co/docs/transformers/en/kv_cache) bakın.

  Sıralı çözümlemeyi hızlandırmak için (bkz. `cache` girdisi) kullanılabilen, önceden hesaplanmış gizli durumları (dikkat bloklarındaki anahtar ve değerler) içerir.

## MusicgenForConditionalGeneration[[transformers.MusicgenForConditionalGeneration]]

#### transformers.MusicgenForConditionalGeneration[[transformers.MusicgenForConditionalGeneration]]

```python
transformers.MusicgenForConditionalGeneration(config: transformers.models.musicgen.configuration_musicgen.MusicgenConfig | None = None, text_encoder: transformers.modeling_utils.PreTrainedModel | None = None, audio_encoder: transformers.modeling_utils.PreTrainedModel | None = None, decoder: transformers.models.musicgen.modeling_musicgen.MusicgenForCausalLM | None = None)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/musicgen/modeling_musicgen.py#L1111)

**Parametreler:**

config ([MusicgenConfig](/docs/transformers/main/tr/model_doc/musicgen#transformers.MusicgenConfig), *isteğe bağlı*) : Modelin tüm parametrelerini içeren model yapılandırma sınıfı. Bir yapılandırma dosyasıyla başlatmak, modelle ilişkili ağırlıkları yüklemez, yalnızca yapılandırmayı yükler. Model ağırlıklarını yüklemek için [from_pretrained()](/docs/transformers/main/tr/main_classes/model#transformers.PreTrainedModel.from_pretrained) yöntemine göz atın.

text_encoder (`PreTrainedModel`, *isteğe bağlı*) : Metni koşullandırma için gizli durumlara kodlayan metin kodlayıcı modeli.

audio_encoder (`PreTrainedModel`, *isteğe bağlı*) : Sesleri koşullandırma için gizli durumlara kodlayan ses kodlayıcı modeli.

decoder (`MusicgenForCausalLM`, *isteğe bağlı*) : Koşullandırma sinyallerine dayanarak ses jetonları üreten çözücü model.

Metin kodlayıcı, ses kodlayıcı ve Musicgen çözücüye sahip bileşik MusicGen modeli,

Bu model [PreTrainedModel](/docs/transformers/main/tr/main_classes/model#transformers.PreTrainedModel) sınıfından devralır. Kütüphanenin tüm modelleri için uyguladığı genel yöntemler (indirme veya kaydetme, giriş gömme boyutlarını yeniden ayarlama, başları budama vb.) için üst sınıf belgelendirmesine bakın.

Bu model aynı zamanda bir PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) alt sınıfıdır. Bunu standart bir PyTorch Module olarak kullanın ve genel kullanım ve davranışla ilgili tüm konular için PyTorch dokümantasyonuna başvurun.

#### forward[[transformers.MusicgenForConditionalGeneration.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.BoolTensor] = None, input_values: typing.Optional[torch.Tensor] = None, padding_mask: typing.Optional[torch.BoolTensor] = None, decoder_input_ids: typing.Optional[torch.LongTensor] = None, decoder_attention_mask: typing.Optional[torch.BoolTensor] = None, encoder_outputs: tuple[torch.Tensor] | None = None, cache: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, decoder_inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, use_cache: bool | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/musicgen/modeling_musicgen.py#L1427)

**Parametreler:**

input_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Sözlükteki girdi dizisi belirteçlerinin (token) indeksleri. Varsayılan olarak dolgu (padding) yoksayılır. İndeksler [AutoTokenizer](/docs/transformers/main/tr/model_doc/auto#transformers.AutoTokenizer) kullanılarak elde edilebilir. Ayrıntılar için [PreTrainedTokenizer.encode()](/docs/transformers/main/tr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) ve [PreTrainedTokenizer.__call__()](/docs/transformers/main/tr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) yöntemlerine bakın. [Girdi kimlikları (input IDs) nedir?](../glossary#input-ids)

attention_mask (`torch.BoolTensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Dolgu (padding) token indekslerinde dikkat (attention) işleminin uygulanmamasını sağlayan maske. `[0, 1]` aralığında seçilen maske değerleri:  - **maske uygulanmayan** tokenlar için 1, - **maske uygulanan** tokenlar için 0.  [Dikkat maskeleri nelerdir?](../glossary#attention-mask)

input_values (`torch.Tensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Girdi ham ses dalgasının float değerleri. Değerler, bir `.flac` veya `.wav` ses dosyasını `list[float]` tipinde bir diziye, `numpy.ndarray` veya `torch.Tensor` içine yükleyerek elde edilebilir; *örneğin* torchcodec kütüphanesi (`pip install torchcodec`) veya soundfile kütüphanesi (`pip install soundfile`) aracılığıyla. Diziyi `input_values` için hazırlamak için, `torch.Tensor` tipinde bir tensöre dolgu ve dönüştürme amacıyla [AutoProcessor](/docs/transformers/main/tr/model_doc/auto#transformers.AutoProcessor) kullanılmalıdır. Ayrıntılar için `processor_class.__call__` bölümüne bakın.

padding_mask (`torch.BoolTensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Dolgu (padding) token indekslerinde dikkat (attention) işleminin uygulanmamasını sağlayan maske. `[0, 1]` aralığında seçilen maske değerleri:  - **maske uygulanmayan** tokenlar için 1, - **maske uygulanan** tokenlar için 0.  [Dikkat maskeleri nelerdir?](../glossary#attention-mask)

decoder_input_ids (`torch.LongTensor`, şekli `(batch_size * num_codebooks, target_sequence_length)`, *isteğe bağlı*) : Sözlükte, ses kodları dizisine karşılık gelen çözücü giriş dizisi belirteçlerinin dizinleri. Dizinler, [EncodecModel](/docs/transformers/main/tr/model_doc/encodec#transformers.EncodecModel) gibi bir ses kodlayıcı modeliyle bir ses istemini kodlayarak ses kodlarını tahmin etmek suretiyle elde edilebilir. Ayrıntılar için [EncodecModel.encode()](/docs/transformers/main/tr/model_doc/encodec#transformers.EncodecModel.encode) bölümüne bakın.  [Çözücü giriş kimlikları nelerdir?](../glossary#decoder-input-ids)    `decoder_input_ids`, ileri geçişte otomatik olarak `(batch_size * num_codebooks, target_sequence_length)` şeklinden `(batch_size, num_codebooks, target_sequence_length)` şekline dönüştürülür. [EncodecModel](/docs/transformers/main/tr/model_doc/encodec#transformers.EncodecModel) gibi bir ses kodlama modelinden ses kodları elde ediyorsanız, kare sayısının 1'e eşit olduğundan ve ses kodlarını `(frames, batch_size, num_codebooks, target_sequence_length)` şeklinden `(batch_size * num_codebooks, target_sequence_length)` şekline yeniden boyutlandırdığınızdan emin olun; ardından bunları `decoder_input_ids` olarak iletin.

decoder_attention_mask (`torch.LongTensor`, şekli `(batch_size, target_sequence_length)`, *isteğe bağlı*) : Varsayılan davranış: `decoder_input_ids` içindeki dolgu (pad) jetonlarını yok sayan bir tensör oluşturur. Varsayılan olarak nedensel maske (causal mask) de kullanılır.

encoder_outputs (`tuple[torch.Tensor]`, *isteğe bağlı*) : (`last_hidden_state`, *isteğe bağlı*: `hidden_states`, *isteğe bağlı*: `attentions`) içeren bir demet. `last_hidden_state`, `(batch_size, sequence_length, hidden_size)` biçiminde, *isteğe bağlı*) kodlayıcının son katmanının çıktısındaki gizli durumlar dizisidir. Kodlayıcının çapraz dikkat (cross-attention) mekanizmasında kullanılır.

cache (`~cache_utils.Cache`, *isteğe bağlı*) : Sıralı çözümlemeyi hızlandırmak için kullanılabilen, önceden hesaplanmış gizli durumlar (self-attention bloklarındaki ve cross-attention bloklarındaki anahtar ve değerler). Bu genellikle, `use_cache=True` veya `config.use_cache=True` olduğunda, çözümlemenin önceki bir aşamasında modelin döndürdüğü `cache`'den oluşur. Girdi olarak yalnızca [Cache](/docs/transformers/main/tr/internal/generation_utils#transformers.Cache) örneği kabul edilir, bkz. [kv cache kılavuzu](https://huggingface.co/docs/transformers/en/kv_cache). `cache` geçirilmezse, varsayılan olarak [DynamicCache](/docs/transformers/main/tr/internal/generation_utils#transformers.DynamicCache) başlatılır. Model, girdi olarak verilen aynı cache biçimini çıktı olarak üretir. `cache` kullanılıyorsa, kullanıcının, bu modele geçmiş anahtar-değer durumları verilmemiş olan, yalnızca işlenmemiş `input_ids`'leri (şekli `(batch_size, unprocessed_length)`) girmesi beklenir; bunun yerine, şekli `(batch_size, sequence_length)` olan tüm `input_ids` girilmez.

inputs_embeds (`torch.Tensor`, şekli `(batch_size, sequence_length, hidden_size)`, *isteğe bağlı*) : `input_ids` parametresini iletmek yerine, gömülü bir temsil doğrudan iletmeyi tercih edebilirsiniz. Bu, `input_ids` indekslerini ilgili vektörlere dönüştürme biçimi üzerinde modelin dahili gömme arama matrisine kıyasla daha fazla kontrol sahibi olmak istiyorsanız faydalıdır.

decoder_inputs_embeds (`torch.Tensor`, şekli `(batch_size, target_sequence_length, hidden_size)`, *isteğe bağlı*) : `decoder_input_ids` parametresini geçirmek yerine, gömülü bir temsil doğrudan geçmeyi tercih edebilirsiniz. `cache` kullanılıyorsa, isteğe bağlı olarak yalnızca son `decoder_inputs_embeds` değerlerinin girdi olarak verilmesi yeterlidir (bkz. `cache`). Bu, `decoder_input_ids` indekslerini ilgili vektörlere dönüştürme biçimi üzerinde modelin dahili gömme arama matrisine kıyasla daha fazla kontrol sahibi olmak istiyorsanız faydalıdır. `decoder_input_ids` ve `decoder_inputs_embeds` parametrelerinin ikisi de ayarlanmamışsa, `decoder_inputs_embeds` parametresi `inputs_embeds` değerini alır.

labels (`torch.LongTensor`, şekli `(batch_size, sequence_length, num_codebooks)`, *isteğe bağlı*) : Dil modelleme için etiketler. Not: Etiketler model içinde **kaydırılır**, yani `labels = input_ids` olarak ayarlayabilirsiniz. İndisler `[-100, 0, ..., config.vocab_size]` aralığından seçilir. `-100` olarak ayarlanan tüm etiketler yok sayılır (maske uygulanır), kayıp yalnızca `[0, ..., config.vocab_size]` aralığındaki etiketler için hesaplanır.

use_cache (`bool`, *isteğe bağlı*) : `True` olarak ayarlanırsa, `cache` anahtar değer durumları döndürülür ve çözümlemeyi hızlandırmak için kullanılabilir (bkz. `cache`).

**Dönüş:** [Seq2SeqLMOutput](/docs/transformers/main/tr/main_classes/output#transformers.modeling_outputs.Seq2SeqLMOutput) veya `tuple(torch.Tensor)`

[Seq2SeqLMOutput](/docs/transformers/main/tr/main_classes/output#transformers.modeling_outputs.Seq2SeqLMOutput) veya bir `torch.Tensor` demeti (eğer `return_dict=False` geçirildiyse veya `config.return_dict=False` ise), yapılandırmaya (`None`) ve girdilere bağlı olarak çeşitli öğelerden oluşur.

[MusicgenForConditionalGeneration](/docs/transformers/main/tr/model_doc/musicgen#transformers.MusicgenForConditionalGeneration) forward metodu, `__call__` özel metodunu geçersiz kılar.

İleri geçiş tarifi bu fonksiyon içinde tanımlanmalı olsa da, sonrasında bunun yerine `Module` örneğini çağırmak gerekir; çünkü ilki ön ve son işleme adımlarını çalıştırmaktan sorumluyken ikincisi bunları sessizce yok sayar.

- **loss** (`torch.Tensor`, şekli `(1,)`, *isteğe bağlı*, `labels` sağlandığında döndürülür) -- Dil modelleme kaybı.
- **logits** (`torch.Tensor`, şekli `(batch_size, sequence_length, config.vocab_size)`) -- Dil modelleme başlığının tahmin puanları (SoftMax öncesi her sözlük jetonu için puanlar).
- **cache** (`EncoderDecoderCache`, *opsiyonel*, `use_cache=True` geçirildiğinde veya `config.use_cache=True` olduğunda döndürülür) -- Bir [EncoderDecoderCache](/docs/transformers/main/tr/internal/generation_utils#transformers.EncoderDecoderCache) örneğidir. Daha fazla ayrıntı için [kv önbellek kılavuzumuza](https://huggingface.co/docs/transformers/en/kv_cache) bakın.

  Sıralı çözümlemeyi hızlandırmak için (bkz. `cache` girdisi) kullanılabilen, önceden hesaplanmış gizli durumları (self-attention bloklarındaki ve cross-attention bloklarındaki anahtar ve değerler) içerir.
- **decoder_hidden_states** (`tuple(torch.Tensor)`, *isteğe bağlı*, `output_hidden_states=True` geçirildiğinde veya `config.output_hidden_states=True` olduğunda döndürülür) -- `torch.Tensor` (modelin bir gömme katmanı varsa gömme katmanının çıktısı için bir tane + her katmanın çıktısı için bir tane) içeren bir tuple, şekli `(batch_size, sequence_length, hidden_size)`.

  Her katmanın çıktısında ve başlangıç gömme çıktılarında dekodlayıcının gizli durumları.
- **decoder_attentions** (`tuple(torch.Tensor)`, *isteğe bağlı*, `output_attentions=True` geçirildiğinde veya `config.output_attentions=True` olduğunda döndürülür) -- `torch.Tensor` (her katman için bir tane) içeren bir tuple, şekli `(batch_size, num_heads, sequence_length, sequence_length)`.

  Dikkat yumuşatma (attention softmax) sonrasında, öz-dikkat (self-attention) kafalarında ağırlıklı ortalamanın hesaplanmasında kullanılan çözücü (decoder) dikkat ağırlıkları.
- **cross_attentions** (`tuple(torch.Tensor)`, *isteğe bağlı*, `output_attentions=True` geçirildiğinde veya `config.output_attentions=True` olduğunda döndürülür) -- `(batch_size, num_heads, sequence_length, sequence_length)` biçiminde, her katman için bir adet içeren `torch.Tensor` demeti.

  Dekoderin çapraz dikkat katmanının dikkat ağırlıkları, dikkat softmax'ından sonra, çapraz dikkat başlıklarında ağırlıklı ortalamanın hesaplanmasında kullanılır.
- **encoder_last_hidden_state** (`torch.Tensor`, şekli `(batch_size, sequence_length, hidden_size)`, *isteğe bağlı*) -- Modelin kodlayıcısının son katmanının çıktısındaki gizli durumlar dizisi.
- **encoder_hidden_states** (`tuple(torch.Tensor)`, *isteğe bağlı*, `output_hidden_states=True` geçirildiğinde veya `config.output_hidden_states=True` olduğunda döndürülür) -- `torch.Tensor` (modelin bir gömme katmanı varsa gömme katmanının çıktısı için bir tane + her katmanın çıktısı için birer tane) içeren, `(batch_size, sequence_length, hidden_size)` biçiminde bir demet.

  Her katmanın çıktısında ve başlangıç gömme çıktılarında kodlayıcının gizli durumları.
- **encoder_attentions** (`tuple(torch.Tensor)`, *isteğe bağlı*, `output_attentions=True` geçirildiğinde veya `config.output_attentions=True` olduğunda döndürülür) -- `torch.Tensor` (her katman için bir tane) içeren bir tuple, şekli `(batch_size, num_heads, sequence_length, sequence_length)`.

  Dikkat yumuşatma (attention softmax) sonrasında, öz-dikkat (self-attention) kafalarında ağırlıklı ortalamanın hesaplanmasında kullanılan kodlayıcının dikkat ağırlıkları.

Örnekler:
```python
>>> from transformers import AutoProcessor, MusicgenForConditionalGeneration
>>> import torch

>>> processor = AutoProcessor.from_pretrained("facebook/musicgen-small")
>>> model = MusicgenForConditionalGeneration.from_pretrained("facebook/musicgen-small")

>>> inputs = processor(
...     text=["80s pop track with bassy drums and synth", "90s rock song with loud guitars and heavy drums"],
...     padding=True,
...     return_tensors="pt",
... )

>>> pad_token_id = model.generation_config.pad_token_id
>>> decoder_input_ids = (
...     torch.ones((inputs.input_ids.shape[0] * model.decoder.num_codebooks, 1), dtype=torch.long)
...     * pad_token_id
... )

>>> logits = model(**inputs, decoder_input_ids=decoder_input_ids).logits
>>> logits.shape  # (bsz * num_codebooks, tgt_len, vocab_size)
torch.Size([8, 1, 2048])
```

