# Audio Flamingo 3

## 개요

Audio Flamingo 3(AF3)는 음성, 환경음, 음악에 대한 견고한 이해와 추론을 위해 설계된 완전히 오픈된 대규모 오디오-언어 모델입니다. AF3는 Whisper 스타일의 오디오 인코더와 인과 언어 모델을 결합하며, 자리 대체 방식의 오디오-텍스트 융합을 수행합니다. 프로세서가 풀링된 오디오 프레임을 전용 플레이스홀더 토큰에 정렬하고, 모델이 포워드 패스 중에 해당 토큰 슬롯을 투영된 오디오 임베딩으로 대체합니다.

모델 체크포인트는 [nvidia/audio-flamingo-3-hf](https://huggingface.co/nvidia/audio-flamingo-3-hf)에서 사용할 수 있습니다.

주요 내용:

- 음성, 소리, 음악 전반에 걸친 통합 오디오 인코더
- **윈도 처리 및 풀링 후 정렬을 통한 긴 오디오 지원(최대 10분).** 모델은 오디오를 30초 단위의 윈도로 처리하며, 최대 20개 윈도(총 10분)로 제한됩니다. 10분을 초과하는 오디오는 잘립니다.
- 오디오 플레이스홀더 토큰을 오디오 임베딩으로 대체하여 시퀀스 길이를 유지하는 결정론적 융합입니다.

이 모델은 [Lasha Koroshinadze](https://huggingface.co/lashahub)와 [Eric Bezzam](https://huggingface.co/bezzam)이 기여했습니다.

### 논문

[Audio Flamingo 3](https://huggingface.co/papers/2507.08128): 완전 오픈 소스 대형 오디오 언어 모델로 오디오 지능을 한 단계 더 나아가다. 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 and University of Maryland 프로젝트: https://research.nvidia.com/labs/adlr/AF3/

## 사용

### 오디오 Instruct 모드

모델은 오디오-텍스트 지시를 지원하며, 다중 턴 상호작용을 포함하여 모두 배치로 처리됩니다.

➡️ 오디오 + 텍스트 지시

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

➡️ 다중 턴:

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

➡️ 텍스트만:

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

➡️ 오디오만:

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

➡️ 배치 추론!

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

➡️ 학습:

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

➡️ 전사 바로 가기

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

모델은 `The spoken content of the audio is "<text>".`과 같은 어시스턴트 프레이밍으로 시작하는 전사 결과를 출력하도록 학습됩니다. `strip_prefix=True`(위와 같이)를 사용하면 고정된 어시스턴트 문장과 surrounding quotes를 제거하여 전사 결과만 남게 됩니다.

## 모델 작동 방식

### 아키텍처

* **AudioFlamingo3Encoder** Whisper 스타일의 feature extractor + encoder → 시간 차원 평균 풀링(stride 2) → LayerNorm. 풀링 후 레이트에서 프레임별 hidden states를 생성합니다.

* **AudioFlamingo3MultiModalProjector** 인코더 특징을 언어 모델의 hidden size로 매핑하는 작은 MLP입니다.

* **AudioFlamingo3ForConditionalGeneration** 각 오디오 플레이스홀더 토큰 슬롯이 오디오 프레임 임베딩으로 제자리에서 대체되는 텍스트 임베딩을 입력으로 받는 인과 언어 모델입니다. 융합 과정에서 시퀀스 길이가 변경되지 않습니다.

### 프로세서 수준 정렬

1. 각 원시 웨이브폼은 피처 추출기의 `chunk_length`(초)와 `sampling_rate`(Hz)를 기준으로 고정 길이의 윈도우로 분할됩니다.
2. 각 윈도우에 대해 프로세서가 인코더가 출력할 풀링 후 프레임 수 `post_pool_len`을 계산합니다(컨볼루션/풀링 스케줄과 일치).
3. processor는 모든 윈도우에 걸친 풀링 후 프레임의 총 개수에 따라 오디오 플레이스홀더 토큰을 확장합니다.
4. 모델은 나중에 해당 토큰 위치를 대응하는 투영된 오디오 임베딩으로 대체합니다.

## 사용 패턴

### 전사 바로 가기

자동 음성 인식의 경우, 매번 기본 지시를 작성할 필요 없이 `apply_transcription_request()`를 호출할 수 있습니다:

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

오디오 플레이스홀더 처리를 유지하면서 지시를 사용자 지정하려면 `prompt="Transcribe the input speech."` (또는 배치 오디오용 프롬프트 목록)를 전달하세요.

`audio`는 메모리 내 배열, 로컬 파일 경로 또는 URL을 입력으로 받습니다. 모든 프로세서 kwargs(`text_kwargs`, `audio_kwargs` 등)가 전달되므로, `processor(...)`를 호출할 때와 마찬가지로 패딩이나 텐서 형식을 조정할 수 있습니다.

## 긴 오디오와 윈도우링

**중요: 최대 오디오 길이는 10분입니다.** 이보다 긴 오디오는 잘립니다.

* 기본 설정은 16 kHz 모노로 30초 창을 처리합니다.
* **프로세서가 샘플당 최대 20개 윈도우라는 하드 리밋을 적용하므로, 최대 10분(20개 윈도우 × 30초)의 오디오만 처리할 수 있습니다.**
* 각 윈도우에 대해:

  * `mel_len`은 패딩된 멜 스펙트로그램의 길이를 나타냅니다.
  * Conv 스택은 `conv_output_len = (mel_len - 1) // 2 + 1`이므로 시간을 줄입니다.
  * 윈도우당 풀링 후 프레임 수: `post_pool_len = (conv_output_len - 2) // 2 + 1`.
  * 오디오 플레이스홀더 토큰은 모든 윈도우의 `post_pool_len` 합으로 확장됩니다.

## 패딩, 어텐션, 캐싱

* **왼쪽 패딩과 오른쪽 패딩** 배치 내에서 프롬프트 길이가 혼합된 생성 작업에는 일반적으로 왼쪽 패딩이 더 적합합니다. 학습에는 오른쪽 패딩이 일반적이며, AF3의 퓨전 메커니즘 자체는 제자리로 치환하기 때문에 패딩 방식에 무관합니다.
* **Attention masks** 프로세서가 `attention_mask`(텍스트)와 `input_features_mask`(오디오)를 반환합니다. 모델은 인코더의 pre-pool 축에서 패드 위치를 음의 무한대로 설정한 내부 4차원 마스크를 구성합니다.
* **캐싱** 생성 과정에서 `input_features`와 `input_features_mask`는 첫 번째 단계에서만 전달됩니다. 이후 단계에서는 언어 모델의 캐시된 키/값을 사용합니다.

## 문제 해결

* 배치 처리 시 빈 출력 또는 잘린 출력 빠른 시작에 나와 있듯이, 배치 생성에는 왼쪽 패딩을 사용하고 프롬프트 길이 이후의 새 토큰만 디코딩하세요.

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

[소스](https://github.com/huggingface/transformers/blob/main/src/transformers/models/audioflamingo3/configuration_audioflamingo3.py#L73)

**매개변수:**

audio_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *선택*) : 오디오 백본의 config 객체 또는 사전입니다.

text_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *선택*) : 텍스트 백본의 config 객체 또는 사전입니다.

audio_token_id (`int`, *선택 사항*, 기본값 `151669`) : 입력 오디오를 위한 플레이스홀더로 사용되는 오디오 토큰 인덱스입니다.

projector_hidden_act (`str`, *선택 사항*, 기본값 `gelu`) : 멀티모달 프로젝터에 사용되는 활성화 함수입니다.

projector_bias (`bool`, *선택 사항*, 기본값 `True`) : 멀티모달 프로젝터에 bias를 사용할지 여부.

이것은 AudioFlamingo3Model의 구성을 저장하기 위한 구성 클래스입니다. 지정된 인자에 따라 Audioflamingo3 모델을 인스턴스화하고 모델 아키텍처를 정의하는 데 사용됩니다. 기본값으로 구성을 인스턴스화하면 [nvidia/audio-flamingo-3-hf](https://huggingface.co/nvidia/audio-flamingo-3-hf)와 유사한 구성이 생성됩니다.

Configuration 객체는 [PreTrainedConfig](/docs/transformers/main/ko/main_classes/configuration#transformers.PreTrainedConfig)를 상속하며, 모델 출력을 제어하는 데 사용할 수 있습니다. 자세한 내용은 [PreTrainedConfig](/docs/transformers/main/ko/main_classes/configuration#transformers.PreTrainedConfig)의 문서를 참고하세요.

예:

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

[소스](https://github.com/huggingface/transformers/blob/main/src/transformers/models/audioflamingo3/configuration_audioflamingo3.py#L26)

**매개변수:**

num_mel_bins (`int`, *선택 사항*, 기본값 `128`) : 입력 프레임당 사용되는 mel 특징의 수입니다. `AutoFeatureExtractor` 클래스에서 사용된 값과 일치해야 합니다.

num_hidden_layers (`int`, *선택 사항*, 기본값 `32`) : Transformer decoder의 숨겨진 레이어 수.

num_attention_heads (`int`, *선택 사항*, 기본값 `20`) : Transformer decoder의 각 attention layer에 사용할 attention head의 수입니다.

intermediate_size (`int`, *선택 사항*, 기본값 `5120`) : MLP 표현의 차원.

layerdrop (`Union[float, int]`, *선택 사항*, 기본값 `0.0`) : LayerDrop 확률입니다. 자세한 내용은 [LayerDrop 논문](see https://huggingface.co/papers/1909.11556)을 참고하세요.

activation_function (`str`, *선택 사항*, 기본값 `gelu`) : 디코더에서 사용되는 비선형 활성화 함수(함수 또는 문자열). 예를 들어, `"gelu"`, `"relu"`, `"silu"` 등이 있습니다.

hidden_size (`int`, *선택 사항*, 기본값 `1280`) : 숨겨진 표현의 차원.

dropout (`Union[float, int]`, *선택 사항*, 기본값 `0.0`) : 모든 dropout 레이어에 적용되는 비율입니다.

attention_dropout (`Union[float, int]`, *선택 사항*, 기본값 `0.0`) : attention 확률에 적용할 dropout 비율입니다.

activation_dropout (`Union[float, int]`, *선택 사항*, 기본값 `0.0`) : 완전 연결 계층 내부 활성화에 적용되는 dropout 비율입니다.

initializer_range (`float`, *선택 사항*, 기본값 `0.02`) : 모든 가중치 행렬을 초기화하는 truncated_normal_initializer의 표준 편차입니다.

scale_embedding (`bool`, *선택 사항*, 기본값 `False`) : 임베딩을 sqrt(d_model)로 나누어 스케일링할지 여부.

max_source_positions (`int`, *선택 사항*, 기본값 1500) : 이 모델이 사용될 수 있는 log-mel filter-bank feature의 최대 시퀀스 길이입니다.

이것은 AudioFlamingo3Model의 구성을 저장하기 위한 구성 클래스입니다. 지정된 인자에 따라 Audioflamingo3 모델을 인스턴스화하고 모델 아키텍처를 정의하는 데 사용됩니다. 기본값으로 구성을 인스턴스화하면 [nvidia/audio-flamingo-3-hf](https://huggingface.co/nvidia/audio-flamingo-3-hf)와 유사한 구성이 생성됩니다.

Configuration 객체는 [PreTrainedConfig](/docs/transformers/main/ko/main_classes/configuration#transformers.PreTrainedConfig)를 상속하며, 모델 출력을 제어하는 데 사용할 수 있습니다. 자세한 내용은 [PreTrainedConfig](/docs/transformers/main/ko/main_classes/configuration#transformers.PreTrainedConfig)의 문서를 참고하세요.

예:

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

[소스](https://github.com/huggingface/transformers/blob/main/src/transformers/models/audioflamingo3/processing_audioflamingo3.py#L53)

**매개변수:**

feature_extractor (`WhisperFeatureExtractor`) : feature extractor는 필수 입력입니다.

tokenizer (`Qwen2Tokenizer`) : 토크나이저는 필수 입력값입니다.

chat_template (`str`) : 채팅의 메시지 목록을 토큰화 가능한 문자열로 변환하는 Jinja 템플릿입니다.

audio_token (`Optional[str]`, *선택 사항*, 기본값 `"<sound>"`) : 채팅 템플릿에서 오디오 입력을 나타내는 데 사용되는 특수 토큰입니다.

default_transcription_prompt (`str`, *선택 사항*, 기본값 `"Transcribe the input speech."`) : 전사 요청을 적용할 때 전사 작업에 사용할 기본 프롬프트입니다.

max_audio_len (`int`, *선택 사항*, 기본값 600) : 오디오 시퀀스의 최대 길이(초). 이 길이를 초과하는 오디오는 잘립니다.

AudioFlamingo3Processor를 생성하며, feature extractor와 tokenizer를 단일 processor로 래핑합니다.

[AudioFlamingo3Processor](/docs/transformers/main/ko/model_doc/audioflamingo3#transformers.AudioFlamingo3Processor)는 [WhisperFeatureExtractor](/docs/transformers/main/ko/model_doc/whisper#transformers.WhisperFeatureExtractor)와 [Qwen2Tokenizer](/docs/transformers/main/ko/model_doc/qwen2#transformers.Qwen2Tokenizer)의 모든 기능을 제공합니다. 자세한 내용은 [~WhisperFeatureExtractor](/docs/transformers/main/ko/model_doc/whisper#transformers.WhisperFeatureExtractor)와 [~Qwen2Tokenizer](/docs/transformers/main/ko/model_doc/qwen2#transformers.Qwen2Tokenizer)를 참고하세요.

#### __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.models.audioflamingo3.processing_audioflamingo3.AudioFlamingo3ProcessorKwargs'>)
```

[소스](https://github.com/huggingface/transformers/blob/main/src/transformers/models/audioflamingo3/processing_audioflamingo3.py#L79)

**매개변수:**

text (`Union[str, list[str]]`) : 인코딩할 시퀀스 또는 시퀀스 배치입니다. 각 시퀀스는 문자열 또는 문자열 목록(사전 토큰화된 문자열)일 수 있습니다. 사전 토큰화된 입력을 전달하는 경우, 배치 입력과의 혼동을 피하기 위해 `is_split_into_words=True`를 설정하세요.

audio (`Union[numpy.ndarray, torch.Tensor, collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence[torch.Tensor]]`, *선택 사항*) : 준비할 오디오 또는 오디오 배치입니다. 각 오디오는 NumPy 배열 또는 PyTorch 텐서일 수 있습니다. NumPy 배열/PyTorch 텐서의 경우, 각 오디오의 shape은 (C, T)여야 하며, 여기서 C는 채널 수, T는 오디오의 샘플 길이입니다.

output_labels (`bool`, *선택*, 기본값=False) : 학습용 라벨을 반환할지 여부.

return_tensors (`str` 또는 [TensorType](/docs/transformers/main/ko/internal/file_utils#transformers.TensorType), *optional*) : 설정된 경우, 특정 프레임워크의 텐서를 반환합니다. 허용되는 값은 다음과 같습니다:  - `'pt'`: PyTorch `torch.Tensor` 객체를 반환합니다. - `'np'`: NumPy `np.ndarray` 객체를 반환합니다.

- ****kwargs** ([ProcessingKwargs](/docs/transformers/main/ko/main_classes/processors#transformers.ProcessingKwargs), *optional*) : 각 모달리티(텍스트, 이미지, 비디오, 오디오)에 대한 추가 처리 옵션입니다. 모델별 매개변수는 위에 나열되어 있으며, 지원되는 인수의 전체 목록은 TypedDict 클래스를 참조하세요.

**반환값:** [BatchFeature](/docs/transformers/main/ko/main_classes/feature_extractor#transformers.BatchFeature)

토큰화된 텍스트(`input_ids`, `attention_mask`)와 오디오 특징(`input_features`, `input_features_mask`)을 포함하는 사전입니다.

## AudioFlamingo3Encoder[[transformers.AudioFlamingo3Encoder]]

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

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

[소스](https://github.com/huggingface/transformers/blob/main/src/transformers/models/audioflamingo3/modeling_audioflamingo3.py#L303)

**매개변수:**

config ([AudioFlamingo3EncoderConfig](/docs/transformers/main/ko/model_doc/audioflamingo3#transformers.AudioFlamingo3EncoderConfig)) : 모델의 모든 매개변수를 포함하는 모델 구성 클래스입니다. 구성 파일로 초기화하는 것은 모델과 연관된 가중치를 로드하지 않으며, 구성 정보만 로드합니다. 모델 가중치를 로드하려면 [from_pretrained()](/docs/transformers/main/ko/main_classes/model#transformers.PreTrainedModel.from_pretrained) 메서드를 확인하세요.

AudioFlamingo3의 오디오 모델로, 상단에 헤드나 투영이 없는 상태입니다.

이 모델은 [PreTrainedModel](/docs/transformers/main/ko/main_classes/model#transformers.PreTrainedModel)에서 상속됩니다. 라이브러리가 모든 모델에 대해 구현하는 일반적 메서드(다운로드 또는 저장, 입력 임베딩 크기 조정, 헤드 프루닝 등)에 대해서는 상위 클래스 문서를 확인하세요.

이 모델은 또한 PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module)의 하위 클래스입니다. 일반적인 PyTorch Module처럼 사용하며, 일반적인 사용법과 동작에 관한 모든 사항은 PyTorch 문서를 참조하세요.

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

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

[소스](https://github.com/huggingface/transformers/blob/main/src/transformers/models/audioflamingo3/modeling_audioflamingo3.py#L350)

**매개변수:**

input_features (`torch.FloatTensor`, shape `(batch_size, feature_size, sequence_length)`) : 원시 오디오에서 추출한 Log-Mel 특징. 프로세서/피처 추출기를 사용하여 웨이브폼 입력에서 이 특징을 계산하고 패딩합니다.

input_features_mask (`torch.FloatTensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : 패딩 feature 인덱스에 대한 attention 수행을 방지하기 위한 마스크. `[0, 1]`에서 선택된 마스크 값: - **마스크되지 않은** 토큰은 1, - **마스크된** 토큰은 0.

## AudioFlamingo3Model[[transformers.AudioFlamingo3Model]]

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

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

[소스](https://github.com/huggingface/transformers/blob/main/src/transformers/models/audioflamingo3/modeling_audioflamingo3.py#L444)

**매개변수:**

config ([AudioFlamingo3Config](/docs/transformers/main/ko/model_doc/audioflamingo3#transformers.AudioFlamingo3Config)) : 모델의 모든 매개변수를 포함하는 모델 구성 클래스입니다. 구성 파일로 초기화하는 것은 모델과 연관된 가중치를 로드하지 않으며, 구성 정보만 로드합니다. 모델 가중치를 로드하려면 [from_pretrained()](/docs/transformers/main/ko/main_classes/model#transformers.PreTrainedModel.from_pretrained) 메서드를 확인하세요.

AudioFlamingo3 모델(파인튜닝된 Whisper 인코더, 멀티모달 프로젝터, Qwen2 언어 모델)로, 언어 모델링 헤드가 없습니다.

이 모델은 [PreTrainedModel](/docs/transformers/main/ko/main_classes/model#transformers.PreTrainedModel)에서 상속됩니다. 라이브러리가 모든 모델에 대해 구현하는 일반적 메서드(다운로드 또는 저장, 입력 임베딩 크기 조정, 헤드 프루닝 등)에 대해서는 상위 클래스 문서를 확인하세요.

이 모델은 또한 PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module)의 하위 클래스입니다. 일반적인 PyTorch Module처럼 사용하며, 일반적인 사용법과 동작에 관한 모든 사항은 PyTorch 문서를 참조하세요.

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

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, input_features: typing.Optional[torch.FloatTensor] = 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.FloatTensor] = None, use_cache: bool | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[소스](https://github.com/huggingface/transformers/blob/main/src/transformers/models/audioflamingo3/modeling_audioflamingo3.py#L510)

**매개변수:**

input_ids (`torch.LongTensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : 어휘(input sequence tokens)의 인덱스입니다. 기본적으로 패딩은 무시됩니다. [AutoTokenizer](/docs/transformers/main/ko/model_doc/auto#transformers.AutoTokenizer)를 사용하여 인덱스를 얻을 수 있습니다. 자세한 내용은 [PreTrainedTokenizer.encode()](/docs/transformers/main/ko/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) 및 [PreTrainedTokenizer.__call__()](/docs/transformers/main/ko/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__)를 참조하세요. [입력 ID란 무엇인가요?](../glossary#input-ids)

input_features (`torch.FloatTensor`, shape `(batch_size, sequence_length, feature_dim)`, *선택 사항*) : 입력 오디오 특징에 해당하는 텐서입니다. 오디오 특징은 [WhisperFeatureExtractor](/docs/transformers/main/ko/model_doc/whisper#transformers.WhisperFeatureExtractor)를 사용하여 얻을 수 있습니다. 자세한 내용은 [WhisperFeatureExtractor.__call__()](/docs/transformers/main/ko/model_doc/whisper#transformers.WhisperFeatureExtractor.__call__)를 참조하세요 ([AudioFlamingo3Processor](/docs/transformers/main/ko/model_doc/audioflamingo3#transformers.AudioFlamingo3Processor)는 오디오 처리에 [WhisperFeatureExtractor](/docs/transformers/main/ko/model_doc/whisper#transformers.WhisperFeatureExtractor)를 사용합니다).

input_features_mask (`torch.Tensor`, shape `(batch_size, feature_sequence_length)`) : padding feature 인덱스에 attention을 수행하지 않도록 방지하는 마스크.

attention_mask (`torch.Tensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : 패딩 토큰 인덱스에 대한 attention을 수행하지 않도록 방지하는 마스크입니다. `[0, 1]`에서 선택된 마스크 값: - **마스크되지 않은** 토큰은 1, - **마스크된** 토큰은 0. [attention 마스크란?](../glossary#attention-mask)

position_ids (`torch.LongTensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : 각 입력 시퀀스의 토큰 위치 인덱스입니다. `[0, config.n_positions - 1]` 범위에서 선택됩니다. [위치 ID란 무엇인가요?](../glossary#position-ids)

past_key_values (`~cache_utils.Cache`, *선택*) : 순차적 디코딩을 가속화할 수 있는 사전 계산된 hidden-states(셀프 어텐션 블록과 크로스 어텐션 블록의 key 및 value)입니다. 일반적으로 `use_cache=True` 또는 `config.use_cache=True`일 때 모델이 디코딩의 이전 단계에서 반환한 `past_key_values`로 구성됩니다. 입력으로 [Cache](/docs/transformers/main/ko/internal/generation_utils#transformers.Cache) 인스턴스만 허용되며, [kv cache 가이드](https://huggingface.co/docs/transformers/en/kv_cache)를 참조하세요. `past_key_values`가 전달되지 않으면 기본적으로 [DynamicCache](/docs/transformers/main/ko/internal/generation_utils#transformers.DynamicCache)가 초기화됩니다. 모델은 입력으로 제공된 것과 동일한 캐시 형식을 출력합니다. `past_key_values`를 사용하는 경우, 이 모델에 과거 key value 상태가 제공되지 않은 `input_ids`(처리되지 않은 항목)만 `(batch_size, unprocessed_length)` 형식으로 입력해야 하며, `(batch_size, sequence_length)` 형식의 모든 `input_ids`를 입력하지 않습니다.

inputs_embeds (`torch.FloatTensor`, shape `(batch_size, sequence_length, hidden_size)`, *선택 사항*) : `input_ids`를 전달하는 대신 임베디드 표현을 직접 전달할 수 있습니다. 이는 모델의 내부 임베딩 조회 행렬보다 `input_ids` 인덱스를 관련 벡터로 변환하는 방식에 대한 더 세밀한 제어가 필요한 경우 유용합니다.

use_cache (`bool`, *선택 사항*) : `True`로 설정하면 `past_key_values` 키 값 상태가 반환되며, 디코딩 속도를 높이는 데 사용할 수 있습니다(`past_key_values` 참조).

**반환값:** `AudioFlamingo3ModelOutputWithPast` 또는 `tuple(torch.FloatTensor)`

`AudioFlamingo3ModelOutputWithPast` 또는 `torch.FloatTensor`의 튜플(`return_dict=False`가 전달되었거나 `config.return_dict=False`인 경우)로, 구성([AudioFlamingo3Config](/docs/transformers/main/ko/model_doc/audioflamingo3#transformers.AudioFlamingo3Config))과 입력에 따라 다양한 요소를 포함합니다.

[AudioFlamingo3Model](/docs/transformers/main/ko/model_doc/audioflamingo3#transformers.AudioFlamingo3Model)의 forward 메서드는 `__call__` 특수 메서드를 오버라이드합니다.

`Module` 인스턴스는 전처리 및 후처리 단계를 실행하는 것을 처리하지만, 이 함수는 해당 단계를 조용히 무시하므로, 순전파(forward pass) 레시피를 이 함수 내에서 정의해야 하더라도 이후에는 이 함수 대신 `Module` 인스턴스를 호출해야 합니다.

- **audio_hidden_states** (`torch.FloatTensor`, *선택 사항*) -- 투영된 오디오 hidden states입니다.

## AudioFlamingo3ForConditionalGeneration[[transformers.AudioFlamingo3ForConditionalGeneration]]

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

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

[소스](https://github.com/huggingface/transformers/blob/main/src/transformers/models/audioflamingo3/modeling_audioflamingo3.py#L566)

**매개변수:**

config ([AudioFlamingo3Config](/docs/transformers/main/ko/model_doc/audioflamingo3#transformers.AudioFlamingo3Config)) : 모델의 모든 매개변수를 포함하는 모델 구성 클래스입니다. 구성 파일로 초기화하는 것은 모델과 연관된 가중치를 로드하지 않으며, 구성 정보만 로드합니다. 모델 가중치를 로드하려면 [from_pretrained()](/docs/transformers/main/ko/main_classes/model#transformers.PreTrainedModel.from_pretrained) 메서드를 확인하세요.

Whisper 인코더의 fine-tuned 버전, 멀티모달 프로젝터, Qwen2 언어 모델로 구성된 AudioFlamingo3 모델입니다.

이 모델은 [PreTrainedModel](/docs/transformers/main/ko/main_classes/model#transformers.PreTrainedModel)에서 상속됩니다. 라이브러리가 모든 모델에 대해 구현하는 일반적 메서드(다운로드 또는 저장, 입력 임베딩 크기 조정, 헤드 프루닝 등)에 대해서는 상위 클래스 문서를 확인하세요.

이 모델은 또한 PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module)의 하위 클래스입니다. 일반적인 PyTorch Module처럼 사용하며, 일반적인 사용법과 동작에 관한 모든 사항은 PyTorch 문서를 참조하세요.

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

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, input_features: typing.Optional[torch.FloatTensor] = 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.FloatTensor] = 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'>)
```

[소스](https://github.com/huggingface/transformers/blob/main/src/transformers/models/audioflamingo3/modeling_audioflamingo3.py#L578)

**매개변수:**

input_ids (`torch.LongTensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : 어휘(input sequence tokens)의 인덱스입니다. 기본적으로 패딩은 무시됩니다. [AutoTokenizer](/docs/transformers/main/ko/model_doc/auto#transformers.AutoTokenizer)를 사용하여 인덱스를 얻을 수 있습니다. 자세한 내용은 [PreTrainedTokenizer.encode()](/docs/transformers/main/ko/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) 및 [PreTrainedTokenizer.__call__()](/docs/transformers/main/ko/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__)를 참조하세요. [입력 ID란 무엇인가요?](../glossary#input-ids)

input_features (`torch.FloatTensor`, shape `(batch_size, sequence_length, feature_dim)`, *선택 사항*) : 입력 오디오 특징에 해당하는 텐서입니다. 오디오 특징은 [WhisperFeatureExtractor](/docs/transformers/main/ko/model_doc/whisper#transformers.WhisperFeatureExtractor)를 사용하여 얻을 수 있습니다. 자세한 내용은 [WhisperFeatureExtractor.__call__()](/docs/transformers/main/ko/model_doc/whisper#transformers.WhisperFeatureExtractor.__call__)를 참조하세요 ([AudioFlamingo3Processor](/docs/transformers/main/ko/model_doc/audioflamingo3#transformers.AudioFlamingo3Processor)는 오디오 처리에 [WhisperFeatureExtractor](/docs/transformers/main/ko/model_doc/whisper#transformers.WhisperFeatureExtractor)를 사용합니다).

input_features_mask (`torch.Tensor`, shape `(batch_size, feature_sequence_length)`) : padding feature 인덱스에 attention을 수행하지 않도록 방지하는 마스크.

attention_mask (`torch.Tensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : 패딩 토큰 인덱스에 대한 attention을 수행하지 않도록 방지하는 마스크입니다. `[0, 1]`에서 선택된 마스크 값: - **마스크되지 않은** 토큰은 1, - **마스크된** 토큰은 0. [attention 마스크란?](../glossary#attention-mask)

position_ids (`torch.LongTensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : 각 입력 시퀀스의 토큰 위치 인덱스입니다. `[0, config.n_positions - 1]` 범위에서 선택됩니다. [위치 ID란 무엇인가요?](../glossary#position-ids)

past_key_values (`~cache_utils.Cache`, *선택*) : 순차적 디코딩을 가속화할 수 있는 사전 계산된 hidden-states(셀프 어텐션 블록과 크로스 어텐션 블록의 key 및 value)입니다. 일반적으로 `use_cache=True` 또는 `config.use_cache=True`일 때 모델이 디코딩의 이전 단계에서 반환한 `past_key_values`로 구성됩니다. 입력으로 [Cache](/docs/transformers/main/ko/internal/generation_utils#transformers.Cache) 인스턴스만 허용되며, [kv cache 가이드](https://huggingface.co/docs/transformers/en/kv_cache)를 참조하세요. `past_key_values`가 전달되지 않으면 기본적으로 [DynamicCache](/docs/transformers/main/ko/internal/generation_utils#transformers.DynamicCache)가 초기화됩니다. 모델은 입력으로 제공된 것과 동일한 캐시 형식을 출력합니다. `past_key_values`를 사용하는 경우, 이 모델에 과거 key value 상태가 제공되지 않은 `input_ids`(처리되지 않은 항목)만 `(batch_size, unprocessed_length)` 형식으로 입력해야 하며, `(batch_size, sequence_length)` 형식의 모든 `input_ids`를 입력하지 않습니다.

inputs_embeds (`torch.FloatTensor`, shape `(batch_size, sequence_length, hidden_size)`, *선택 사항*) : `input_ids`를 전달하는 대신 임베디드 표현을 직접 전달할 수 있습니다. 이는 모델의 내부 임베딩 조회 행렬보다 `input_ids` 인덱스를 관련 벡터로 변환하는 방식에 대한 더 세밀한 제어가 필요한 경우 유용합니다.

labels (`torch.LongTensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : masked language modeling loss를 계산하기 위한 라벨.

use_cache (`bool`, *선택 사항*) : `True`로 설정하면 `past_key_values` 키 값 상태가 반환되며, 디코딩 속도를 높이는 데 사용할 수 있습니다(`past_key_values` 참조).

logits_to_keep (`Union[int, torch.Tensor]`, *선택 사항*, 기본값 `0`) : `int`인 경우, 마지막 `logits_to_keep` 토큰에 대한 logits를 계산합니다. `0`인 경우, 모든 `input_ids`에 대한 logits를 계산합니다(특수한 경우). 생성에는 마지막 토큰의 logits만 필요하며, 해당 토큰에 대해서만 계산하면 메모리를 절약할 수 있습니다. 이는 긴 시퀀스나 큰 어휘 크기의 경우 상당한 이점을 제공합니다. `torch.Tensor`인 경우, 시퀀스 길이 차원에서 유지할 인덱스에 해당하는 1차원 텐서여야 합니다. 이는 packed tensor 형식(배치와 시퀀스 길이를 단일 차원으로 사용하는 경우)을 사용할 때 유용합니다.

**반환값:** `AudioFlamingo3CausalLMOutputWithPast` 또는 `tuple(torch.FloatTensor)`

`AudioFlamingo3CausalLMOutputWithPast` 또는 `torch.FloatTensor`의 튜플(`return_dict=False`가 전달되었거나 `config.return_dict=False`인 경우)로, 구성([AudioFlamingo3Config](/docs/transformers/main/ko/model_doc/audioflamingo3#transformers.AudioFlamingo3Config))과 입력에 따라 다양한 요소를 포함합니다.

[AudioFlamingo3ForConditionalGeneration](/docs/transformers/main/ko/model_doc/audioflamingo3#transformers.AudioFlamingo3ForConditionalGeneration)의 forward 메서드는 `__call__` 특수 메서드를 오버라이드합니다.

`Module` 인스턴스는 전처리 및 후처리 단계를 실행하는 것을 처리하지만, 이 함수는 해당 단계를 조용히 무시하므로, 순전파(forward pass) 레시피를 이 함수 내에서 정의해야 하더라도 이후에는 이 함수 대신 `Module` 인스턴스를 호출해야 합니다.

- **loss** (`torch.FloatTensor`, shape `(1,)`, *선택 사항*, `labels`가 제공될 때 반환됨) -- 다음 토큰 예측을 위한 언어 모델링 손실.
- **logits** (`torch.FloatTensor`, shape `(batch_size, sequence_length, config.vocab_size)`) -- 언어 모델링 헤드의 예측 점수.
- **past_key_values** (`Cache`, *선택*, `use_cache=True`가 전달되거나 `config.use_cache=True`인 경우 반환됨) -- [Cache](/docs/transformers/main/ko/internal/generation_utils#transformers.Cache) 인스턴스입니다.
- **hidden_states** (`tuple[torch.FloatTensor]`, *선택 사항*, `output_hidden_states=True`가 전달되었거나 `config.output_hidden_states=True`인 경우 반환됨) -- `torch.FloatTensor`의 튜플(모델에 임베딩 레이어가 있는 경우 임베딩 출력용 1개 + 각 레이어의 출력용 1개)로, 모양은 `(batch_size, sequence_length, hidden_size)`입니다.

  각 레이어의 출력에서 모델의 Hidden-states와 선택적 초기 임베딩 출력을 포함합니다.
- **attentions** (`tuple[torch.FloatTensor]`, *선택 사항*, `output_attentions=True`가 전달되었거나 `config.output_attentions=True`인 경우 반환됨) -- 각 레이어마다 하나씩 포함된 `torch.FloatTensor`의 튜플로, 모양은 `(batch_size, num_heads, sequence_length, sequence_length)`입니다.

  self-attention 헤드에서 가중 평균을 계산하는 데 사용되는 attention softmax 이후의 attention 가중치입니다.
- **audio_hidden_states** (`torch.FloatTensor`, *선택 사항*) -- 투영 이후 오디오 인코더의 히든 스테이트입니다.

예:

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

[소스](https://github.com/huggingface/transformers/blob/main/src/transformers/models/audioflamingo3/modeling_audioflamingo3.py#L575)