Transformers documentation
Music Flamingo
Model ini dipublikasikan di HF papers pada 2025-11-13 dan disumbangkan ke Hugging Face Transformers pada 2026-03-30.
Music Flamingo
Ikhtisar
Music Flamingo adalah model audio–bahasa besar yang sepenuhnya terbuka, dirancang untuk pemahaman dan penalaran yang tangguh terhadap musik. Model ini dibangun di atas arsitektur Audio Flamingo 3 dengan menyertakan Rotary Time Embeddings (RoTE), yang menyuntikkan informasi posisi temporal agar model dapat menangani urutan audio hingga 20 menit (1200 detik).
Checkpoint model tersedia di: nvidia/music-flamingo-2601-hf
Sorotan:
- Encoder audio terpadu untuk ucapan, suara, dan musik.
- Rotary Time Embeddings (RoTE) untuk pemodelan temporal yang lebih baik, memungkinkan dukungan untuk audio hingga 20 menit.
- Dukungan audio panjang yang diperluas melalui windowing dan post-pool alignment (maksimum 20 menit). Model memproses audio dalam jendela 30 detik dengan batas keras 40 jendela (total 20 menit). Audio yang lebih panjang dari 20 menit akan dipotong.
- Token batas suara khusus (
<|sound_bos|>dan<|sound_eos|>) untuk pemodelan urutan audio yang lebih baik. - Fusi deterministik yang mempertahankan panjang urutan dengan mengganti token placeholder audio dengan embedding audio.
Model ini disumbangkan oleh Lasha Koroshinadze dan Eric Bezzam.
Makalah
Music Flamingo: Skala Pemahaman Musik dalam Model Bahasa Audio
S. Ghosh, A. Goel, L. Koroshinadze, S. Lee, Z. Kong, J. F. Santos, R. Duraiswami, D. Manocha, W. Ping, M. Shoeybi, B. Catanzaro
NVIDIA dan University of Maryland
Proyek: https://research.nvidia.com/labs/adlr/MF/
Penggunaan
Mode Instruct Audio
Model ini mendukung instruksi audio-teks, termasuk interaksi multi-turn, yang semuanya diproses dalam batch.
➡️ audio + instruksi teks
from transformers import AutoProcessor, MusicFlamingoForConditionalGeneration
model_id = "nvidia/music-flamingo-2601-hf"
processor = AutoProcessor.from_pretrained(model_id)
model = MusicFlamingoForConditionalGeneration.from_pretrained(model_id, device_map="auto")
conversation = [
{
"role": "user",
"content": [
{"type": "text", "text": "Describe this track in full detail - tell me the genre, tempo, and key, then dive into the instruments, production style, and overall mood it creates."},
{"type": "audio", "path": "https://huggingface.co/datasets/nvidia/AudioSkills/resolve/main/assets/song_1.mp3"},
],
}
]
inputs = processor.apply_chat_template(
conversation,
tokenize=True,
add_generation_prompt=True,
return_dict=True,
).to(model.device)
inputs["input_features"] = inputs["input_features"].to(model.dtype)
outputs = model.generate(**inputs, max_new_tokens=500)
decoded_outputs = processor.batch_decode(outputs[:, inputs.input_ids.shape[1]:], skip_special_tokens=True)
print(decoded_outputs)➡️ multi-turn:
from transformers import AutoProcessor, MusicFlamingoForConditionalGeneration
model_id = "nvidia/music-flamingo-2601-hf"
processor = AutoProcessor.from_pretrained(model_id)
model = MusicFlamingoForConditionalGeneration.from_pretrained(model_id, device_map="auto")
conversation = [
{
"role": "user",
"content": [
{
"type": "text",
"text": "Write a rich caption that blends the technical details (genre, BPM, key, chords, mix) with how the song feels emotionally and dynamically as it unfolds.",
},
{"type": "audio", "path": "https://huggingface.co/datasets/nvidia/AudioSkills/resolve/main/assets/song_1.mp3"},
],
},
{
"role": "assistant",
"content": [{"type": "text", "text": "This energetic Eurodance anthem at 150 BPM in E major combines bright synth arpeggios with a punchy four-on-the-floor beat..."}],
},
{
"role": "user",
"content": [
{"type": "text", "text": "What instruments stand out the most?"},
],
},
]
inputs = processor.apply_chat_template(
conversation,
tokenize=True,
add_generation_prompt=True,
return_dict=True,
).to(model.device)
inputs["input_features"] = inputs["input_features"].to(model.dtype)
outputs = model.generate(**inputs, max_new_tokens=500)
decoded_outputs = processor.batch_decode(outputs[:, inputs.input_ids.shape[1]:], skip_special_tokens=True)
print(decoded_outputs)➡️ inferensi berbatch!
from transformers import AutoProcessor, MusicFlamingoForConditionalGeneration
model_id = "nvidia/music-flamingo-2601-hf"
processor = AutoProcessor.from_pretrained(model_id)
model = MusicFlamingoForConditionalGeneration.from_pretrained(model_id, device_map="auto")
conversations = [
[
{
"role": "user",
"content": [
{"type": "text", "text": "Describe this track in full detail - tell me the genre, tempo, and key, then dive into the instruments, production style, and overall mood it creates."},
{
"type": "audio",
"path": "https://huggingface.co/datasets/nvidia/AudioSkills/resolve/main/assets/song_1.mp3",
},
],
}
],
[
{
"role": "user",
"content": [
{
"type": "text",
"text": "Generate a structured lyric sheet from the input music.",
},
{"type": "audio", "path": "https://huggingface.co/datasets/nvidia/AudioSkills/resolve/main/assets/song_2.mp3"},
],
}
],
]
inputs = processor.apply_chat_template(
conversations,
tokenize=True,
add_generation_prompt=True,
return_dict=True,
).to(model.device)
inputs["input_features"] = inputs["input_features"].to(model.dtype)
outputs = model.generate(**inputs, max_new_tokens=500)
decoded_outputs = processor.batch_decode(outputs[:, inputs.input_ids.shape[1]:], skip_special_tokens=True)
print(decoded_outputs)➡️ Pelatihan:
from transformers import AutoProcessor, MusicFlamingoForConditionalGeneration
model_id = "nvidia/music-flamingo-2601-hf"
processor = AutoProcessor.from_pretrained(model_id)
model = MusicFlamingoForConditionalGeneration.from_pretrained(model_id, device_map="auto")
model.train()
conversation = [
[
{
"role": "user",
"content": [
{"type": "text", "text": "Break the track down like a critic - list its tempo, key, and chordal motion, then explain the textures, dynamics, and emotional impact of the performance."},
{"type": "audio", "path": "https://huggingface.co/datasets/nvidia/AudioSkills/resolve/main/assets/song_1.mp3"},
],
},
{
"role": "assistant",
"content": [{"type": "text", "text": "This Eurodance track operates at 150 BPM in E major, with harmonic movement centering on the I-vi-IV-V family. The production features layered synth arpeggios, a four-on-the-floor kick pattern, and a mezzo-soprano lead vocal with bright timbre. Dynamically, the track builds through verses into an anthemic chorus with full synth orchestration and backing vocals, creating an uplifting, euphoric atmosphere characteristic of late 2000s dance-pop."}],
}
],
[
{
"role": "user",
"content": [
{
"type": "text",
"text": "Describe this song from both a technical and artistic lens: mention tempo, harmony, and instrumentation, but also mood, lyrical themes, and structure.",
},
{"type": "audio", "path": "https://huggingface.co/datasets/nvidia/AudioSkills/resolve/main/assets/song_2.mp3"},
],
},
{
"role": "assistant",
"content": [{"type": "text", "text": "This electronic pop track combines upbeat production with playful lyrical themes centered around late-night pizza cravings. The structure follows a verse-chorus format with recurring melodic motifs and rhythmic patterns that emphasize the celebratory, lighthearted mood of the piece."}],
}
]
]
inputs = processor.apply_chat_template(
conversation,
tokenize=True,
add_generation_prompt=True,
return_dict=True,
processor_kwargs={"output_labels": True},
).to(model.device)
inputs["input_features"] = inputs["input_features"].to(model.dtype)
loss = model(**inputs).loss
loss.backward()Cara kerja model
Arsitektur
Audio Encoder Ekstraktor fitur + encoder bergaya Whisper → average-pool di sepanjang waktu (stride 2) → LayerNorm. Menghasilkan hidden states per frame pada laju pasca-pool.
Rotary Time Embeddings (RoTE) diterapkan pada output encoder untuk menyuntikkan informasi posisi temporal, memungkinkan model menangani urutan audio hingga 20 menit (1200 detik). RoTE menggunakan 2D axial rotary embeddings untuk dimensi batch dan waktu dengan modulasi sudut berbasis waktu.
MusicFlamingoMultiModalProjector MLP kecil yang memetakan fitur encoder ke ukuran tersembunyi model bahasa.
MusicFlamingoForConditionalGeneration Model bahasa kausal yang menerima embedding teks di mana setiap slot token placeholder audio diganti, di tempatnya, oleh embedding frame audio. Menggunakan token batas khusus (
<|sound_bos|>dan<|sound_eos|>) untuk menandai urutan audio. Tidak ada perubahan panjang urutan yang diperkenalkan oleh fusi.
Penyelarasan tingkat prosesor
- Setiap gelombang mentah dipecah menjadi jendela dengan panjang tetap berdasarkan
chunk_length(detik) dansampling_rate(Hz) dari feature extractor. - Untuk setiap jendela, prosesor menghitung jumlah frame pasca-pool
post_pool_lenyang akan dioutput oleh encoder (sesuai dengan jadwal conv/pool). - Processor memperluas token placeholder audio berdasarkan jumlah total frame pasca-pooling di seluruh jendela.
- Model kemudian mengganti posisi token tersebut dengan embedding audio yang diproyeksikan secara sesuai.
Audio panjang dan windowing
Penting: Panjang audio maksimum adalah 20 menit. Audio yang lebih panjang dari ini akan dipotong.
Pengaturan default memproses jendela 30 detik pada 16 kHz mono.
Processor menerapkan batas keras 40 jendela per sampel, yang menghasilkan durasi audio maksimum 20 menit (40 jendela × 30 detik).
Rotary Time Embeddings (RoTE) menyediakan informasi posisi untuk urutan hingga 20 menit (1200 detik).
Untuk setiap jendela:
mel_lenadalah panjang mel yang telah di-*padding*.- Stack conv mengurangi waktu karena
conv_output_len = (mel_len - 1) // 2 + 1. - Frame per jendela pasca-pooling:
post_pool_len = (conv_output_len - 2) // 2 + 1. - Token placeholder audio diperluas menjadi jumlah dari
post_pool_lendi semua jendela.
MusicFlamingoConfig
kelas transformers.MusicFlamingoConfig
< source >( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Noneaudio_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonetext_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Noneaudio_token_id: int = 151669projector_hidden_act: str = 'gelu'projector_bias: bool = Trueaudio_bos_token_id: int = 151670audio_eos_token_id: int = 151671audio_frame_step: float = 0.01rope_parameters: dict | None = None )
Parameter
- audio_config (
Union[dict, ~configuration_utils.PreTrainedConfig], opsional) — Objek config atau dictionary dari audio backbone. - text_config (
Union[dict, ~configuration_utils.PreTrainedConfig], opsional) — Objek config atau dictionary dari text backbone. - audio_token_id (
int, opsional, default151669) — Indeks token audio yang digunakan sebagai placeholder untuk audio input. - projector_hidden_act (
str, opsional, defaultnyagelu) — Fungsi aktivasi yang digunakan oleh proyektor multimodal. - projector_bias (
bool, opsional, defaultTrue) — Apakah akan menggunakan bias pada multimodal projector. - audio_bos_token_id (
int, opsional, default 151670) — Indeks token awal audio yang digunakan untuk menandai awal rentang audio. - audio_eos_token_id (
int, opsional, default 151671) — Indeks token end-of-audio yang digunakan untuk menandai akhir rentang audio. - audio_frame_step (
float, opsional, default 0.01) — Durasi dalam detik dari satu frame mel input (dilatih dengan hop_length 160 pada sampling_rate 16000). - rope_parameters (
dict, opsional) — Kamus yang berisi parameter konfigurasi untuk embedding RoPE. Kamus tersebut harus berisi nilai untukrope_thetadan secara opsional parameter yang digunakan untuk penskalaan jika Anda ingin menggunakan RoPE denganmax_position_embeddingsyang lebih panjang.
Ini adalah kelas konfigurasi untuk menyimpan konfigurasi dari MusicFlamingoModel. Kelas ini digunakan untuk membuat model Musicflamingo berdasarkan argumen yang ditentukan, yang mendefinisikan arsitektur model. Membuat konfigurasi dengan nilai bawaan akan menghasilkan konfigurasi yang serupa dengan konfigurasi dari nvidia/music-flamingo-2601-hf
Objek konfigurasi mewarisi dari PreTrainedConfig dan dapat digunakan untuk mengontrol output model. Baca dokumentasi dari PreTrainedConfig untuk informasi lebih lanjut.
Contoh:
>>> from transformers import MusicFlamingoForConditionalGeneration, MusicFlamingoConfig, AudioFlamingo3EncoderConfig, Qwen2Config
>>> # Initializing an MusicFlamingoEncoder config
>>> audio_config = AudioFlamingo3EncoderConfig()
>>> # Initializing a Qwen2 config
>>> text_config = Qwen2Config()
>>> # Initializing an MusicFlamingo configuration
>>> configuration = MusicFlamingoConfig(audio_config, text_config)
>>> # Initializing a model from the musicflamingo style configuration
>>> model = MusicFlamingoForConditionalGeneration(configuration)
>>> # Accessing the model configuration
>>> configuration = model.configMusicFlamingoProcessor
kelas transformers.MusicFlamingoProcessor
< source >( feature_extractortokenizerchat_template = Noneaudio_token = '<sound>'audio_bos_token = '<|sound_bos|>'audio_eos_token = '<|sound_eos|>'max_audio_len = 1200 )
Parameter
- feature_extractor (
feature_extractor_class) — Feature extractor adalah input yang wajib. - tokenizer (
tokenizer_class) — Tokenizer adalah input yang wajib. - chat_template (
str) — Template Jinja untuk mengubah daftar pesan dalam chat menjadi string yang dapat ditokenisasi. - audio_token (
Optional[str], opsional, default"<sound>") — Token khusus yang digunakan untuk merepresentasikan input audio dalam template chat. - audio_bos_token (
Optional[str], opsional, default"<|sound_bos|>") — Token khusus yang digunakan untuk mewakili awal audio. - audio_eos_token (
Optional[str], opsional, default"<|sound_eos|>") — Token khusus yang digunakan untuk mewakili akhir audio. - max_audio_len (
int, opsional, default 1200) — Panjang maksimum urutan audio dalam detik. Audio yang lebih panjang dari ini akan dipotong.
Membangun MusicFlamingoProcessor yang membungkus feature extractor dan tokenizer menjadi satu processor.
MusicFlamingoProcessor menyediakan semua fungsionalitas dari feature_extractor_class dan tokenizer_class. Lihat ~feature_extractor_class dan ~tokenizer_class untuk informasi lebih lanjut.
MusicFlamingoModel
kelas transformers.MusicFlamingoModel
< source >( config: MusicFlamingoConfig )
Parameter
- config (MusicFlamingoConfig) — Kelas konfigurasi model dengan semua parameter model. Inisialisasi dengan file konfigurasi tidak memuat bobot yang terkait dengan model, hanya konfigurasinya. Lihat metode from_pretrained() untuk memuat bobot model.
Model MusicFlamingo (encoder Whisper yang telah dihaluskan, proyektor multi-modal, model bahasa Qwen2), tanpa kepala pemodelan bahasa.
Model ini mewarisi dari PreTrainedModel. Periksa dokumentasi kelas induk untuk metode generik yang diimplementasikan oleh pustaka untuk semua model (seperti mengunduh atau menyimpan, mengubah ukuran embedding input, memangkas kepala, dll.)
Model ini juga merupakan subclass dari torch.nn.Module PyTorch. Gunakan sebagai PyTorch Module biasa dan merujuk ke dokumentasi PyTorch untuk semua hal yang berkaitan dengan penggunaan dan perilaku umum.
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = Noneinput_features: typing.Optional[torch.Tensor] = Noneinput_features_mask: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Noneuse_cache: bool | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → MusicFlamingoModelOutputWithPast or tuple(torch.Tensor)
Parameter
- input_ids (
torch.LongTensordengan bentuk(batch_size, sequence_length), opsional) — Indeks token dari urutan input dalam kosakata. Padding akan diabaikan secara default.Indeks dapat diperoleh menggunakan AutoTokenizer. Lihat PreTrainedTokenizer.encode() dan PreTrainedTokenizer.call() untuk detailnya.
- input_features (
torch.Tensordengan bentuk(batch_size, sequence_length, feature_dim), opsional) — Tensor yang sesuai dengan fitur audio input. Fitur audio dapat diperoleh menggunakanfeature_extractor_class. Lihatfeature_extractor_class.__call__untuk detailnya (MusicFlamingoProcessor menggunakanfeature_extractor_classuntuk memproses audio). - input_features_mask (
torch.Tensordengan bentuk(batch_size, feature_sequence_length)) — Mask untuk menghindari pelaksanaan perhatian pada indeks fitur padding. - attention_mask (
torch.Tensordengan bentuk(batch_size, sequence_length), opsional) — Mask untuk menghindari eksekusi attention pada indeks token padding. Nilai mask dipilih dari[0, 1]:- 1 untuk token yang tidak dimasker,
- 0 untuk token yang dimasker.
- position_ids (
torch.LongTensordengan bentuk(batch_size, sequence_length), opsional) — Indeks posisi token dari setiap urutan input dalam position embeddings. Dipilih dalam rentang[0, config.n_positions - 1]. - past_key_values (
~cache_utils.Cache, opsional) — Hidden-states yang sudah dihitung sebelumnya (key dan values di blok self-attention dan di blok cross-attention) yang dapat digunakan untuk mempercepat decoding berurutan. Ini biasanya terdiri daripast_key_valuesyang dikembalikan oleh model pada tahap decoding sebelumnya, ketikause_cache=Trueatauconfig.use_cache=True.Hanya instance Cache yang diizinkan sebagai input, lihat panduan kv cache kami. Jika tidak ada
past_key_valuesyang diteruskan, DynamicCache akan diinisialisasi secara default.Model akan menghasilkan format cache yang sama dengan yang diberikan sebagai input.
Jika
past_key_valuesdigunakan, pengguna diharapkan hanya memasukkaninput_idsyang belum diproses (yang tidak memiliki state past key value yang diberikan ke model ini) dengan bentuk(batch_size, unprocessed_length)alih-alih semuainput_idsdengan bentuk(batch_size, sequence_length). - inputs_embeds (
torch.Tensordengan bentuk(batch_size, sequence_length, hidden_size), opsional) — Secara opsional, alih-alih meneruskaninput_ids, Anda dapat memilih untuk langsung meneruskan representasi tertanam. Hal ini berguna jika Anda ingin memiliki kendali lebih atas cara mengonversi indeksinput_idsmenjadi vektor terkait, dibandingkan dengan matriks pencarian penanaman internal model. - use_cache (
bool, opsional) — Jika diset keTrue, state kunci-nilaipast_key_valuesakan dikembalikan dan dapat digunakan untuk mempercepat decoding (lihatpast_key_values).
Mengembalikan
MusicFlamingoModelOutputWithPast atau tuple(torch.Tensor)
MusicFlamingoModelOutputWithPast atau tuple dari
torch.Tensor (jika return_dict=False diteruskan atau ketika config.return_dict=False) yang terdiri dari berbagai
elemen tergantung pada konfigurasi (MusicFlamingoConfig) dan input.
Metode forward dari MusicFlamingoModel menimpa metode khusus __call__.
Meskipun resep untuk forward pass perlu didefinisikan di dalam fungsi ini, sebaiknya panggil instance
Modulesetelahnya alih-alih fungsi ini, karena yang pertama menangani langkah-langkah pra-pemrosesan dan pasca-pemrosesan, sedangkan yang kedua mengabaikannya secara diam-diam.
- audio_hidden_states (
torch.Tensor, opsional) — Hidden states audio yang diproyeksikan.
MusicFlamingoForConditionalGeneration
kelas transformers.MusicFlamingoForConditionalGeneration
< source >( config: MusicFlamingoConfig )
Parameter
- config (MusicFlamingoConfig) — Kelas konfigurasi model dengan semua parameter model. Inisialisasi dengan file konfigurasi tidak memuat bobot yang terkait dengan model, hanya konfigurasinya. Lihat metode from_pretrained() untuk memuat bobot model.
Model MusicFlamingo yang terdiri dari encoder Whisper yang telah dihaluskan (fine-tuned), rotary time embedding, projector multi-modal, dan model bahasa Qwen2.
Model ini mewarisi dari PreTrainedModel. Periksa dokumentasi kelas induk untuk metode generik yang diimplementasikan oleh pustaka untuk semua model (seperti mengunduh atau menyimpan, mengubah ukuran embedding input, memangkas kepala, dll.)
Model ini juga merupakan subclass dari torch.nn.Module PyTorch. Gunakan sebagai PyTorch Module biasa dan merujuk ke dokumentasi PyTorch untuk semua hal yang berkaitan dengan penggunaan dan perilaku umum.
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = Noneinput_features: typing.Optional[torch.Tensor] = Noneinput_features_mask: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.LongTensor] = Noneuse_cache: bool | None = Nonelogits_to_keep: typing.Union[int, torch.Tensor] = 0**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → MusicFlamingoCausalLMOutputWithPast or tuple(torch.Tensor)
Parameter
- input_ids (
torch.LongTensordengan bentuk(batch_size, sequence_length), opsional) — Indeks token dari urutan input dalam kosakata. Padding akan diabaikan secara default.Indeks dapat diperoleh menggunakan AutoTokenizer. Lihat PreTrainedTokenizer.encode() dan PreTrainedTokenizer.call() untuk detailnya.
- input_features (
torch.Tensordengan bentuk(batch_size, sequence_length, feature_dim), opsional) — Tensor yang sesuai dengan fitur audio input. Fitur audio dapat diperoleh menggunakanfeature_extractor_class. Lihatfeature_extractor_class.__call__untuk detailnya (MusicFlamingoProcessor menggunakanfeature_extractor_classuntuk memproses audio). - input_features_mask (
torch.Tensordengan bentuk(batch_size, feature_sequence_length)) — Mask untuk menghindari pelaksanaan perhatian pada indeks fitur padding. - attention_mask (
torch.Tensordengan bentuk(batch_size, sequence_length), opsional) — Mask untuk menghindari eksekusi attention pada indeks token padding. Nilai mask dipilih dari[0, 1]:- 1 untuk token yang tidak dimasker,
- 0 untuk token yang dimasker.
- position_ids (
torch.LongTensordengan bentuk(batch_size, sequence_length), opsional) — Indeks posisi token dari setiap urutan input dalam position embeddings. Dipilih dalam rentang[0, config.n_positions - 1]. - past_key_values (
~cache_utils.Cache, opsional) — Hidden-states yang sudah dihitung sebelumnya (key dan values di blok self-attention dan di blok cross-attention) yang dapat digunakan untuk mempercepat decoding berurutan. Ini biasanya terdiri daripast_key_valuesyang dikembalikan oleh model pada tahap decoding sebelumnya, ketikause_cache=Trueatauconfig.use_cache=True.Hanya instance Cache yang diizinkan sebagai input, lihat panduan kv cache kami. Jika tidak ada
past_key_valuesyang diteruskan, DynamicCache akan diinisialisasi secara default.Model akan menghasilkan format cache yang sama dengan yang diberikan sebagai input.
Jika
past_key_valuesdigunakan, pengguna diharapkan hanya memasukkaninput_idsyang belum diproses (yang tidak memiliki state past key value yang diberikan ke model ini) dengan bentuk(batch_size, unprocessed_length)alih-alih semuainput_idsdengan bentuk(batch_size, sequence_length). - inputs_embeds (
torch.Tensordengan bentuk(batch_size, sequence_length, hidden_size), opsional) — Secara opsional, alih-alih meneruskaninput_ids, Anda dapat memilih untuk langsung meneruskan representasi tertanam. Hal ini berguna jika Anda ingin memiliki kendali lebih atas cara mengonversi indeksinput_idsmenjadi vektor terkait, dibandingkan dengan matriks pencarian penanaman internal model. - labels (
torch.LongTensordengan bentuk(batch_size, sequence_length), opsional) — Label untuk menghitung kerugian pemodelan bahasa yang disamarkan (masked language modeling loss). - use_cache (
bool, opsional) — Jika diset keTrue, state kunci-nilaipast_key_valuesakan dikembalikan dan dapat digunakan untuk mempercepat decoding (lihatpast_key_values). - logits_to_keep (
Union[int, torch.Tensor], opsional, default0) — Jika berupaint, hitung logits untuklogits_to_keeptoken terakhir. Jika0, hitung logits untuk semuainput_ids(kasus khusus). Hanya logits token terakhir yang diperlukan untuk generasi, dan menghitungnya hanya untuk token tersebut dapat menghemat memori, yang menjadi cukup signifikan untuk urutan panjang atau ukuran kosakata besar. Jika berupatorch.Tensor, harus 1D yang sesuai dengan indeks yang akan dipertahankan pada dimensi panjang urutan. Ini berguna saat menggunakan format tensor terpadu (satu dimensi untuk batch dan panjang urutan).
Mengembalikan
MusicFlamingoCausalLMOutputWithPast atau tuple(torch.Tensor)
MusicFlamingoCausalLMOutputWithPast atau tuple dari
torch.Tensor (jika return_dict=False diteruskan atau ketika config.return_dict=False) yang terdiri dari berbagai
elemen tergantung pada konfigurasi (MusicFlamingoConfig) dan input.
Metode forward dari MusicFlamingoForConditionalGeneration menimpa metode khusus __call__.
Meskipun resep untuk forward pass perlu didefinisikan di dalam fungsi ini, sebaiknya panggil instance
Modulesetelahnya alih-alih fungsi ini, karena yang pertama menangani langkah-langkah pra-pemrosesan dan pasca-pemrosesan, sedangkan yang kedua mengabaikannya secara diam-diam.
loss (
torch.Tensordengan bentuk(1,), opsional, dikembalikan saatlabelsdisediakan) — Loss pemodelan bahasa (untuk prediksi token berikutnya).logits (
torch.Tensordengan bentuk(batch_size, sequence_length, config.vocab_size)) — Skor prediksi dari kepala pemodelan bahasa.past_key_values (
Cache, opsional, dikembalikan ketikause_cache=Truedilewatkan atau ketikaconfig.use_cache=True) — Ini adalah instance Cache.hidden_states (
tuple[torch.Tensor], opsional, dikembalikan saatoutput_hidden_states=Truedilewatkan atau saatconfig.output_hidden_states=True) — Tuple daritorch.Tensor(satu untuk output dari embeddings, jika model memiliki lapisan embedding, + satu untuk output dari setiap lapisan) dengan bentuk(batch_size, sequence_length, hidden_size).Hidden-states model pada output setiap layer ditambah output embedding awal yang opsional.
attentions (
tuple[torch.Tensor], opsional, dikembalikan saatoutput_attentions=Truedilewatkan atau saatconfig.output_attentions=True) — Tuple daritorch.Tensor(satu untuk setiap layer) dengan bentuk(batch_size, num_heads, sequence_length, sequence_length).Bobot perhatian setelah softmax perhatian, digunakan untuk menghitung rata-rata berbobot di kepala perhatian diri (self-attention).
audio_hidden_states (
torch.Tensor, opsional) — Hidden states dari encoder audio setelah proyeksi.