# Fun-ASR-Nano

## 개요

Fun-ASR-Nano는 Alibaba DAMO Academy의 FunAudioLLM 팀이 개발한 800M 파라미터의 엔드투엔드 음성 인식 모델입니다. 동급 모델보다 훨씬 작은 크기임에도 불구하고 중국어, 영어, 일본어 ASR 벤치마크에서 최첨단 성능을 달성합니다.

해당 모델은 [Fun-ASR: An Industrial-Grade Speech Recognition System](https://huggingface.co/papers/2509.12508)에서 제안되었습니다.

### 아키텍처

Fun-ASR-Nano는 세 가지 구성 요소로 이루어져 있습니다:

1. **오디오 인코더**(SenseVoiceEncoderSmall): 다중 헤드 셀프 어텐션과 Feedforward Sequential Memory Networks를 결합하여 음성 특징을 효율적으로 추출하는 70층 SANM(Self-Attention with FSMN Memory) 인코더입니다.

2. **Audio Adaptor**: 인코더 출력(512차원)을 LLM 차원(1024차원)으로 투영하는 2층 Transformer입니다.

3. **Language Model**(Qwen3-0.6B): 전사 텍스트를 자기회귀적으로 생성하는 28층 인과 언어 모델입니다.

### 주요 기능

- **중국어, 영어, 일본어**를 포함하며, 중국 방언 7개와 지역 억양 26개를 지원합니다
- **핫워드 커스터마이징**을 통한 도메인별 어휘 처리
- **네이티브 구두점** 출력 (별도의 구두점 모델 불필요)

## 사용

### 단일 추론

```python
from transformers import AutoModelForSpeechSeq2Seq, AutoProcessor

model_id = "FunAudioLLM/Fun-ASR-Nano-2512-hf"
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForSpeechSeq2Seq.from_pretrained(model_id, device_map="auto")

audio_url = "https://huggingface.co/FunAudioLLM/Fun-ASR-Nano-2512/resolve/main/example/en.mp3"
inputs = processor.apply_transcription_request(audio=audio_url).to(model.device)

generated_ids = model.generate(**inputs, max_new_tokens=200)
generated_ids = generated_ids[:, inputs.input_ids.shape[1]:]
print(processor.decode(generated_ids, skip_special_tokens=True)[0])
```

### 배치 추론

```python
from transformers import AutoModelForSpeechSeq2Seq, AutoProcessor

model_id = "FunAudioLLM/Fun-ASR-Nano-2512-hf"
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForSpeechSeq2Seq.from_pretrained(model_id, device_map="auto")

audio_urls = [
    "https://huggingface.co/FunAudioLLM/Fun-ASR-Nano-2512/resolve/main/example/zh.mp3",
    "https://huggingface.co/FunAudioLLM/Fun-ASR-Nano-2512/resolve/main/example/en.mp3",
]
languages = ["zh", "en"]
inputs = processor.apply_transcription_request(audio=audio_urls, language=languages).to(model.device)

generated_ids = model.generate(**inputs, max_new_tokens=200)
generated_ids = generated_ids[:, inputs.input_ids.shape[1]:]
print(processor.decode(generated_ids, skip_special_tokens=True))
```

### 사용자 지정 프롬프트 및 핫워드

`prompt`로 컨텍스트 정보를, `keywords`로 핫워드를 전달합니다. 체크포인트의 채팅 템플릿이 전체 전사 지시를 구성합니다. `language`는 중국어, 영어, 일본어의 정식 명칭 또는 ISO 코드를 지원합니다.

```python
from transformers import AutoModelForSpeechSeq2Seq, AutoProcessor

model_id = "FunAudioLLM/Fun-ASR-Nano-2512-hf"
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForSpeechSeq2Seq.from_pretrained(model_id, device_map="auto")

audio_url = "https://huggingface.co/FunAudioLLM/Fun-ASR-Nano-2512/resolve/main/example/en.mp3"
inputs = processor.apply_transcription_request(
    audio=audio_url,
    prompt="A tribal story involving a chieftain and a boy.",
    keywords=["tribal chieftain", "fifty pieces of gold"],
).to(model.device)

generated_ids = model.generate(**inputs, max_new_tokens=200)
generated_ids = generated_ids[:, inputs.input_ids.shape[1]:]
print(processor.decode(generated_ids, skip_special_tokens=True)[0])
```

### 학습

```python
from transformers import AutoModelForSpeechSeq2Seq, AutoProcessor

model_id = "FunAudioLLM/Fun-ASR-Nano-2512-hf"
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForSpeechSeq2Seq.from_pretrained(model_id, device_map="auto")
model.train()

audio_url = "https://huggingface.co/FunAudioLLM/Fun-ASR-Nano-2512/resolve/main/example/en.mp3"
conversation = [
    {
        "role": "user",
        "content": [
            {"type": "audio", "path": audio_url},
        ],
    },
    {
        "role": "assistant",
        "content": [
            {
                "type": "text",
                "text": "The tribal chieftain called for the boy, and presented him with fifty pieces of gold.",
            }
        ],
    },
]
inputs = processor.apply_chat_template(
    conversation,
    tokenize=True,
    return_dict=True,
    processor_kwargs={"output_labels": True},
).to(model.device)

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

### `torch.compile`을 사용한 추론

```python
import torch
from transformers import AutoModelForSpeechSeq2Seq, AutoProcessor, CompileConfig

model_id = "FunAudioLLM/Fun-ASR-Nano-2512-hf"
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForSpeechSeq2Seq.from_pretrained(model_id, device_map="auto")

audio_url = "https://huggingface.co/FunAudioLLM/Fun-ASR-Nano-2512/resolve/main/example/en.mp3"
inputs = processor.apply_transcription_request(audio=audio_url).to(model.device)

with torch.inference_mode():
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=200,
        compile_config=CompileConfig(),
    )
generated_ids = generated_ids[:, inputs.input_ids.shape[1]:]
print(processor.decode(generated_ids, skip_special_tokens=True)[0])
```

## FunAsrNanoConfig[[transformers.FunAsrNanoConfig]]

#### transformers.FunAsrNanoConfig[[transformers.FunAsrNanoConfig]]

```python
transformers.FunAsrNanoConfig(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, adaptor_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, audio_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, text_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, audio_token_id: int = 151646, initializer_range: float = 0.02, tie_word_embeddings: bool = True)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/fun_asr_nano/configuration_fun_asr_nano.py#L77)

**매개변수:**

adaptor_config (`dict` 또는 `FunAsrNanoAdaptorConfig`, *선택 사항*) : 양방향 오디오 어댑터에 대한 설정입니다.

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

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

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

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

tie_word_embeddings (`bool`, *선택 사항*, 기본값 `True`) : 모델의 `tied_weights_keys` 매핑에 따라 가중치 임베딩을 묶을지 여부.

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

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

## FunAsrNanoEncoderConfig[[transformers.FunAsrNanoEncoderConfig]]

#### transformers.FunAsrNanoEncoderConfig[[transformers.FunAsrNanoEncoderConfig]]

```python
transformers.FunAsrNanoEncoderConfig(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 = 80, hidden_size: int = 512, num_attention_heads: int = 4, intermediate_size: int = 2048, num_hidden_layers: int = 70, hidden_dropout: float = 0.1, attention_dropout: float = 0.1, layer_norm_eps: float = 1e-05, hidden_act: str = 'relu', max_position_embeddings: int = 2049, num_stacked_frames: int = 7, num_timestamp_prediction_layers: int = 20, fsmn_kernel_size: int = 11)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/fun_asr_nano/configuration_fun_asr_nano.py#L25)

**매개변수:**

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

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

num_attention_heads (`int`, *선택 사항*, 기본값 `4`) : Transformer 디코더의 각 어텐션 레이어에 사용할 어텐션 헤드 수입니다.

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

num_hidden_layers (`int`, *선택 사항*, 기본값 70) : 전사 레이어와 그 후의 타임스탬프 예측 레이어를 모두 포함한 인코더 레이어의 총 개수입니다.

hidden_dropout (`float`, *선택 사항*, 기본값 `0.1`) : 임베딩, 인코더, 풀러의 모든 완전 연결 계층에 적용되는 드롭아웃 확률입니다.

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

layer_norm_eps (`float`, *선택 사항*, 기본값 `1e-05`) : layer normalization 레이어에서 사용되는 epsilon 값입니다.

hidden_act (`str`, *선택 사항*, 기본값 `relu`) : 디코더의 비선형 활성화 함수(함수 또는 문자열). 예를 들어, `"gelu"`, `"relu"`, `"silu"` 등.

max_position_embeddings (`int`, *선택 사항*, 기본값 `2049`) : 이 모델이 사용될 수 있는 최대 시퀀스 길이입니다.

num_stacked_frames (`int`, *선택 사항*, 기본값 7) : 저프레임레이트 특징 추출에 의해 스택되는 연속적인 mel 프레임의 수입니다.

num_timestamp_prediction_layers (`int`, *선택 사항*, 기본값 20) : 타임스탬프 예측에 전념하는 인코더 레이어(마지막 레이어)의 수입니다. 전사 출력은 `num_hidden_layers - num_timestamp_prediction_layers - 1` 레이어 이후에 가져옵니다.

fsmn_kernel_size (`int`, *선택 사항*, 기본값 11) : 피드포워드 시퀀셜 메모리 네트워크(FSMN) 컨볼루션의 커널 크기.

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

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

## FunAsrNanoAdaptorConfig[[transformers.FunAsrNanoAdaptorConfig]]

#### transformers.FunAsrNanoAdaptorConfig[[transformers.FunAsrNanoAdaptorConfig]]

```python
transformers.FunAsrNanoAdaptorConfig(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, hidden_size: int = 1024, num_attention_heads: int = 8, intermediate_size: int = 256, num_hidden_layers: int = 2, hidden_dropout: float = 0.0, attention_dropout: float = 0.0, layer_norm_eps: float = 1e-05, hidden_act: str = 'relu', projector_hidden_act: str = 'relu', projector_hidden_size: int = 2048)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/fun_asr_nano/configuration_fun_asr_nano.py#L62)

**매개변수:**

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

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

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

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

hidden_dropout (`float`, *선택 사항*, 기본값 `0.0`) : 임베딩, 인코더, 풀러의 모든 완전 연결 계층에 적용되는 드롭아웃 확률입니다.

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

layer_norm_eps (`float`, *선택 사항*, 기본값 `1e-05`) : layer normalization 레이어에서 사용되는 epsilon 값입니다.

hidden_act (`str`, *선택 사항*, 기본값 `relu`) : 디코더의 비선형 활성화 함수(함수 또는 문자열). 예를 들어, `"gelu"`, `"relu"`, `"silu"` 등.

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

projector_hidden_size (`int`, *선택 사항*, 기본값 `2048`) : 텍스트 및 비전 투영 레이어의 차원.

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

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

## FunAsrNanoFeatureExtractor[[transformers.FunAsrNanoFeatureExtractor]]

#### transformers.FunAsrNanoFeatureExtractor[[transformers.FunAsrNanoFeatureExtractor]]

```python
transformers.FunAsrNanoFeatureExtractor(feature_size: int = 80, sampling_rate: int = 16000, frame_length: int = 25, frame_shift: int = 10, num_frames_lfr: int = 7, stride_lfr: int = 6, window: str = 'hamming', padding_value: float = 0.0, return_attention_mask: bool = True, **kwargs)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/fun_asr_nano/feature_extraction_fun_asr_nano.py#L33)

**매개변수:**

feature_size (`int`, *선택 사항*, 기본값 80) : 멜 주파수 빈의 수.

sampling_rate (`int`, *선택 사항*, 기본값 16000) : 오디오의 샘플링 레이트입니다.

frame_length (`int`, *선택 사항*, 기본값 25) : STFT의 프레임 길이(밀리초).

frame_shift (`int`, *선택 사항*, 기본값 10) : STFT의 프레임 시프트(홉 길이)를 밀리초 단위로 지정합니다.

num_frames_lfr (`int`, *선택 사항*, 기본값 7) : 스택할 연속 프레임 수(LFR 스택 팩터).

stride_lfr (`int`, *선택 사항*, 기본값 6) : LFR의 서브샘플링 스트라이드(스택된 프레임 중 `stride_lfr`번째마다 가져옴).

window (`str`, *선택 사항*, 기본값 `"hamming"`) : STFT에 사용할 윈도우 함수.

padding_value (`float`, *선택 사항*, 기본값 0.0) : 짧은 시퀀스를 패딩하는 데 사용되는 값.

return_attention_mask (`bool`, *선택 사항*, 기본값 `True`) : attention mask를 반환할지 여부.

Fun-ASR-Nano feature extractor를 생성합니다.

이 feature extractor는 대부분의 주요 메서드를 포함하는 [SequenceFeatureExtractor](/docs/transformers/v5.23.0/ko/main_classes/feature_extractor#transformers.SequenceFeatureExtractor)를 상속합니다. 해당 메서드에 대한 자세한 내용은 이 상위 클래스를 참고하세요.

`torchaudio.compliance.kaldi.fbank`를 통해 Kaldi 호환 mel-filterbank 특징을 추출한 후(원본 FunASR 프론트엔드와 일치), `num_frames_lfr`개의 연속 프레임을 스택하고 스트라이드 `stride_lfr`로 서브샘플링하여 Low Frame Rate(LFR) 처리를 적용합니다.

예:

```python
>>> import numpy as np
>>> from transformers import FunAsrNanoFeatureExtractor

>>> feature_extractor = FunAsrNanoFeatureExtractor()
>>> audio = np.random.randn(16000)  # 1 second of audio at 16kHz
>>> features = feature_extractor(audio, sampling_rate=16000, return_tensors="pt")
>>> features.input_features.shape  # (1, num_frames_after_lfr, 560)
```

#### __call__[[transformers.FunAsrNanoFeatureExtractor.__call__]]

```python
__call__(raw_speech: typing.Union[numpy.ndarray, ForwardRef('torch.Tensor'), collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence['torch.Tensor']], sampling_rate: int | None = None, return_tensors: str | transformers.utils.generic.TensorType | None = 'pt', padding: bool | str = True, max_length: int | None = None, truncation: bool = False, pad_to_multiple_of: int | None = None, return_attention_mask: bool | None = None, **kwargs)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/fun_asr_nano/feature_extraction_fun_asr_nano.py#L146)

**매개변수:**

raw_speech (`np.ndarray`, `list[float]`, `list[np.ndarray]`, `list[list[float]]`) : 특징 추출할 모노 웨이브폼의 시퀀스 또는 배치.

sampling_rate (`int`, *선택 사항*) : 입력 오디오의 샘플링 레이트입니다. `self.sampling_rate`(16000 Hz)와 일치해야 합니다.

return_tensors (`str` 또는 [TensorType](/docs/transformers/v5.23.0/ko/internal/file_utils#transformers.TensorType), *optional*) : 설정된 경우, 해당 프레임워크(`"pt"`, `"np"`, ...)의 텐서를 반환합니다.

padding (`bool` 또는 `str`, *선택 사항*, 기본값 `True`) : [pad()](/docs/transformers/v5.23.0/ko/main_classes/feature_extractor#transformers.SequenceFeatureExtractor.pad)에 전달되는 패딩 전략입니다.

max_length (`int`, *선택 사항*) : 패딩/잘라내기용 최대 LFR 시퀀스 길이.

truncation (`bool`, *선택 사항*, 기본값 `False`) : `max_length`보다 긴 시퀀스를 잘라낼지 여부.

pad_to_multiple_of (`int`, *선택 사항*) : 설정된 경우, LFR 시퀀스 길이를 이 값의 배수로 패딩합니다.

return_attention_mask (`bool`, *선택 사항*) : `input_features_mask`를 반환할지 여부입니다. 기본값은 `self.return_attention_mask`입니다.

**반환값:**

`input_features`의 shape가 `(batch, max_lfr_frames, feature_size * num_frames_lfr)`인 [BatchFeature](/docs/transformers/v5.23.0/ko/main_classes/feature_extractor#transformers.BatchFeature)와 프레임 수준의 `input_features_mask`

하나 이상의 원시 오디오 웨이브폼에서 Kaldi mel-filterbank + LFR 특징을 추출합니다.

## FunAsrNanoProcessor[[transformers.FunAsrNanoProcessor]]

#### transformers.FunAsrNanoProcessor[[transformers.FunAsrNanoProcessor]]

```python
transformers.FunAsrNanoProcessor(feature_extractor, tokenizer, chat_template = None, audio_token = '<|object_ref_start|>')
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/fun_asr_nano/processing_fun_asr_nano.py#L47)

**매개변수:**

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

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

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

audio_token (`str`, *선택 사항*, 기본값 `"<|object_ref_start|>"`) : 텍스트에서 오디오를 위한 플레이스홀더로 사용되는 토큰입니다.

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

[FunAsrNanoProcessor](/docs/transformers/v5.23.0/ko/model_doc/fun_asr_nano#transformers.FunAsrNanoProcessor)는 [FunAsrNanoFeatureExtractor](/docs/transformers/v5.23.0/ko/model_doc/fun_asr_nano#transformers.FunAsrNanoFeatureExtractor)와 [Qwen2Tokenizer](/docs/transformers/v5.23.0/ko/model_doc/qwen2#transformers.Qwen2Tokenizer)의 모든 기능을 제공합니다. 자세한 내용은 [~FunAsrNanoFeatureExtractor](/docs/transformers/v5.23.0/ko/model_doc/fun_asr_nano#transformers.FunAsrNanoFeatureExtractor)와 [~Qwen2Tokenizer](/docs/transformers/v5.23.0/ko/model_doc/qwen2#transformers.Qwen2Tokenizer)를 참고하세요.

#### __call__[[transformers.FunAsrNanoProcessor.__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'>)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/fun_asr_nano/processing_fun_asr_nano.py#L69)

**매개변수:**

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_mm_token_type_ids (`bool`, *kwargs*) : 멀티모달 플레이스홀더 토큰의 위치를 나타내는 멀티모달 토큰 타입 ID를 반환할지 여부.

return_text_replacement_offsets (`bool`, *kwargs*) : 각 멀티모달 플레이스홀더 및 그 대체 문자열의 문자 오프셋을 반환할지 여부.

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

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

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

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

#### apply_transcription_request[[transformers.FunAsrNanoProcessor.apply_transcription_request]]

```python
apply_transcription_request(audio: typing.Union[numpy.ndarray, ForwardRef('torch.Tensor'), collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence['torch.Tensor'], list[typing.Union[numpy.ndarray, ForwardRef('torch.Tensor'), collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence['torch.Tensor']]]], language: str | list[str] | None = None, prompt: str | list[str] | None = None, keywords: str | list[str] | list[list[str]] | None = None, tokenize: bool = True, **kwargs: *<class 'transformers.processing_utils.ProcessingKwargs'>)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/fun_asr_nano/processing_fun_asr_nano.py#L134)

**매개변수:**

audio (`AudioInput` 또는 `list[AudioInput]`) : 전사할 오디오입니다. URL, 로컬 경로, NumPy 배열, PyTorch 텐서 또는 이들의 목록일 수 있습니다.

language (`str` 또는 `list[str]`, *선택 사항*) : 대상 언어. 중국어, 영어, 일본어의 전체 영어 이름, ISO 코드(`"zh"`, `"en"`, `"ja"`), 또는 체크포인트의 중국어 언어 이름(`"中文"`, `"英文"`, `"日文"`)을 허용합니다. 단일 값은 배치 전체에 브로드캐스트됩니다.

prompt (`str` 또는 `list[str]`, *선택 사항*) : 전사(transcription) 품질을 향상시킬 수 있는 문맥 정보. 리스트는 오디오 배치 크기와 일치해야 합니다.

keywords (`str`, `list[str]`, 또는 `list[list[str]]`, *선택 사항*) : 인식에 편향을 주기 위한 핫워드입니다. 문자열 또는 평탄한 리스트는 배치 전체에서 공유되며, 중첩 리스트는 각 오디오 샘플에 대해 별도의 핫워드를 제공합니다.

tokenize (`bool`, *선택 사항*, 기본값 `True`) : 프롬프트를 토큰화하고 오디오를 처리할지 여부입니다. `False`인 경우 오디오가 로드되지 않고, 오디오 플레이스홀더가 확장되지 않은 문자열로 프롬프트가 반환됩니다. 이 프롬프트를 오디오와 함께 프로세서에 전달하면 `processor(text=prompts, audio=audio)`, `tokenize=True`일 때와 동일한 출력을 얻습니다.

- ****kwargs** : [apply_chat_template()](/docs/transformers/v5.23.0/ko/main_classes/processors#transformers.ProcessorMixin.apply_chat_template) 및 기본 프로세서 호출로 전달되는 추가 키워드 인자(예: `text_kwargs`, `audio_kwargs`, ...).

**반환값:** [BatchFeature](/docs/transformers/v5.23.0/ko/main_classes/feature_extractor#transformers.BatchFeature) 또는 `list[str]`

`tokenize=False`인 경우 오디오당 프롬프트가 하나씩 생성되며, 그렇지 않으면 [FunAsrNanoForConditionalGeneration.generate()](/docs/transformers/v5.23.0/ko/main_classes/text_generation#transformers.GenerationMixin.generate)에 바로 전달할 수 있는 형태로 프로세서가 출력합니다.

checkpoint의 구조화된 전사 chat 템플릿을 사용하여 ASR에 사용할 입력을 준비합니다.

## FunAsrNanoEncoder[[transformers.FunAsrNanoEncoder]]

#### transformers.FunAsrNanoEncoder[[transformers.FunAsrNanoEncoder]]

```python
transformers.FunAsrNanoEncoder(config: FunAsrNanoEncoderConfig)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/fun_asr_nano/modeling_fun_asr_nano.py#L279)

**매개변수:**

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

Fun-ASR-Nano 오디오 인코더(SenseVoice SAN-M 아키텍처)로, 상단에 헤드가 없는 상태입니다.

이 모델은 [PreTrainedModel](/docs/transformers/v5.23.0/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.FunAsrNanoEncoder.forward]]

```python
forward(input_features: Tensor, input_features_mask: Tensor, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/fun_asr_nano/modeling_fun_asr_nano.py#L313)

**매개변수:**

input_features (`torch.Tensor`, shape `(batch_size, sequence_length, feature_dim)`) : 입력 오디오 특징에 해당하는 텐서입니다. 오디오 특징은 [FunAsrNanoFeatureExtractor](/docs/transformers/v5.23.0/ko/model_doc/fun_asr_nano#transformers.FunAsrNanoFeatureExtractor)를 사용하여 얻을 수 있습니다. 자세한 내용은 [FunAsrNanoFeatureExtractor.__call__()](/docs/transformers/v5.23.0/ko/model_doc/fun_asr_nano#transformers.FunAsrNanoFeatureExtractor.__call__)를 참조하세요 ([FunAsrNanoProcessor](/docs/transformers/v5.23.0/ko/model_doc/fun_asr_nano#transformers.FunAsrNanoProcessor)는 오디오 처리에 [FunAsrNanoFeatureExtractor](/docs/transformers/v5.23.0/ko/model_doc/fun_asr_nano#transformers.FunAsrNanoFeatureExtractor)를 사용합니다).

input_features_mask (`torch.LongTensor`, shape `(batch_size, padded_feature_length)`) : 유효한 mel 프레임은 1, 패딩은 0.

**반환값:** [BaseModelOutput](/docs/transformers/v5.23.0/ko/main_classes/output#transformers.modeling_outputs.BaseModelOutput) 또는 `tuple(torch.Tensor)`

구성([FunAsrNanoConfig](/docs/transformers/v5.23.0/ko/model_doc/fun_asr_nano#transformers.FunAsrNanoConfig))과 입력에 따라 다양한 요소를 포함하는 [BaseModelOutput](/docs/transformers/v5.23.0/ko/main_classes/output#transformers.modeling_outputs.BaseModelOutput) 또는 `torch.Tensor`의 튜플(`return_dict=False`가 전달되거나 `config.return_dict=False`인 경우).

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

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

- **last_hidden_state** (`torch.Tensor`, shape `(batch_size, sequence_length, hidden_size)`) -- 모델의 마지막 레이어 출력에서 생성된 hidden-state 시퀀스입니다.
- **hidden_states** (`tuple(torch.Tensor)`, *선택 사항*, `output_hidden_states=True`가 전달되었거나 `config.output_hidden_states=True`인 경우 반환됨) -- `torch.Tensor`의 튜플(모델에 임베딩 레이어가 있는 경우 임베딩 출력 1개 + 각 레이어의 출력 1개)로, 형태는 `(batch_size, sequence_length, hidden_size)`입니다.

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

  self-attention 헤드에서 가중 평균을 계산하는 데 사용되는 attention softmax 이후의 attention 가중치입니다.

## FunAsrNanoModel[[transformers.FunAsrNanoModel]]

#### transformers.FunAsrNanoModel[[transformers.FunAsrNanoModel]]

```python
transformers.FunAsrNanoModel(config: FunAsrNanoConfig)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/fun_asr_nano/modeling_fun_asr_nano.py#L393)

**매개변수:**

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

언어 모델링 헤드가 없는 Fun-ASR-Nano 모델(SenseVoice SAN-M 오디오 인코더, Transformer 어댑터, Qwen3 언어 모델).

이 모델은 [PreTrainedModel](/docs/transformers/v5.23.0/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.FunAsrNanoModel.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'>)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/fun_asr_nano/modeling_fun_asr_nano.py#L468)

**매개변수:**

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

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

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/v5.23.0/ko/internal/generation_utils#transformers.Cache) 인스턴스만 허용되며, [kv cache 가이드](https://huggingface.co/docs/transformers/en/kv_cache)를 참조하세요. `past_key_values`가 전달되지 않으면 기본적으로 [DynamicCache](/docs/transformers/v5.23.0/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.Tensor`, shape `(batch_size, sequence_length, hidden_size)`, *선택 사항*) : `input_ids`를 전달하는 대신 임베디드 표현을 직접 전달할 수 있습니다. 이는 모델의 내부 임베딩 조회 행렬보다 `input_ids` 인덱스를 관련 벡터로 변환하는 방식에 대해 더 많은 제어가 필요한 경우 유용합니다.

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

**반환값:** `FunAsrNanoModelOutputWithPast` 또는 `tuple(torch.Tensor)`

`FunAsrNanoModelOutputWithPast` 또는 `torch.Tensor`의 튜플(`return_dict=False`이 전달되거나 `config.return_dict=False`인 경우)로, 구성([FunAsrNanoConfig](/docs/transformers/v5.23.0/ko/model_doc/fun_asr_nano#transformers.FunAsrNanoConfig)) 및 입력에 따라 다양한 요소를 포함합니다.

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

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

- **audio_hidden_states** (`torch.Tensor`, *선택 사항*) -- 투영된 오디오 히든 상태입니다.

## FunAsrNanoForConditionalGeneration[[transformers.FunAsrNanoForConditionalGeneration]]

#### transformers.FunAsrNanoForConditionalGeneration[[transformers.FunAsrNanoForConditionalGeneration]]

```python
transformers.FunAsrNanoForConditionalGeneration(config: FunAsrNanoConfig)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/fun_asr_nano/modeling_fun_asr_nano.py#L551)

**매개변수:**

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

음성 인식용 Fun-ASR-Nano 모델: SenseVoice SAN-M 오디오 인코더, Transformer 어댑터, 언어 모델링 헤드가 있는 Qwen3 언어 모델로 구성됩니다.

이 모델은 [PreTrainedModel](/docs/transformers/v5.23.0/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.FunAsrNanoForConditionalGeneration.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'>)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/fun_asr_nano/modeling_fun_asr_nano.py#L564)

**매개변수:**

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

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

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/v5.23.0/ko/internal/generation_utils#transformers.Cache) 인스턴스만 허용되며, [kv cache 가이드](https://huggingface.co/docs/transformers/en/kv_cache)를 참조하세요. `past_key_values`가 전달되지 않으면 기본적으로 [DynamicCache](/docs/transformers/v5.23.0/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.Tensor`, 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 형식(배치와 시퀀스 길이를 단일 차원으로 사용하는 경우)을 사용할 때 유용합니다.

**반환값:** `FunAsrNanoCausalLMOutputWithPast` 또는 `tuple(torch.Tensor)`

`FunAsrNanoCausalLMOutputWithPast` 또는 `torch.Tensor`의 튜플(`return_dict=False`가 전달되거나 `config.return_dict=False`인 경우)로, [FunAsrNanoConfig](/docs/transformers/v5.23.0/ko/model_doc/fun_asr_nano#transformers.FunAsrNanoConfig) 및 입력에 따라 다양한 요소를 포함합니다.

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

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

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

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

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

예:

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

>>> model_id = "FunAudioLLM/Fun-ASR-Nano-2512-hf"
>>> processor = AutoProcessor.from_pretrained(model_id)
>>> model = FunAsrNanoForConditionalGeneration.from_pretrained(model_id, device_map="auto")
```

