# Audio Flamingo 3

## Ikhtisar

Audio Flamingo 3 (AF3) adalah model audio–bahasa besar yang sepenuhnya terbuka, dirancang untuk pemahaman dan penalaran yang tangguh terhadap ucapan, suara lingkungan, dan musik. AF3 menggabungkan encoder audio bergaya Whisper dengan model bahasa kausal dan melakukan fusi audio–teks dengan penggantian di tempat: prosesor menyelaraskan frame audio pasca-pooling ke token placeholder khusus, dan model mengganti slot token tersebut dengan embedding audio yang diproyeksikan selama forward pass.

Checkpoint model tersedia di: [nvidia/audio-flamingo-3-hf](https://huggingface.co/nvidia/audio-flamingo-3-hf)

Sorotan:

- Encoder audio terpadu untuk ucapan, suara, dan musik.
- **Dukungan audio panjang melalui windowing dan post-pool alignment (maksimum 10 menit).** Model memproses audio dalam jendela 30 detik dengan batas keras 20 jendela (total 10 menit). Audio yang lebih panjang dari 10 menit akan dipotong.
- Fusi deterministik yang mempertahankan panjang urutan dengan mengganti token placeholder audio dengan embedding audio.

Model ini disumbangkan oleh [Lasha Koroshinadze](https://huggingface.co/lashahub) dan [Eric Bezzam](https://huggingface.co/bezzam).

### Makalah

[Audio Flamingo 3](https://huggingface.co/papers/2507.08128): Mendorong Kecerdasan Audio dengan Model Bahasa Audio Besar yang Sepenuhnya Terbuka A. Goel, S. Ghosh, J. Kim, S. Kumar, Z. Kong, S. Lee, C.-H. H. Yang, R. Duraiswami, D. Manocha, R. Valle, B. Catanzaro NVIDIA dan University of Maryland Proyek: https://research.nvidia.com/labs/adlr/AF3/

## Penggunaan

### Mode Instruct Audio

Model ini mendukung instruksi audio-teks, termasuk interaksi multi-turn, yang semuanya diproses dalam batch.

➡️ audio + instruksi teks

```python
from transformers import AudioFlamingo3ForConditionalGeneration, AutoProcessor

model_id = "nvidia/audio-flamingo-3-hf"
processor = AutoProcessor.from_pretrained(model_id)
model = AudioFlamingo3ForConditionalGeneration.from_pretrained(model_id, device_map="auto")

conversation = [
    {
        "role": "user",
        "content": [
            {"type": "text", "text": "Transcribe the input speech."},
            {"type": "audio", "path": "https://huggingface.co/datasets/nvidia/AudioSkills/resolve/main/assets/WhDJDIviAOg_120_10.mp3"},
        ],
    }
]

inputs = processor.apply_chat_template(
    conversation,
    tokenize=True,
    add_generation_prompt=True,
    return_dict=True,
).to(model.device, dtype=model.dtype)

outputs = model.generate(**inputs, max_new_tokens=500)

decoded_outputs = processor.decode(outputs[:, inputs.input_ids.shape[1]:], skip_special_tokens=True)
print(decoded_outputs)
```

➡️ multi-turn:

```python
from transformers import AudioFlamingo3ForConditionalGeneration, AutoProcessor

model_id = "nvidia/audio-flamingo-3-hf"
processor = AutoProcessor.from_pretrained(model_id)
model = AudioFlamingo3ForConditionalGeneration.from_pretrained(model_id, device_map="auto")

conversation = [
    {
        "role": "user",
        "content": [
            {
                "type": "text",
                "text": "Instruction: How does the tone of female speech change throughout the audio? Choose the correct option among the options below: (A) Sad to happy (B) Happy to sad (C) Neutral to happy (D) Happy to neutral.",
            },
            {"type": "audio", "path": "https://huggingface.co/datasets/nvidia/AudioSkills/resolve/main/assets/000000786159.31.wav"},
        ],
    },
    {
        "role": "assistant",
        "content": [{"type": "text", "text": "(A) Sad to happy"}],
    },
    {
        "role": "user",
        "content": [
            {"type": "text", "text": "Why do you think so?"},
        ],
    },
]

inputs = processor.apply_chat_template(
    conversation,
    tokenize=True,
    add_generation_prompt=True,
    return_dict=True,
).to(model.device, dtype=model.dtype)

outputs = model.generate(**inputs, max_new_tokens=500)

decoded_outputs = processor.decode(outputs[:, inputs.input_ids.shape[1]:], skip_special_tokens=True)
print(decoded_outputs)
```

➡️ hanya teks:

```python
from transformers import AudioFlamingo3ForConditionalGeneration, AutoProcessor

model_id = "nvidia/audio-flamingo-3-hf"
processor = AutoProcessor.from_pretrained(model_id)
model = AudioFlamingo3ForConditionalGeneration.from_pretrained(model_id, device_map="auto")

conversation = [
    {
        "role": "user",
        "content": [
            {"type": "text", "text": "What is the capital of France?"},
        ],
    }
]

inputs = processor.apply_chat_template(
    conversation,
    tokenize=True,
    add_generation_prompt=True,
    return_dict=True,
).to(model.device, dtype=model.dtype)

outputs = model.generate(**inputs, max_new_tokens=500)

decoded_outputs = processor.decode(outputs[:, inputs.input_ids.shape[1]:], skip_special_tokens=True)
print(decoded_outputs)
```

➡️ hanya audio:

```python
from transformers import AudioFlamingo3ForConditionalGeneration, AutoProcessor

model_id = "nvidia/audio-flamingo-3-hf"
processor = AutoProcessor.from_pretrained(model_id)
model = AudioFlamingo3ForConditionalGeneration.from_pretrained(model_id, device_map="auto")

conversation = [
    {
        "role": "user",
        "content": [
            {"type": "audio", "path": "https://huggingface.co/datasets/nvidia/AudioSkills/resolve/main/assets/WhDJDIviAOg_120_10.mp3"},
        ],
    }
]

inputs = processor.apply_chat_template(
    conversation,
    tokenize=True,
    add_generation_prompt=True,
    return_dict=True,
).to(model.device, dtype=model.dtype)

outputs = model.generate(**inputs, max_new_tokens=500)

decoded_outputs = processor.decode(outputs[:, inputs.input_ids.shape[1]:], skip_special_tokens=True)
print(decoded_outputs)
```

➡️ inferensi berbatch!

```python
from transformers import AudioFlamingo3ForConditionalGeneration, AutoProcessor

model_id = "nvidia/audio-flamingo-3-hf"
processor = AutoProcessor.from_pretrained(model_id)
model = AudioFlamingo3ForConditionalGeneration.from_pretrained(model_id, device_map="auto")

conversations = [
    [
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "Transcribe the input speech."},
                {
                    "type": "audio",
                    "path": "https://huggingface.co/datasets/nvidia/AudioSkills/resolve/main/assets/t_837b89f2-26aa-4ee2-bdf6-f73f0dd59b26.wav",
                },
            ],
        }
    ],
    [
        {
            "role": "user",
            "content": [
                {
                    "type": "text",
                    "text": "This track feels really peaceful and introspective. What elements make it feel so calming and meditative?",
                },
                {"type": "audio", "path": "https://huggingface.co/datasets/nvidia/AudioSkills/resolve/main/assets/FPSbCAANfbJLVSwD.mp3"},
            ],
        }
    ],
]

inputs = processor.apply_chat_template(
    conversations,
    tokenize=True,
    add_generation_prompt=True,
    return_dict=True,
).to(model.device, dtype=model.dtype)

outputs = model.generate(**inputs, max_new_tokens=500)

decoded_outputs = processor.decode(outputs[:, inputs.input_ids.shape[1]:], skip_special_tokens=True)
print(decoded_outputs)
```

➡️ Pelatihan:

```python
from transformers import AudioFlamingo3ForConditionalGeneration, AutoProcessor

model_id = "nvidia/audio-flamingo-3-hf"
processor = AutoProcessor.from_pretrained(model_id)
model = AudioFlamingo3ForConditionalGeneration.from_pretrained(model_id, device_map="auto")
model.train()

conversation = [
    [
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "Transcribe the input speech."},
                {"type": "audio", "path": "https://huggingface.co/datasets/nvidia/AudioSkills/resolve/main/assets/WhDJDIviAOg_120_10.mp3"},
            ],
        },
        {
            "role": "assistant",
            "content": [{"type": "text", "text": "The transcription of the audio is 'summer follows spring the days grow longer and the nights are warm'."}],
        }
    ],
    [
        {
            "role": "user",
            "content": [
                {
                    "type": "text",
                    "text": "This track feels really peaceful and introspective. What elements make it feel so calming and meditative?",
                },
                {"type": "audio", "path": "https://huggingface.co/datasets/nvidia/AudioSkills/resolve/main/assets/FPSbCAANfbJLVSwD.mp3"},
            ],
        },
        {
            "role": "assistant",
            "content": [{"type": "text", "text": "The transcription of the audio is 'some transcription of the audio'."}],
        }

    ]
]

inputs = processor.apply_chat_template(
    conversation,
    tokenize=True,
    return_dict=True,
    processor_kwargs={"output_labels": True},
).to(model.device, dtype=model.dtype)

loss = model(**inputs).loss
loss.backward()
```

➡️ pintasan transkripsi

```python
from transformers import AudioFlamingo3ForConditionalGeneration, AutoProcessor

model_id = "nvidia/audio-flamingo-3-hf"
processor = AutoProcessor.from_pretrained(model_id)
model = AudioFlamingo3ForConditionalGeneration.from_pretrained(model_id, device_map="auto")

inputs = processor.apply_transcription_request(audio="https://huggingface.co/datasets/nvidia/AudioSkills/resolve/main/assets/t_837b89f2-26aa-4ee2-bdf6-f73f0dd59b26.wav").to(model.device, dtype=model.dtype)

outputs = model.generate(**inputs, max_new_tokens=500)
decoded_outputs = processor.decode(outputs[:, inputs.input_ids.shape[1]:], skip_special_tokens=True, strip_prefix=True)

print(decoded_outputs)
```

Model dilatih untuk mengeluarkan transkripsi yang diawali dengan framing asisten seperti `The spoken content of the audio is "<text>".`. Gunakan `strip_prefix=True` (seperti yang ditunjukkan di atas) untuk menghapus kalimat asisten yang tetap dan tanda kutip di sekitarnya sehingga hanya transkripsi yang tersisa.

## Cara kerja model

### Arsitektur

* **AudioFlamingo3Encoder** Ekstraktor fitur + encoder bergaya Whisper → average-pool di sepanjang waktu (stride 2) → LayerNorm. Menghasilkan hidden states per frame pada laju pasca-pool.

* **AudioFlamingo3MultiModalProjector** MLP kecil yang memetakan fitur encoder ke ukuran tersembunyi model bahasa.

* **AudioFlamingo3ForConditionalGeneration** Model bahasa kausal yang menerima embedding teks, di mana setiap slot token placeholder audio diganti, di tempatnya, oleh embedding frame audio. Tidak ada perubahan panjang urutan yang diperkenalkan oleh fusi.

### Penyelarasan tingkat prosesor

1. Setiap gelombang mentah dipecah menjadi jendela dengan panjang tetap berdasarkan `chunk_length` (detik) dan `sampling_rate` (Hz) dari feature extractor.
2. Untuk setiap jendela, prosesor menghitung jumlah frame pasca-pool `post_pool_len` yang akan dioutput oleh encoder (sesuai dengan jadwal conv/pool).
3. Processor memperluas token placeholder audio berdasarkan jumlah total frame pasca-pooling di seluruh jendela.
4. Model kemudian mengganti posisi token tersebut dengan embedding audio yang diproyeksikan secara sesuai.

## Pola penggunaan

### Jalan pintas transkripsi

Untuk pengenalan ucapan otomatis, Anda dapat melewati penulisan instruksi default setiap kali dan memanggil `apply_transcription_request()`:

```python
inputs = processor.apply_transcription_request(audio=audio_array)
```

Lewati `prompt="Transcribe the input speech."` (atau daftar prompt untuk audio batch) untuk menyesuaikan instruksi sambil tetap mempertahankan penanganan placeholder audio.

`audio` menerima array in-memory, path file lokal, atau URL. Argumen processor mana pun (`text_kwargs`, `audio_kwargs`, dll.) diteruskan, sehingga Anda dapat menyesuaikan padding atau format tensor sama seperti saat memanggil `processor(...)`.

## Audio panjang dan windowing

**Penting: Panjang audio maksimum adalah 10 menit.** Audio yang lebih panjang dari ini akan dipotong.

* Pengaturan default memproses jendela 30 detik pada 16 kHz mono.
* **Processor menerapkan batas keras 20 jendela per sampel, yang menghasilkan durasi audio maksimum 10 menit (20 jendela × 30 detik).**
* Untuk setiap jendela:

  * `mel_len` adalah 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_len` di semua jendela.

## Padding, perhatian, dan penyangga

* **Padding kiri vs padding kanan** Untuk generasi dengan panjang prompt yang bervariasi dalam satu batch, padding kiri biasanya lebih disukai. Untuk pelatihan, padding kanan lebih umum digunakan; mekanisme fusi AF3 sendiri tidak bergantung pada padding karena penggantian dilakukan di tempat.
* **Mask perhatian** Prosesor mengembalikan `attention_mask` (teks) dan `input_features_mask` (audio). Model membangun mask 4-D internal pada sumbu pra-pooling encoder dengan nilai negatif tak hingga pada posisi pad.
* **Penyimpanan sementara** Selama generasi, `input_features` dan `input_features_mask` hanya diteruskan pada langkah pertama. Langkah-langkah berikutnya menggunakan kunci/nilai yang disimpan sementara dari model bahasa.

## Pemecahan Masalah

* Output kosong atau terpotong saat batching Gunakan left padding untuk generasi batched dan decode hanya token baru setelah panjang prompt, seperti yang ditunjukkan di quickstart.

## AudioFlamingo3Config[[transformers.AudioFlamingo3Config]]

#### transformers.AudioFlamingo3Config[[transformers.AudioFlamingo3Config]]

```python
transformers.AudioFlamingo3Config(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, audio_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, text_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, audio_token_id: int = 151669, projector_hidden_act: str = 'gelu', projector_bias: bool = True)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/audioflamingo3/configuration_audioflamingo3.py#L73)

**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*, defaultnya `151669`) : Indeks token audio yang digunakan sebagai placeholder untuk audio input.

projector_hidden_act (`str`, *opsional*, defaultnya `gelu`) : Fungsi aktivasi yang digunakan oleh proyektor multimodal.

projector_bias (`bool`, *opsional*, defaultnya `True`) : Apakah akan menggunakan bias pada proyektor multimodal.

Ini adalah kelas konfigurasi untuk menyimpan konfigurasi dari AudioFlamingo3Model. Kelas ini digunakan untuk membuat instans model Audioflamingo3 berdasarkan argumen yang ditentukan, yang mendefinisikan arsitektur model. Membuat instans konfigurasi dengan nilai bawaan akan menghasilkan konfigurasi yang serupa dengan konfigurasi dari [nvidia/audio-flamingo-3-hf](https://huggingface.co/nvidia/audio-flamingo-3-hf)

Objek konfigurasi mewarisi dari [PreTrainedConfig](/docs/transformers/v5.23.0/id/main_classes/configuration#transformers.PreTrainedConfig) dan dapat digunakan untuk mengontrol keluaran model. Baca dokumentasi dari [PreTrainedConfig](/docs/transformers/v5.23.0/id/main_classes/configuration#transformers.PreTrainedConfig) untuk informasi lebih lanjut.

Contoh:

```python
>>> from transformers import AudioFlamingo3ForConditionalGeneration, AudioFlamingo3Config, AudioFlamingo3EncoderConfig, Qwen2Config

>>> # Initializing an AudioFlamingo3Encoder config
>>> audio_config = AudioFlamingo3EncoderConfig()

>>> # Initializing a Qwen2 config
>>> text_config = Qwen2Config()

>>> # Initializing an AudioFlamingo3 configuration
>>> configuration = AudioFlamingo3Config(audio_config, text_config)

>>> # Initializing a model from the audioflamingo3 style configuration
>>> model = AudioFlamingo3ForConditionalGeneration(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config
```

## AudioFlamingo3EncoderConfig[[transformers.AudioFlamingo3EncoderConfig]]

#### transformers.AudioFlamingo3EncoderConfig[[transformers.AudioFlamingo3EncoderConfig]]

```python
transformers.AudioFlamingo3EncoderConfig(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, num_mel_bins: int = 128, num_hidden_layers: int = 32, num_attention_heads: int = 20, intermediate_size: int = 5120, layerdrop: float | int = 0.0, activation_function: str = 'gelu', hidden_size: int = 1280, dropout: float | int = 0.0, attention_dropout: float | int = 0.0, activation_dropout: float | int = 0.0, initializer_range: float = 0.02, scale_embedding: bool = False, max_source_positions: int = 1500)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/audioflamingo3/configuration_audioflamingo3.py#L26)

**Parameter:**

num_mel_bins (`int`, *opsional*, defaultnya `128`) : Jumlah fitur mel yang digunakan per bingkai input. Seharusnya sesuai dengan nilai yang digunakan di kelas `AutoFeatureExtractor`.

num_hidden_layers (`int`, *opsional*, defaultnya `32`) : Jumlah lapisan tersembunyi dalam decoder Transformer.

num_attention_heads (`int`, *opsional*, defaultnya `20`) : Jumlah kepala perhatian untuk setiap lapisan perhatian dalam decoder Transformer.

intermediate_size (`int`, *opsional*, defaultnya `5120`) : Dimensi dari representasi MLP.

layerdrop (`Union[float, int]`, *opsional*, defaultnya `0.0`) : Probabilitas LayerDrop. Lihat [makalah LayerDrop](see https://huggingface.co/papers/1909.11556) untuk detail lebih lanjut.

activation_function (`str`, *opsional*, defaultnya `gelu`) : Fungsi aktivasi non-linear (fungsi atau string) di decoder. Misalnya, `"gelu"`, `"relu"`, `"silu"`, dan sebagainya.

hidden_size (`int`, *opsional*, defaultnya `1280`) : Dimensi dari representasi tersembunyi.

dropout (`Union[float, int]`, *opsional*, defaultnya `0.0`) : Rasio untuk semua lapisan dropout.

attention_dropout (`Union[float, int]`, *opsional*, defaultnya `0.0`) : Rasio dropout untuk probabilitas perhatian.

activation_dropout (`Union[float, int]`, *opsional*, defaultnya `0.0`) : Rasio dropout untuk aktivasi di dalam lapisan fully connected.

initializer_range (`float`, *opsional*, defaultnya `0.02`) : Deviasi standar dari truncated_normal_initializer untuk menginisialisasi semua matriks bobot.

scale_embedding (`bool`, *opsional*, defaultnya `False`) : Apakah akan menskalakan embedding dengan membaginya oleh sqrt(d_model).

max_source_positions (`int`, *opsional*, default 1500) : Panjang maksimum sekuens fitur log-mel filter-bank yang mungkin digunakan dengan model ini.

Ini adalah kelas konfigurasi untuk menyimpan konfigurasi dari AudioFlamingo3Model. Kelas ini digunakan untuk membuat instans model Audioflamingo3 berdasarkan argumen yang ditentukan, yang mendefinisikan arsitektur model. Membuat instans konfigurasi dengan nilai bawaan akan menghasilkan konfigurasi yang serupa dengan konfigurasi dari [nvidia/audio-flamingo-3-hf](https://huggingface.co/nvidia/audio-flamingo-3-hf)

Objek konfigurasi mewarisi dari [PreTrainedConfig](/docs/transformers/v5.23.0/id/main_classes/configuration#transformers.PreTrainedConfig) dan dapat digunakan untuk mengontrol keluaran model. Baca dokumentasi dari [PreTrainedConfig](/docs/transformers/v5.23.0/id/main_classes/configuration#transformers.PreTrainedConfig) untuk informasi lebih lanjut.

Contoh:

```python
>>> from transformers import AudioFlamingo3EncoderConfig, AudioFlamingo3Encoder

>>> # Initializing an AudioFlamingo3EncoderConfig
>>> configuration = AudioFlamingo3EncoderConfig()

>>> # Initializing an AudioFlamingo3Encoder (with random weights)
>>> model = AudioFlamingo3Encoder(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config
```

## AudioFlamingo3Processor[[transformers.AudioFlamingo3Processor]]

#### transformers.AudioFlamingo3Processor[[transformers.AudioFlamingo3Processor]]

```python
transformers.AudioFlamingo3Processor(feature_extractor, tokenizer, chat_template = None, audio_token = '<sound>', default_transcription_prompt = 'Transcribe the input speech.', max_audio_len = 600)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/audioflamingo3/processing_audioflamingo3.py#L37)

**Parameter:**

feature_extractor (`WhisperFeatureExtractor`) : Ekstraktor fitur adalah input yang wajib.

tokenizer (`Qwen2Tokenizer`) : Tokenizer adalah input yang wajib.

chat_template (`str`) : Template Jinja untuk mengonversi daftar pesan dalam chat menjadi string yang dapat ditokenisasi.

audio_token (`Optional[str]`, *opsional*, defaultnya `"<sound>"`) : Token khusus yang digunakan untuk merepresentasikan input audio dalam template chat.

default_transcription_prompt (`str`, *opsional*, defaultnya `"Transcribe the input speech."`) : Prompt default yang digunakan untuk tugas transkripsi saat menerapkan permintaan transkripsi.

max_audio_len (`int`, *opsional*, default 600) : Panjang maksimum urutan audio dalam detik. Audio yang lebih panjang dari ini akan dipotong.

Membangun AudioFlamingo3Processor yang membungkus feature extractor dan tokenizer menjadi satu processor.

[AudioFlamingo3Processor](/docs/transformers/v5.23.0/id/model_doc/audioflamingo3#transformers.AudioFlamingo3Processor) menyediakan semua fungsionalitas dari [WhisperFeatureExtractor](/docs/transformers/v5.23.0/id/model_doc/whisper#transformers.WhisperFeatureExtractor) dan [Qwen2Tokenizer](/docs/transformers/v5.23.0/id/model_doc/qwen2#transformers.Qwen2Tokenizer). Lihat [~WhisperFeatureExtractor](/docs/transformers/v5.23.0/id/model_doc/whisper#transformers.WhisperFeatureExtractor) dan [~Qwen2Tokenizer](/docs/transformers/v5.23.0/id/model_doc/qwen2#transformers.Qwen2Tokenizer) untuk informasi lebih lanjut.

#### __call__[[transformers.AudioFlamingo3Processor.__call__]]

```python
__call__(text: str | list[str], audio: typing.Union[numpy.ndarray, ForwardRef('torch.Tensor'), collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence['torch.Tensor'], NoneType] = None, output_labels: bool | None = False, **kwargs: *<class 'transformers.processing_utils.ProcessingKwargs'>)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/audioflamingo3/processing_audioflamingo3.py#L71)

**Parameter:**

text (`Union[str, list[str]]`) : Urutan atau batch dari urutan yang akan dienkod. Setiap urutan dapat berupa string atau daftar string (string pretokenized). Jika Anda memasukkan input pretokenized, setel `is_split_into_words=True` untuk menghindari ambiguitas dengan input batched.

audio (`Union[numpy.ndarray, torch.Tensor, collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence[torch.Tensor]]`, *opsional*) : Audio atau batch audio yang akan disiapkan. Setiap audio dapat berupa array NumPy atau tensor PyTorch. Jika berupa array NumPy/tensor PyTorch, setiap audio harus memiliki bentuk (C, T), di mana C adalah jumlah channel, dan T adalah panjang sampel audio.

output_labels (`bool`, *opsional*, default=False) : Apakah akan mengembalikan label untuk pelatihan.

return_mm_token_type_ids (`bool`, *kwargs*) : Apakah akan mengembalikan id tipe token multimodal yang menunjukkan posisi token placeholder multimodal.

return_text_replacement_offsets (`bool`, *kwargs*) : Apakah akan mengembalikan offset karakter untuk setiap placeholder multimodal dan pengantinya.

return_tensors (`str` atau [TensorType](/docs/transformers/v5.23.0/id/internal/file_utils#transformers.TensorType), *opsional*) : Jika diatur, akan mengembalikan tensor dari framework tertentu. Nilai yang dapat diterima adalah:  - `'pt'`: Mengembalikan objek `torch.Tensor` PyTorch. - `'np'`: Mengembalikan objek `np.ndarray` NumPy.

- ****kwargs** ([ProcessingKwargs](/docs/transformers/v5.23.0/id/main_classes/processors#transformers.ProcessingKwargs), *opsional*) : Opsi pemrosesan tambahan untuk setiap modalitas (teks, gambar, video, audio). Parameter spesifik model tercantum di atas; lihat kelas TypedDict untuk daftar lengkap argumen yang didukung.

**Mengembalikan:** [BatchFeature](/docs/transformers/v5.23.0/id/main_classes/feature_extractor#transformers.BatchFeature)

Kamus dengan teks yang ditokenisasi (`input_ids`, `attention_mask`) dan fitur audio (`input_features`, `input_features_mask`).

## AudioFlamingo3Encoder[[transformers.AudioFlamingo3Encoder]]

#### transformers.AudioFlamingo3Encoder[[transformers.AudioFlamingo3Encoder]]

```python
transformers.AudioFlamingo3Encoder(config: AudioFlamingo3EncoderConfig)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/audioflamingo3/modeling_audioflamingo3.py#L303)

**Parameter:**

config ([AudioFlamingo3EncoderConfig](/docs/transformers/v5.23.0/id/model_doc/audioflamingo3#transformers.AudioFlamingo3EncoderConfig)) : Kelas konfigurasi model dengan semua parameter model. Inisialisasi dengan file konfigurasi tidak memuat bobot yang terkait dengan model, hanya konfigurasinya. Lihat metode [from_pretrained()](/docs/transformers/v5.23.0/id/main_classes/model#transformers.PreTrainedModel.from_pretrained) untuk memuat bobot model.

Model audio dari AudioFlamingo3 tanpa head atau proyeksi di atasnya.

Model ini mewarisi dari [PreTrainedModel](/docs/transformers/v5.23.0/id/main_classes/model#transformers.PreTrainedModel). Periksa dokumentasi kelas induk untuk metode generik yang diimplementasikan oleh pustaka ini untuk semua model (seperti mengunduh atau menyimpan, mengubah ukuran input embeddings, memangkas heads, dll.)

Model ini juga merupakan subclass dari [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#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[[transformers.AudioFlamingo3Encoder.forward]]

```python
forward(input_features: Tensor, input_features_mask: typing.Optional[torch.Tensor] = None, **kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/audioflamingo3/modeling_audioflamingo3.py#L350)

**Parameter:**

input_features (`torch.Tensor` dengan bentuk `(batch_size, feature_size, sequence_length)`) : Fitur Log-Mel yang diekstrak dari audio mentah. Gunakan processor/feature extractor untuk menghitung dan melakukan padding fitur-fitur ini dari input waveform.

input_features_mask (`torch.Tensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Mask untuk menghindari pelaksanaan attention pada indeks fitur padding. Nilai mask dipilih dari `[0, 1]`:  - 1 untuk token yang **tidak di-mask**, - 0 untuk token yang **di-mask**.

## AudioFlamingo3Model[[transformers.AudioFlamingo3Model]]

#### transformers.AudioFlamingo3Model[[transformers.AudioFlamingo3Model]]

```python
transformers.AudioFlamingo3Model(config: AudioFlamingo3Config)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/audioflamingo3/modeling_audioflamingo3.py#L448)

**Parameter:**

config ([AudioFlamingo3Config](/docs/transformers/v5.23.0/id/model_doc/audioflamingo3#transformers.AudioFlamingo3Config)) : Kelas konfigurasi model dengan semua parameter model. Inisialisasi dengan file konfigurasi tidak memuat bobot yang terkait dengan model, hanya konfigurasinya. Lihat metode [from_pretrained()](/docs/transformers/v5.23.0/id/main_classes/model#transformers.PreTrainedModel.from_pretrained) untuk memuat bobot model.

Model AudioFlamingo3 (encoder Whisper yang telah dihaluskan, proyektor multi-modal, model bahasa Qwen2), tanpa kepala pemodelan bahasa.

Model ini mewarisi dari [PreTrainedModel](/docs/transformers/v5.23.0/id/main_classes/model#transformers.PreTrainedModel). Periksa dokumentasi kelas induk untuk metode generik yang diimplementasikan oleh pustaka ini untuk semua model (seperti mengunduh atau menyimpan, mengubah ukuran input embeddings, memangkas heads, dll.)

Model ini juga merupakan subclass dari [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#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[[transformers.AudioFlamingo3Model.forward]]

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/audioflamingo3/modeling_audioflamingo3.py#L514)

**Parameter:**

input_ids (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Indeks token dari urutan input dalam kosakata. Padding akan diabaikan secara default. Indeks dapat diperoleh menggunakan [AutoTokenizer](/docs/transformers/v5.23.0/id/model_doc/auto#transformers.AutoTokenizer). Lihat [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/id/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) dan [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/id/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) untuk detailnya. [Apa itu input IDs?](../glossary#input-ids)

input_features (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, feature_dim)`, *opsional*) : Tensor yang sesuai dengan fitur audio input. Fitur audio dapat diperoleh menggunakan [WhisperFeatureExtractor](/docs/transformers/v5.23.0/id/model_doc/whisper#transformers.WhisperFeatureExtractor). Lihat [WhisperFeatureExtractor.__call__()](/docs/transformers/v5.23.0/id/model_doc/whisper#transformers.WhisperFeatureExtractor.__call__) untuk detailnya ([AudioFlamingo3Processor](/docs/transformers/v5.23.0/id/model_doc/audioflamingo3#transformers.AudioFlamingo3Processor) menggunakan [WhisperFeatureExtractor](/docs/transformers/v5.23.0/id/model_doc/whisper#transformers.WhisperFeatureExtractor) untuk memproses audio).

input_features_mask (`torch.Tensor` dengan bentuk `(batch_size, feature_sequence_length)`) : Mask untuk menghindari pelaksanaan perhatian pada indeks fitur padding.

attention_mask (`torch.Tensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Mask untuk menghindari pelaksanaan attention pada indeks token padding. Nilai mask dipilih dalam `[0, 1]`:  - 1 untuk token yang **tidak di-mask**, - 0 untuk token yang **di-mask**.  [Apa itu attention masks?](../glossary#attention-mask)

position_ids (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Indeks posisi token dari setiap urutan input dalam embedding posisi. Dipilih dalam rentang `[0, config.n_positions - 1]`.  [Apa itu position ID?](../glossary#position-ids)

past_key_values (`~cache_utils.Cache`, *opsional*) : Hidden-states yang telah dihitung sebelumnya (key dan values di blok self-attention dan di blok cross-attention) yang dapat digunakan untuk mempercepat decoding berurutan. Ini biasanya terdiri dari `past_key_values` yang dikembalikan oleh model pada tahap decoding sebelumnya, ketika `use_cache=True` atau `config.use_cache=True`. Hanya instance [Cache](/docs/transformers/v5.23.0/id/internal/generation_utils#transformers.Cache) yang diizinkan sebagai input, lihat [panduan kv cache](https://huggingface.co/docs/transformers/en/kv_cache) kami. Jika tidak ada `past_key_values` yang diteruskan, [DynamicCache](/docs/transformers/v5.23.0/id/internal/generation_utils#transformers.DynamicCache) akan diinisialisasi secara default. Model akan mengoutput format cache yang sama dengan yang diberikan sebagai input. Jika `past_key_values` digunakan, pengguna diharapkan untuk hanya menginput `input_ids` yang belum diproses (yang tidak memiliki state past key value mereka diberikan ke model ini) dengan bentuk `(batch_size, unprocessed_length)` alih-alih semua `input_ids` dengan bentuk `(batch_size, sequence_length)`.

inputs_embeds (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, hidden_size)`, *opsional*) : Secara opsional, alih-alih meneruskan `input_ids`, Anda dapat memilih untuk langsung meneruskan representasi tertanam. Ini berguna jika Anda ingin lebih banyak kendali atas cara mengonversi indeks `input_ids` menjadi vektor terkait daripada matriks pencarian penanaman internal model.

use_cache (`bool`, *opsional*) : Jika diatur ke `True`, state kunci-nilai `past_key_values` akan dikembalikan dan dapat digunakan untuk mempercepat decoding (lihat `past_key_values`).

**Mengembalikan:** `AudioFlamingo3ModelOutputWithPast` atau `tuple(torch.Tensor)`

A `AudioFlamingo3ModelOutputWithPast` atau tuple dari `torch.Tensor` (jika `return_dict=False` dilewatkan atau ketika `config.return_dict=False`) yang terdiri dari berbagai elemen tergantung pada konfigurasi ([AudioFlamingo3Config](/docs/transformers/v5.23.0/id/model_doc/audioflamingo3#transformers.AudioFlamingo3Config)) dan input.

Metode forward dari [AudioFlamingo3Model](/docs/transformers/v5.23.0/id/model_doc/audioflamingo3#transformers.AudioFlamingo3Model) menimpa metode khusus `__call__`.

Meskipun resep untuk forward pass perlu didefinisikan di dalam fungsi ini, sebaiknya panggil instance `Module` setelahnya 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.

## AudioFlamingo3ForConditionalGeneration[[transformers.AudioFlamingo3ForConditionalGeneration]]

#### transformers.AudioFlamingo3ForConditionalGeneration[[transformers.AudioFlamingo3ForConditionalGeneration]]

```python
transformers.AudioFlamingo3ForConditionalGeneration(config: AudioFlamingo3Config)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/audioflamingo3/modeling_audioflamingo3.py#L570)

**Parameter:**

config ([AudioFlamingo3Config](/docs/transformers/v5.23.0/id/model_doc/audioflamingo3#transformers.AudioFlamingo3Config)) : Kelas konfigurasi model dengan semua parameter model. Inisialisasi dengan file konfigurasi tidak memuat bobot yang terkait dengan model, hanya konfigurasinya. Lihat metode [from_pretrained()](/docs/transformers/v5.23.0/id/main_classes/model#transformers.PreTrainedModel.from_pretrained) untuk memuat bobot model.

Model AudioFlamingo3 yang terdiri dari encoder Whisper yang telah dihaluskan (fine-tuned), proyektor multi-modal, dan model bahasa Qwen2.

Model ini mewarisi dari [PreTrainedModel](/docs/transformers/v5.23.0/id/main_classes/model#transformers.PreTrainedModel). Periksa dokumentasi kelas induk untuk metode generik yang diimplementasikan oleh pustaka ini untuk semua model (seperti mengunduh atau menyimpan, mengubah ukuran input embeddings, memangkas heads, dll.)

Model ini juga merupakan subclass dari [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#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[[transformers.AudioFlamingo3ForConditionalGeneration.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, input_features: typing.Optional[torch.Tensor] = None, input_features_mask: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, use_cache: bool | None = None, logits_to_keep: typing.Union[int, torch.Tensor] = 0, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/audioflamingo3/modeling_audioflamingo3.py#L582)

**Parameter:**

input_ids (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Indeks token dari urutan input dalam kosakata. Padding akan diabaikan secara default. Indeks dapat diperoleh menggunakan [AutoTokenizer](/docs/transformers/v5.23.0/id/model_doc/auto#transformers.AutoTokenizer). Lihat [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/id/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) dan [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/id/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) untuk detailnya. [Apa itu input IDs?](../glossary#input-ids)

input_features (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, feature_dim)`, *opsional*) : Tensor yang sesuai dengan fitur audio input. Fitur audio dapat diperoleh menggunakan [WhisperFeatureExtractor](/docs/transformers/v5.23.0/id/model_doc/whisper#transformers.WhisperFeatureExtractor). Lihat [WhisperFeatureExtractor.__call__()](/docs/transformers/v5.23.0/id/model_doc/whisper#transformers.WhisperFeatureExtractor.__call__) untuk detailnya ([AudioFlamingo3Processor](/docs/transformers/v5.23.0/id/model_doc/audioflamingo3#transformers.AudioFlamingo3Processor) menggunakan [WhisperFeatureExtractor](/docs/transformers/v5.23.0/id/model_doc/whisper#transformers.WhisperFeatureExtractor) untuk memproses audio).

input_features_mask (`torch.Tensor` dengan bentuk `(batch_size, feature_sequence_length)`) : Mask untuk menghindari pelaksanaan perhatian pada indeks fitur padding.

attention_mask (`torch.Tensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Mask untuk menghindari pelaksanaan attention pada indeks token padding. Nilai mask dipilih dalam `[0, 1]`:  - 1 untuk token yang **tidak di-mask**, - 0 untuk token yang **di-mask**.  [Apa itu attention masks?](../glossary#attention-mask)

position_ids (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Indeks posisi token dari setiap urutan input dalam embedding posisi. Dipilih dalam rentang `[0, config.n_positions - 1]`.  [Apa itu position ID?](../glossary#position-ids)

past_key_values (`~cache_utils.Cache`, *opsional*) : Hidden-states yang telah dihitung sebelumnya (key dan values di blok self-attention dan di blok cross-attention) yang dapat digunakan untuk mempercepat decoding berurutan. Ini biasanya terdiri dari `past_key_values` yang dikembalikan oleh model pada tahap decoding sebelumnya, ketika `use_cache=True` atau `config.use_cache=True`. Hanya instance [Cache](/docs/transformers/v5.23.0/id/internal/generation_utils#transformers.Cache) yang diizinkan sebagai input, lihat [panduan kv cache](https://huggingface.co/docs/transformers/en/kv_cache) kami. Jika tidak ada `past_key_values` yang diteruskan, [DynamicCache](/docs/transformers/v5.23.0/id/internal/generation_utils#transformers.DynamicCache) akan diinisialisasi secara default. Model akan mengoutput format cache yang sama dengan yang diberikan sebagai input. Jika `past_key_values` digunakan, pengguna diharapkan untuk hanya menginput `input_ids` yang belum diproses (yang tidak memiliki state past key value mereka diberikan ke model ini) dengan bentuk `(batch_size, unprocessed_length)` alih-alih semua `input_ids` dengan bentuk `(batch_size, sequence_length)`.

inputs_embeds (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, hidden_size)`, *opsional*) : Secara opsional, alih-alih meneruskan `input_ids`, Anda dapat memilih untuk langsung meneruskan representasi tertanam. Ini berguna jika Anda ingin lebih banyak kendali atas cara mengonversi indeks `input_ids` menjadi vektor terkait daripada matriks pencarian penanaman internal model.

labels (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Label untuk menghitung kerugian pemodelan bahasa yang disamarkan (masked language modeling loss).

use_cache (`bool`, *opsional*) : Jika diatur ke `True`, state kunci-nilai `past_key_values` akan dikembalikan dan dapat digunakan untuk mempercepat decoding (lihat `past_key_values`).

logits_to_keep (`Union[int, torch.Tensor]`, *opsional*, defaultnya `0`) : Jika berupa `int`, hitung logits untuk `logits_to_keep` token terakhir. Jika `0`, hitung logits untuk semua `input_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 berupa `torch.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:** `AudioFlamingo3CausalLMOutputWithPast` atau `tuple(torch.Tensor)`

Sebuah `AudioFlamingo3CausalLMOutputWithPast` atau tuple dari `torch.Tensor` (jika `return_dict=False` dilewatkan atau ketika `config.return_dict=False`) yang terdiri dari berbagai elemen tergantung pada konfigurasi ([AudioFlamingo3Config](/docs/transformers/v5.23.0/id/model_doc/audioflamingo3#transformers.AudioFlamingo3Config)) dan input.

Metode forward dari [AudioFlamingo3ForConditionalGeneration](/docs/transformers/v5.23.0/id/model_doc/audioflamingo3#transformers.AudioFlamingo3ForConditionalGeneration) menimpa metode khusus `__call__`.

Meskipun resep untuk forward pass perlu didefinisikan di dalam fungsi ini, sebaiknya panggil instance `Module` setelahnya alih-alih fungsi ini, karena yang pertama menangani langkah-langkah pra-pemrosesan dan pasca-pemrosesan, sedangkan yang kedua mengabaikannya secara diam-diam.

- **loss** (`torch.Tensor` dengan bentuk `(1,)`, *opsional*, dikembalikan saat `labels` disediakan) -- Loss pemodelan bahasa (untuk prediksi token berikutnya).
- **logits** (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, config.vocab_size)`) -- Skor prediksi dari kepala pemodelan bahasa.
- **past_key_values** (`Cache`, *opsional*, dikembalikan ketika `use_cache=True` dilewatkan atau ketika `config.use_cache=True`) -- Ini adalah instance [Cache](/docs/transformers/v5.23.0/id/internal/generation_utils#transformers.Cache).
- **hidden_states** (`tuple[torch.Tensor]`, *opsional*, dikembalikan ketika `output_hidden_states=True` dilewatkan atau ketika `config.output_hidden_states=True`) -- Tuple dari `torch.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 ketika `output_attentions=True` dilewatkan atau ketika `config.output_attentions=True`) -- Tuple dari `torch.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 self-attention.
- **audio_hidden_states** (`torch.Tensor`, *opsional*) -- Hidden states dari audio encoder setelah proyeksi.

Contoh:

```python
>>> from transformers import AudioFlamingo3ForConditionalGeneration, AutoProcessor

>>> model_id = "nvidia/audio-flamingo-3-hf"
>>> processor = AutoProcessor.from_pretrained(model_id)
>>> model = AudioFlamingo3ForConditionalGeneration.from_pretrained(model_id, device_map="auto")
```

#### get_audio_features[[transformers.AudioFlamingo3ForConditionalGeneration.get_audio_features]]

```python
get_audio_features(input_features, input_features_mask, **kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/audioflamingo3/modeling_audioflamingo3.py#L579)

