# Fun-ASR-Nano

## Ikhtisar

Fun-ASR-Nano adalah model pengenalan ucapan end-to-end dengan 800 juta parameter yang dikembangkan oleh tim FunAudioLLM dari Alibaba DAMO Academy. Model ini mencapai kinerja state-of-the-art pada benchmark ASR untuk bahasa Mandarin, Inggris, dan Jepang, sekaligus jauh lebih kecil dibandingkan model-model sejenis.

Model ini diusulkan dalam [Fun-ASR: An Industrial-Grade Speech Recognition System](https://huggingface.co/papers/2509.12508).

### Arsitektur

Fun-ASR-Nano terdiri dari tiga komponen:

1. **Audio Encoder** (SenseVoiceEncoderSmall): Encoder 70-lapisan SANM (Self-Attention with FSMN Memory) yang menggabungkan multi-head self-attention dengan Feedforward Sequential Memory Networks untuk ekstraksi fitur ucapan yang efisien.

2. **Audio Adaptor**: Transformer 2-lapisan yang memproyeksikan keluaran encoder (dim-512) ke dimensi LLM (dim-1024).

3. **Language Model** (Qwen3-0.6B): Model bahasa kausal 28 lapis yang menghasilkan teks transkripsi secara autoregresif.

### Fitur Utama

- **Bahasa Mandarin, Inggris, dan Jepang**, termasuk 7 dialek Mandarin dan 26 aksen regional
- **Penyesuaian hotword** untuk kosakata spesifik domain
- Output **Native punctuation** (tidak memerlukan model tanda baca terpisah)

## Penggunaan

### Inferensi tunggal

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

### Inferensi batch

```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 dan hotword kustom

Lewatkan informasi kontekstual dengan `prompt` dan hotwords dengan `keywords`; template chat checkpoint membangun instruksi transkripsi lengkap. `language` menerima Chinese, English, dan Japanese sebagai nama lengkap atau kode 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])
```

### Pelatihan

Lewatkan transkrip target ke `apply_transcription_request` dengan `transcription`, dan `labels` yang dikembalikan digunakan untuk menghitung loss.

```python
from datasets import Audio, load_dataset
from transformers import AutoModelForSpeechSeq2Seq, AutoProcessor

model_id = "FunAudioLLM/Fun-ASR-Nano-2512-hf"
NUM_SAMPLES = 2

processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForSpeechSeq2Seq.from_pretrained(model_id, device_map="auto")
model.train()

ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
ds = ds.cast_column("audio", Audio(sampling_rate=processor.feature_extractor.sampling_rate))
speech_samples = [el["array"] for el in ds["audio"][:NUM_SAMPLES]]
text_samples = ds["text"][:NUM_SAMPLES]

inputs = processor.apply_transcription_request(speech_samples, language="en", transcription=text_samples)
inputs.to(model.device, dtype=model.dtype)

loss = model(**inputs).loss
print("Loss:", loss.item())
loss.backward()
```

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

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/fun_asr_nano/configuration_fun_asr_nano.py#L77)

**Parameter:**

adaptor_config (`dict` atau `FunAsrNanoAdaptorConfig`, *opsional*) : Konfigurasi untuk adaptor audio bidireksional.

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

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

tie_word_embeddings (`bool`, *opsional*, defaultnya `True`) : Apakah mengikat embedding bobot sesuai dengan pemetaan `tied_weights_keys` model.

Ini adalah kelas konfigurasi untuk menyimpan konfigurasi dari FunAsrNanoModel. Kelas ini digunakan untuk menginstansiasi model Fun Asr Nano sesuai dengan argumen yang ditentukan, yang mendefinisikan arsitektur model. Menginstansiasi konfigurasi dengan nilai bawaan akan menghasilkan konfigurasi yang serupa dengan konfigurasi dari [FunAudioLLM/Fun-ASR-Nano-2512-hf](https://huggingface.co/FunAudioLLM/Fun-ASR-Nano-2512-hf)

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

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

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/fun_asr_nano/configuration_fun_asr_nano.py#L25)

**Parameter:**

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

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

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

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

num_hidden_layers (`int`, *opsional*, default 70) : Jumlah total lapisan encoder, termasuk lapisan transkripsi dan lapisan prediksi timestamp berikutnya.

hidden_dropout (`float`, *opsional*, defaultnya `0.1`) : Probabilitas dropout untuk semua lapisan fully connected di embeddings, encoder, dan pooler.

attention_dropout (`float`, *opsional*, default `0.1`) : Rasio dropout untuk probabilitas perhatian.

layer_norm_eps (`float`, *opsional*, defaultnya `1e-05`) : Epsilon yang digunakan oleh lapisan normalisasi lapisan.

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

max_position_embeddings (`int`, *opsional*, defaultnya `2049`) : Panjang urutan maksimum yang mungkin digunakan oleh model ini.

num_stacked_frames (`int`, *opsional*, default 7) : Jumlah frame mel berurutan yang ditumpuk oleh ekstraksi fitur laju frame rendah.

num_timestamp_prediction_layers (`int`, *opsional*, default 20) : Jumlah lapisan encoder (bagian akhir) yang dialokasikan untuk prediksi timestamp. Output transkripsi diambil setelah lapisan `num_hidden_layers - num_timestamp_prediction_layers - 1`.

fsmn_kernel_size (`int`, *opsional*, default 11) : Ukuran kernel untuk konvolusi pada jaringan memori sekuensial feedforward (FSMN).

Ini adalah kelas konfigurasi untuk menyimpan konfigurasi dari FunAsrNanoModel. Kelas ini digunakan untuk menginstansiasi model Fun Asr Nano sesuai dengan argumen yang ditentukan, yang mendefinisikan arsitektur model. Menginstansiasi konfigurasi dengan nilai bawaan akan menghasilkan konfigurasi yang serupa dengan konfigurasi dari [FunAudioLLM/Fun-ASR-Nano-2512-hf](https://huggingface.co/FunAudioLLM/Fun-ASR-Nano-2512-hf)

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

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

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/fun_asr_nano/configuration_fun_asr_nano.py#L62)

**Parameter:**

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

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

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

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

hidden_dropout (`float`, *opsional*, defaultnya `0.0`) : Probabilitas dropout untuk semua lapisan fully connected di embeddings, encoder, dan pooler.

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

layer_norm_eps (`float`, *opsional*, defaultnya `1e-05`) : Epsilon yang digunakan oleh lapisan normalisasi lapisan.

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

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

projector_hidden_size (`int`, *opsional*, defaultnya `2048`) : Dimensi dari lapisan proyeksi teks dan visi.

Ini adalah kelas konfigurasi untuk menyimpan konfigurasi dari FunAsrNanoModel. Kelas ini digunakan untuk menginstansiasi model Fun Asr Nano sesuai dengan argumen yang ditentukan, yang mendefinisikan arsitektur model. Menginstansiasi konfigurasi dengan nilai bawaan akan menghasilkan konfigurasi yang serupa dengan konfigurasi dari [FunAudioLLM/Fun-ASR-Nano-2512-hf](https://huggingface.co/FunAudioLLM/Fun-ASR-Nano-2512-hf)

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

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

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/fun_asr_nano/feature_extraction_fun_asr_nano.py#L33)

**Parameter:**

feature_size (`int`, *opsional*, defaultnya 80) : Jumlah bin frekuensi mel.

sampling_rate (`int`, *opsional*, default 16000) : Laju sampling audio.

frame_length (`int`, *opsional*, default 25) : Panjang frame dalam milidetik untuk STFT.

frame_shift (`int`, *opsional*, default 10) : Pergeseran frame (panjang hop) dalam milidetik untuk STFT.

num_frames_lfr (`int`, *opsional*, default 7) : Jumlah frame berurutan untuk ditumpuk (faktor penumpukan LFR).

stride_lfr (`int`, *opsional*, default 6) : Stride subsampling untuk LFR (ambil setiap frame bertumpuk ke-`stride_lfr`).

window (`str`, *opsional*, defaultnya `"hamming"`) : Fungsi jendela untuk STFT.

padding_value (`float`, *opsional*, default 0.0) : Nilai yang digunakan untuk mengisi (padding) urutan yang lebih pendek.

return_attention_mask (`bool`, *opsional*, defaultnya `True`) : Apakah akan mengembalikan attention mask.

Membangun ekstraktor fitur Fun-ASR-Nano.

Feature extractor ini mewarisi dari [SequenceFeatureExtractor](/docs/transformers/main/id/main_classes/feature_extractor#transformers.SequenceFeatureExtractor) yang berisi sebagian besar metode utama. Pengguna harus merujuk ke superclass ini untuk informasi lebih lanjut mengenai metode-metode tersebut.

Itu mengekstrak fitur mel-filterbank yang kompatibel dengan Kaldi (melalui `torchaudio.compliance.kaldi.fbank`, yang sesuai dengan front-end FunASR asli) dan kemudian menerapkan pemrosesan Low Frame Rate (LFR) dengan menumpuk `num_frames_lfr` frame berurutan dan melakukan subsampling dengan stride `stride_lfr`.

Contoh:

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

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/fun_asr_nano/feature_extraction_fun_asr_nano.py#L146)

**Parameter:**

raw_speech (`np.ndarray`, `list[float]`, `list[np.ndarray]`, `list[list[float]]`) : Urutan atau batch dari waveform mono yang akan difeaturisasi.

sampling_rate (`int`, *opsional*) : Laju sampling audio input. Harus cocok dengan `self.sampling_rate` (16000 Hz).

return_tensors (`str` atau [TensorType](/docs/transformers/main/id/internal/file_utils#transformers.TensorType), *opsional*) : Jika diatur, mengembalikan tensor dari framework yang diberikan (`"pt"`, `"np"`, ...).

padding (`bool` atau `str`, *opsional*, defaultnya `True`) : Strategi padding yang diteruskan ke [pad()](/docs/transformers/main/id/main_classes/feature_extractor#transformers.SequenceFeatureExtractor.pad).

max_length (`int`, *opsional*) : Panjang maksimum urutan LFR untuk padding/truncation.

truncation (`bool`, *opsional*, defaultnya `False`) : Apakah akan memotong (truncate) urutan yang lebih panjang dari `max_length`.

pad_to_multiple_of (`int`, *opsional*) : Jika diatur, panjang urutan LFR akan di-*pad* menjadi kelipatan dari nilai ini.

return_attention_mask (`bool`, *opsional*) : Apakah akan mengembalikan `input_features_mask`. Bawaan adalah `self.return_attention_mask`.

**Mengembalikan:**

[BatchFeature](/docs/transformers/main/id/main_classes/feature_extractor#transformers.BatchFeature) dengan `input_features` berbentuk `(batch, max_lfr_frames, feature_size * num_frames_lfr)` dan `input_features_mask` tingkat frame.

Ekstrak fitur Kaldi mel-filterbank + LFR dari satu atau beberapa waveform audio mentah.

## FunAsrNanoProcessor[[transformers.FunAsrNanoProcessor]]

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

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

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/fun_asr_nano/processing_fun_asr_nano.py#L53)

**Parameter:**

feature_extractor (`FunAsrNanoFeatureExtractor`) : 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 (`str`, *opsional*, defaultnya `"<|object_ref_start|>"`) : Token yang digunakan sebagai placeholder untuk audio dalam teks.

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

[FunAsrNanoProcessor](/docs/transformers/main/id/model_doc/fun_asr_nano#transformers.FunAsrNanoProcessor) menyediakan semua fungsionalitas dari [FunAsrNanoFeatureExtractor](/docs/transformers/main/id/model_doc/fun_asr_nano#transformers.FunAsrNanoFeatureExtractor) dan [Qwen2Tokenizer](/docs/transformers/main/id/model_doc/qwen2#transformers.Qwen2Tokenizer). Lihat [~FunAsrNanoFeatureExtractor](/docs/transformers/main/id/model_doc/fun_asr_nano#transformers.FunAsrNanoFeatureExtractor) dan [~Qwen2Tokenizer](/docs/transformers/main/id/model_doc/qwen2#transformers.Qwen2Tokenizer) untuk informasi lebih lanjut.

#### __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.models.fun_asr_nano.processing_fun_asr_nano.FunAsrNanoProcessorKwargs'>)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/fun_asr_nano/processing_fun_asr_nano.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_tensors (`str` atau [TensorType](/docs/transformers/main/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/main/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/main/id/main_classes/feature_extractor#transformers.BatchFeature)

Kamus dengan teks yang ditokenisasi (`input_ids`, `attention_mask`) dan fitur audio (`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, transcription: str | list[str] | None = None, tokenize: bool = True, **kwargs: *<class 'transformers.models.fun_asr_nano.processing_fun_asr_nano.FunAsrNanoProcessorKwargs'>)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/fun_asr_nano/processing_fun_asr_nano.py#L135)

**Parameter:**

audio (`AudioInput` atau `list[AudioInput]`) : Audio untuk ditranskripsi. Bisa berupa URL, path lokal, array NumPy, tensor PyTorch, atau daftar dari item-item tersebut.

language (`str` atau `list[str]`, *opsional*) : Bahasa target. Menerima bahasa Mandarin, Inggris, atau Jepang sebagai nama lengkap dalam bahasa Inggris, kode ISO (`"zh"`, `"en"`, `"ja"`), atau nama bahasa Mandarin dari checkpoint (`"中文"`, `"英文"`, `"日文"`). Satu nilai akan diterapkan ke seluruh batch.

prompt (`str` atau `list[str]`, *opsional*) : Informasi kontekstual yang dapat meningkatkan transkripsi. Daftar harus sesuai dengan ukuran batch audio.

keywords (`str`, `list[str]`, atau `list[list[str]]`, *opsional*) : Hotwords untuk memihak pengenalan. String atau list datar dibagikan di seluruh batch; list bersarang menyediakan hotwords terpisah untuk setiap sampel audio.

transcription (`str` atau `list[str]`, *opsional*) : Transkrip target untuk pelatihan, satu per audio. Jika diberikan, setiap transkrip ditulis sebagai giliran asisten dan `labels` dikembalikan (lihat `output_labels` di [__call__()](/docs/transformers/main/id/model_doc/fun_asr_nano#transformers.FunAsrNanoProcessor.__call__)).

tokenize (`bool`, *opsional*, defaultnya `True`) : Apakah akan melakukan tokenisasi pada prompt dan memproses audio. Jika `False`, audio tidak dimuat dan prompt dikembalikan sebagai string dengan placeholder audio yang belum diperluas. Mengalirkannya bersama audio ke processor, `processor(text=prompts, audio=audio)`, menghasilkan output yang sama dengan `tokenize=True`.

- ****kwargs** : Argumen kata kunci tambahan yang diteruskan ke [apply_chat_template()](/docs/transformers/main/id/main_classes/processors#transformers.ProcessorMixin.apply_chat_template). Argumen processor (misalnya `text_kwargs`, `audio_kwargs`, ...) harus diteruskan sebagai `processor_kwargs={...}`.

**Mengembalikan:** [BatchFeature](/docs/transformers/main/id/main_classes/feature_extractor#transformers.BatchFeature) atau `list[str]`

Satu prompt per audio ketika `tokenize=False`, selain itu processor menghasilkan output yang siap diteruskan ke [FunAsrNanoForConditionalGeneration.generate()](/docs/transformers/main/id/main_classes/text_generation#transformers.GenerationMixin.generate), atau ke [FunAsrNanoForConditionalGeneration.forward()](/docs/transformers/main/id/model_doc/fun_asr_nano#transformers.FunAsrNanoForConditionalGeneration.forward) untuk menghitung loss ketika `transcription` diberikan.

Siapkan input untuk ASR menggunakan template chat transkripsi terstruktur dari checkpoint, baik untuk inferensi maupun, ketika `transcription` diberikan, untuk pelatihan.

## FunAsrNanoEncoder[[transformers.FunAsrNanoEncoder]]

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

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

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/fun_asr_nano/modeling_fun_asr_nano.py#L279)

**Parameter:**

config ([FunAsrNanoEncoderConfig](/docs/transformers/main/id/model_doc/fun_asr_nano#transformers.FunAsrNanoEncoderConfig)) : 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/main/id/main_classes/model#transformers.PreTrainedModel.from_pretrained) untuk memuat bobot model.

Enkoder audio Fun-ASR-Nano (arsitektur SenseVoice SAN-M), tanpa head di atasnya.

Model ini mewarisi dari [PreTrainedModel](/docs/transformers/main/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.FunAsrNanoEncoder.forward]]

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

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/fun_asr_nano/modeling_fun_asr_nano.py#L313)

**Parameter:**

input_features (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, feature_dim)`) : Tensor yang sesuai dengan fitur audio input. Fitur audio dapat diperoleh menggunakan [FunAsrNanoFeatureExtractor](/docs/transformers/main/id/model_doc/fun_asr_nano#transformers.FunAsrNanoFeatureExtractor). Lihat [FunAsrNanoFeatureExtractor.__call__()](/docs/transformers/main/id/model_doc/fun_asr_nano#transformers.FunAsrNanoFeatureExtractor.__call__) untuk detailnya ([FunAsrNanoProcessor](/docs/transformers/main/id/model_doc/fun_asr_nano#transformers.FunAsrNanoProcessor) menggunakan [FunAsrNanoFeatureExtractor](/docs/transformers/main/id/model_doc/fun_asr_nano#transformers.FunAsrNanoFeatureExtractor) untuk memproses audio).

input_features_mask (`torch.LongTensor` dengan bentuk `(batch_size, padded_feature_length)`) : 1 untuk frame mel yang valid dan 0 untuk padding.

**Mengembalikan:** [BaseModelOutput](/docs/transformers/main/id/main_classes/output#transformers.modeling_outputs.BaseModelOutput) atau `tuple(torch.Tensor)`

[BaseModelOutput](/docs/transformers/main/id/main_classes/output#transformers.modeling_outputs.BaseModelOutput) atau tuple dari `torch.Tensor` (jika `return_dict=False` diteruskan atau ketika `config.return_dict=False`) yang terdiri dari berbagai elemen tergantung pada konfigurasi ([FunAsrNanoConfig](/docs/transformers/main/id/model_doc/fun_asr_nano#transformers.FunAsrNanoConfig)) dan input.

Metode forward dari [FunAsrNanoEncoder](/docs/transformers/main/id/model_doc/fun_asr_nano#transformers.FunAsrNanoEncoder) 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.

- **last_hidden_state** (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, hidden_size)`) -- Urutan hidden-states pada keluaran lapisan terakhir model.
- **hidden_states** (`tuple(torch.Tensor)`, *opsional*, dikembalikan saat `output_hidden_states=True` dilewatkan atau saat `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.

## FunAsrNanoModel[[transformers.FunAsrNanoModel]]

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

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

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/fun_asr_nano/modeling_fun_asr_nano.py#L393)

**Parameter:**

config ([FunAsrNanoConfig](/docs/transformers/main/id/model_doc/fun_asr_nano#transformers.FunAsrNanoConfig)) : 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/main/id/main_classes/model#transformers.PreTrainedModel.from_pretrained) untuk memuat bobot model.

Model Fun-ASR-Nano (encoder audio SenseVoice SAN-M, adaptor Transformer, dan model bahasa Qwen3), tanpa kepala pemodelan bahasa.

Model ini mewarisi dari [PreTrainedModel](/docs/transformers/main/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.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'>)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/fun_asr_nano/modeling_fun_asr_nano.py#L468)

**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/main/id/model_doc/auto#transformers.AutoTokenizer). Lihat [PreTrainedTokenizer.encode()](/docs/transformers/main/id/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) dan [PreTrainedTokenizer.__call__()](/docs/transformers/main/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 [FunAsrNanoFeatureExtractor](/docs/transformers/main/id/model_doc/fun_asr_nano#transformers.FunAsrNanoFeatureExtractor). Lihat [FunAsrNanoFeatureExtractor.__call__()](/docs/transformers/main/id/model_doc/fun_asr_nano#transformers.FunAsrNanoFeatureExtractor.__call__) untuk detailnya ([FunAsrNanoProcessor](/docs/transformers/main/id/model_doc/fun_asr_nano#transformers.FunAsrNanoProcessor) menggunakan [FunAsrNanoFeatureExtractor](/docs/transformers/main/id/model_doc/fun_asr_nano#transformers.FunAsrNanoFeatureExtractor) 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/main/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/main/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:** `FunAsrNanoModelOutputWithPast` atau `tuple(torch.Tensor)`

A `FunAsrNanoModelOutputWithPast` atau tuple dari `torch.Tensor` (jika `return_dict=False` dilewatkan atau ketika `config.return_dict=False`) yang terdiri dari berbagai elemen tergantung pada konfigurasi ([FunAsrNanoConfig](/docs/transformers/main/id/model_doc/fun_asr_nano#transformers.FunAsrNanoConfig)) dan input.

Metode forward dari [FunAsrNanoModel](/docs/transformers/main/id/model_doc/fun_asr_nano#transformers.FunAsrNanoModel) 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.

## FunAsrNanoForConditionalGeneration[[transformers.FunAsrNanoForConditionalGeneration]]

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

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

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/fun_asr_nano/modeling_fun_asr_nano.py#L551)

**Parameter:**

config ([FunAsrNanoConfig](/docs/transformers/main/id/model_doc/fun_asr_nano#transformers.FunAsrNanoConfig)) : 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/main/id/main_classes/model#transformers.PreTrainedModel.from_pretrained) untuk memuat bobot model.

Model Fun-ASR-Nano untuk pengenalan ucapan: encoder audio SenseVoice SAN-M, adaptor Transformer, dan model bahasa Qwen3 dengan kepala pemodelan bahasa.

Model ini mewarisi dari [PreTrainedModel](/docs/transformers/main/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.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'>)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/fun_asr_nano/modeling_fun_asr_nano.py#L564)

**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/main/id/model_doc/auto#transformers.AutoTokenizer). Lihat [PreTrainedTokenizer.encode()](/docs/transformers/main/id/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) dan [PreTrainedTokenizer.__call__()](/docs/transformers/main/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 [FunAsrNanoFeatureExtractor](/docs/transformers/main/id/model_doc/fun_asr_nano#transformers.FunAsrNanoFeatureExtractor). Lihat [FunAsrNanoFeatureExtractor.__call__()](/docs/transformers/main/id/model_doc/fun_asr_nano#transformers.FunAsrNanoFeatureExtractor.__call__) untuk detailnya ([FunAsrNanoProcessor](/docs/transformers/main/id/model_doc/fun_asr_nano#transformers.FunAsrNanoProcessor) menggunakan [FunAsrNanoFeatureExtractor](/docs/transformers/main/id/model_doc/fun_asr_nano#transformers.FunAsrNanoFeatureExtractor) 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/main/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/main/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:** `FunAsrNanoCausalLMOutputWithPast` atau `tuple(torch.Tensor)`

A `FunAsrNanoCausalLMOutputWithPast` atau tuple dari `torch.Tensor` (jika `return_dict=False` dilewatkan atau ketika `config.return_dict=False`) yang terdiri dari berbagai elemen tergantung pada konfigurasi ([FunAsrNanoConfig](/docs/transformers/main/id/model_doc/fun_asr_nano#transformers.FunAsrNanoConfig)) dan input.

Metode forward dari [FunAsrNanoForConditionalGeneration](/docs/transformers/main/id/model_doc/fun_asr_nano#transformers.FunAsrNanoForConditionalGeneration) 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/main/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 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")
```