# Fun-ASR-Nano

## 概要

Fun-ASR-Nano は、Alibaba DAMO Academy の FunAudioLLM チームが開発した、8億パラメータのエンドツーエンド音声認識モデルです。同等のモデルよりも大幅に小さいながら、中国語、英語、日本語の ASR ベンチマークで最先端の性能を実現しています。

このモデルは、[Fun-ASR: An Industrial-Grade Speech Recognition System](https://huggingface.co/papers/2509.12508) で提案されました。

### アーキテクチャ

Fun-ASR-Nanoは3つのコンポーネントで構成されています:

1. **Audio Encoder**（SenseVoiceEncoderSmall）: 70層のSANM（Self-Attention with FSMN Memory）エンコーダーです。マルチヘッド自己注意機構とFeedforward Sequential Memory Networksを組み合わせることで、効率的な音声特徴抽出を実現します。

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/main/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) と同様の設定が得られます。

設定オブジェクトは [PreTrainedConfig](/docs/transformers/main/ja/main_classes/configuration#transformers.PreTrainedConfig) を継承し、モデルの出力を制御するために使用できます。詳細については、[PreTrainedConfig](/docs/transformers/main/ja/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/main/src/transformers/models/fun_asr_nano/configuration_fun_asr_nano.py#L25)

**パラメータ:**

num_mel_bins (`int`、*任意*、デフォルトは`80`) : 入力フレームごとに使用されるメル特徴の数を指定します。`AutoFeatureExtractor`クラスで使用される値と一致させる必要があります。

hidden_size (`int`、*任意*、デフォルトは`512`) : 隠れ表現の次元数。

num_attention_heads (`int`、*任意*、デフォルトは `4`) : Transformer デコーダーの各アテンション層におけるアテンションヘッドの数。

intermediate_size (`int`、*任意*、デフォルトは`2048`) : MLP 表現の次元数。

num_hidden_layers (`int`、*optional*、デフォルト値は 70) : 転写層と、それに続くタイムスタンプ予測層の両方を含む、エンコーダー層の総数。

hidden_dropout (`float`、*任意*、デフォルトは `0.1`) : embeddings、encoder、pooler 内のすべての全結合層における dropout 確率。

attention_dropout (`float`、*任意*、デフォルトは`0.1`) : 注意確率のドロップアウト率です。

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`、*optional*、デフォルトは 7) : 低フレームレート特徴量抽出によってスタックされる連続する mel フレームの数。

num_timestamp_prediction_layers (`int`、*optional*、デフォルト値は 20) : タイムスタンプ予測に専用に割り当てられるエンコーダー層（末尾の層）の数です。転写出力は、`num_hidden_layers - num_timestamp_prediction_layers - 1` 層の後に取得されます。

fsmn_kernel_size (`int`, *optional*, デフォルトは 11) : フィードフォワード逐次メモリネットワーク (FSMN) の畳み込みのカーネルサイズ。

これは、FunAsrNanoModel の設定を保存するための設定クラスです。指定された引数に基づいて Fun Asr Nano モデルをインスタンス化し、モデルのアーキテクチャを定義するために使用されます。デフォルト値で設定をインスタンス化すると、[FunAudioLLM/Fun-ASR-Nano-2512-hf](https://huggingface.co/FunAudioLLM/Fun-ASR-Nano-2512-hf) と同様の設定が得られます。

設定オブジェクトは [PreTrainedConfig](/docs/transformers/main/ja/main_classes/configuration#transformers.PreTrainedConfig) を継承し、モデルの出力を制御するために使用できます。詳細については、[PreTrainedConfig](/docs/transformers/main/ja/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/main/src/transformers/models/fun_asr_nano/configuration_fun_asr_nano.py#L62)

**パラメータ:**

hidden_size (`int`、*任意*、デフォルトは`1024`) : 隠れ表現の次元数。

num_attention_heads (`int`、*任意*、デフォルトは `8`) : Transformer デコーダーの各アテンション層におけるアテンションヘッドの数。

intermediate_size (`int`、*optional*、デフォルトは`256`) : MLP 表現の次元数。

num_hidden_layers (`int`、*任意*、デフォルトは `2`) : Transformer デコーダーの隠れ層の数。

hidden_dropout (`float`、*任意*、デフォルトは `0.0`) : embeddings、encoder、pooler 内のすべての全結合層における dropout 確率。

attention_dropout (`float`、*任意*、デフォルトは`0.0`) : 注意確率のドロップアウト率です。

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) と同様の設定が得られます。

設定オブジェクトは [PreTrainedConfig](/docs/transformers/main/ja/main_classes/configuration#transformers.PreTrainedConfig) を継承し、モデルの出力を制御するために使用できます。詳細については、[PreTrainedConfig](/docs/transformers/main/ja/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/main/src/transformers/models/fun_asr_nano/feature_extraction_fun_asr_nano.py#L33)

**パラメータ:**

feature_size (`int`、*optional*、デフォルトは 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` 個ごとに 1 個採用）。

window (`str`、*任意*、デフォルトは`"hamming"`) : STFT用のウィンドウ関数。

padding_value (`float`、*任意*、デフォルト値は 0.0) : 短いシーケンスのパディングに使用される値。

return_attention_mask (`bool`、*任意*、デフォルトは`True`) : attention mask を返すかどうか。

Fun-ASR-Nano の特徴抽出器を構築します。

このフィーチャーエクストラクターは、主要なメソッドの大部分を含む [SequenceFeatureExtractor](/docs/transformers/main/ja/main_classes/feature_extractor#transformers.SequenceFeatureExtractor) を継承しています。これらのメソッドに関する詳細については、このスーパークラスを参照してください。

`torchaudio.compliance.kaldi.fbank` を介して Kaldi 互換のメルフィルタバンク特徴量（元の FunASR フロントエンドと一致）を抽出し、その後、`num_frames_lfr` 個の連続フレームをスタックして、ストライド `stride_lfr` でサブサンプリングを行うことで、低フレームレート（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/main/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/main/ja/internal/file_utils#transformers.TensorType)、*optional*) : 設定されている場合、指定されたフレームワーク (`"pt"`、`"np"` など) のテンソルを返します。

padding (`bool` または `str`、*省略可能*、デフォルトは `True`) : [pad()](/docs/transformers/main/ja/main_classes/feature_extractor#transformers.SequenceFeatureExtractor.pad) に転送されるパディング戦略。

max_length (`int`, *任意*) : パディングや切り詰め用の最大 LFR シーケンス長。

truncation (`bool`、*任意*、デフォルトは`False`) : `max_length`を超えるシーケンスを切り詰めるかどうか。

pad_to_multiple_of (`int`, *optional*) : 設定されている場合、LFR シーケンスの長さをこの値の倍数にパディングします。

return_attention_mask (`bool`, *任意*) : `input_features_mask`を返すかどうか。デフォルトは`self.return_attention_mask`です。

**戻り値:**

`input_features` の形状が `(batch, max_lfr_frames, feature_size * num_frames_lfr)` であり、フレームレベルの `input_features_mask` を持つ [BatchFeature](/docs/transformers/main/ja/main_classes/feature_extractor#transformers.BatchFeature)

1つ以上の生オーディオ波形から、Kaldiのメルフィルタバンク特徴量および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/main/src/transformers/models/fun_asr_nano/processing_fun_asr_nano.py#L53)

**パラメータ:**

feature_extractor (`FunAsrNanoFeatureExtractor`) : 特徴抽出器は必須の入力です。

tokenizer (`Qwen2Tokenizer`) : トークナイザーは必須の入力です。

chat_template (`str`) : チャット内のメッセージのリストをトークン化可能な文字列に変換するための Jinja テンプレート。

audio_token (`str`、*任意*、デフォルトは `"<|object_ref_start|>"`) : テキスト内のオーディオのプレースホルダーとして使用されるトークン。

FunAsrNanoProcessor を構築します。これは、フィーチャーエクストラクターとトークナイザーを単一のプロセッサーにラップします。

[FunAsrNanoProcessor](/docs/transformers/main/ja/model_doc/fun_asr_nano#transformers.FunAsrNanoProcessor) は、[FunAsrNanoFeatureExtractor](/docs/transformers/main/ja/model_doc/fun_asr_nano#transformers.FunAsrNanoFeatureExtractor) と [Qwen2Tokenizer](/docs/transformers/main/ja/model_doc/qwen2#transformers.Qwen2Tokenizer) のすべての機能を提供します。詳細については、[~FunAsrNanoFeatureExtractor](/docs/transformers/main/ja/model_doc/fun_asr_nano#transformers.FunAsrNanoFeatureExtractor) および [~Qwen2Tokenizer](/docs/transformers/main/ja/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.models.fun_asr_nano.processing_fun_asr_nano.FunAsrNanoProcessorKwargs'>)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/fun_asr_nano/processing_fun_asr_nano.py#L71)

**パラメータ:**

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 テンソルの場合、各オーディオの形状は (C, T) である必要があります。ここで C はチャネル数、T はオーディオのサンプル長を表します。

output_labels (`bool`、*任意*、デフォルト: False) : 学習用のラベルを返すかどうか。

return_tensors (`str` または [TensorType](/docs/transformers/main/ja/internal/file_utils#transformers.TensorType)、*optional*) : 設定されている場合、特定のフレームワークのテンソルを返します。受け入れ可能な値は以下の通りです:  - `'pt'`: PyTorch の `torch.Tensor` オブジェクトを返します。 - `'np'`: NumPy の `np.ndarray` オブジェクトを返します。

- ****kwargs** ([ProcessingKwargs](/docs/transformers/main/ja/main_classes/processors#transformers.ProcessingKwargs), *optional*) : 各モダリティ（テキスト、画像、動画、音声）の追加処理オプション。モデル固有のパラメータは上記にリストされています。サポートされている引数の完全なリストについては、TypedDict クラスを参照してください。

**戻り値:** [BatchFeature](/docs/transformers/main/ja/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.models.fun_asr_nano.processing_fun_asr_nano.FunAsrNanoProcessorKwargs'>)
```

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

**パラメータ:**

audio (`AudioInput` または `list[AudioInput]`) : 文字起こし対象の音声。URL、ローカルパス、NumPy 配列、PyTorch テンソル、またはそれらのリストを指定できます。

language (`str` または `list[str]`、*省略可能*) : ターゲット言語。英語の正式名称（Chinese、English、Japanese）、ISO コード（`"zh"`、`"en"`、`"ja"`）、またはチェックポイントの中国語言語名（`"中文"`、`"英文"`、`"日文"`）を受け取ります。単一の値はバッチ全体にブロードキャストされます。

prompt (`str` または `list[str]`、*省略可*) : 文字起こしの精度を向上させる可能性がある文脈情報。リストの場合、オーディオのバッチサイズと一致する必要があります。

keywords (`str`、`list[str]`、または `list[list[str]]`、*任意*) : 認識をバイアスするためのホットワード。文字列またはフラットなリストはバッチ全体で共有されます。ネストされたリストを使用すると、各オーディオサンプルに対して個別のホットワードを指定できます。

tokenize (`bool`、*任意*、デフォルトは `True`) : プロンプトのトークナイズとオーディオの処理を行うかどうかを指定します。`False` の場合、オーディオは読み込まれず、プロンプトは展開されていないオーディオプレースホルダーを含む文字列として返されます。これらをオーディオとともにプロセッサーに渡す `processor(text=prompts, audio=audio)` 場合、`tokenize=True` と同じ出力が得られます。

- ****kwargs** : [apply_chat_template()](/docs/transformers/main/ja/main_classes/processors#transformers.ProcessorMixin.apply_chat_template)および基盤となるプロセッサ呼び出しに転送される追加のキーワード引数（例: `text_kwargs`、`audio_kwargs` など）。

**戻り値:** [BatchFeature](/docs/transformers/main/ja/main_classes/feature_extractor#transformers.BatchFeature) または `list[str]`

`tokenize=False` の場合は 1 つのオーディオごとに 1 つのプロンプトが出力され、それ以外の場合は [FunAsrNanoForConditionalGeneration.generate()](/docs/transformers/main/ja/main_classes/text_generation#transformers.GenerationMixin.generate) にそのまま渡せる状態の出力が得られます。

チェックポイントの構造化トランスクリプションチャットテンプレートを使用して、ASR用の入力を準備します。

## FunAsrNanoEncoder[[transformers.FunAsrNanoEncoder]]

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

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

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

**パラメータ:**

config ([FunAsrNanoEncoderConfig](/docs/transformers/main/ja/model_doc/fun_asr_nano#transformers.FunAsrNanoEncoderConfig)) : モデルのパラメータをすべて含むモデル設定クラスです。設定ファイルで初期化しても、モデルに関連する重みは読み込まれず、設定のみが読み込まれます。モデルの重みをロードするには、[from_pretrained()](/docs/transformers/main/ja/main_classes/model#transformers.PreTrainedModel.from_pretrained) メソッドを参照してください。

ヘッドなしの Fun-ASR-Nano 音声エンコーダー（SenseVoice SAN-M アーキテクチャ）。

このモデルは [PreTrainedModel](/docs/transformers/main/ja/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/main/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/main/ja/model_doc/fun_asr_nano#transformers.FunAsrNanoFeatureExtractor) を使用して取得できます。詳細は [FunAsrNanoFeatureExtractor.__call__()](/docs/transformers/main/ja/model_doc/fun_asr_nano#transformers.FunAsrNanoFeatureExtractor.__call__) を参照してください（[FunAsrNanoProcessor](/docs/transformers/main/ja/model_doc/fun_asr_nano#transformers.FunAsrNanoProcessor) は音声の処理に [FunAsrNanoFeatureExtractor](/docs/transformers/main/ja/model_doc/fun_asr_nano#transformers.FunAsrNanoFeatureExtractor) を使用します）。

input_features_mask (`torch.LongTensor`、shape `(batch_size, padded_feature_length)`) : 有効な mel フレームには 1、パディングには 0。

**戻り値:** [BaseModelOutput](/docs/transformers/main/ja/main_classes/output#transformers.modeling_outputs.BaseModelOutput) または `tuple(torch.FloatTensor)`

[FunAsrNanoConfig](/docs/transformers/main/ja/model_doc/fun_asr_nano#transformers.FunAsrNanoConfig) や入力に応じて、さまざまな要素で構成される [BaseModelOutput](/docs/transformers/main/ja/main_classes/output#transformers.modeling_outputs.BaseModelOutput) または `torch.FloatTensor` のタプル（`return_dict=False` が渡された場合、または `config.return_dict=False` の場合）。

[FunAsrNanoEncoder](/docs/transformers/main/ja/model_doc/fun_asr_nano#transformers.FunAsrNanoEncoder)のforwardメソッドは、`__call__`特殊メソッドをオーバーライドします。

この関数内でフォワードパスの手順を定義する必要がありますが、その後、この関数ではなく`Module`インスタンスを呼び出すべきです。前者は前処理と後処理の実行を適切に処理するのに対し、後者はそれらを無視してしまいます。

- **last_hidden_state** (`torch.FloatTensor`、shape `(batch_size, sequence_length, hidden_size)`) -- モデルの最終層の出力における隠れ状態のシーケンス。
- **hidden_states** (`tuple(torch.FloatTensor)`、*optional*、`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)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) -- `torch.FloatTensor` のタプル（各レイヤーごとに1つ）で、形状は `(batch_size, num_heads, sequence_length, sequence_length)` です。

  アテンションのsoftmax後のアテンション重み。自己アテンションヘッド内で加重平均を計算するために使用されます。

## FunAsrNanoModel[[transformers.FunAsrNanoModel]]

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

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

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

**パラメータ:**

config ([FunAsrNanoConfig](/docs/transformers/main/ja/model_doc/fun_asr_nano#transformers.FunAsrNanoConfig)) : モデルのパラメータをすべて含むモデル設定クラスです。設定ファイルで初期化しても、モデルに関連する重みは読み込まれず、設定のみが読み込まれます。モデルの重みをロードするには、[from_pretrained()](/docs/transformers/main/ja/main_classes/model#transformers.PreTrainedModel.from_pretrained) メソッドを確認してください。

Fun-ASR-Nano モデル（SenseVoice SAN-M 音声エンコーダー、Transformer アダプター、Qwen3 言語モデル）は、言語モデリングヘッドを備えていません。

このモデルは [PreTrainedModel](/docs/transformers/main/ja/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.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/fun_asr_nano/modeling_fun_asr_nano.py#L468)

**パラメータ:**

input_ids (`torch.LongTensor`、shape `(batch_size, sequence_length)`、*任意*) : 語彙における入力シーケンスのトークンインデックスです。デフォルトでは、パディングは無視されます。インデックスは [AutoTokenizer](/docs/transformers/main/ja/model_doc/auto#transformers.AutoTokenizer) を使用して取得できます。詳細については、[PreTrainedTokenizer.encode()](/docs/transformers/main/ja/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) および [PreTrainedTokenizer.__call__()](/docs/transformers/main/ja/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) を参照してください。 [入力IDとは何ですか？](../glossary#input-ids)

input_features (`torch.FloatTensor`、shape `(batch_size, sequence_length, feature_dim)`、*任意*) : 入力音声特徴に対応するテンソルです。音声特徴は [FunAsrNanoFeatureExtractor](/docs/transformers/main/ja/model_doc/fun_asr_nano#transformers.FunAsrNanoFeatureExtractor) を使用して取得できます。詳細は [FunAsrNanoFeatureExtractor.__call__()](/docs/transformers/main/ja/model_doc/fun_asr_nano#transformers.FunAsrNanoFeatureExtractor.__call__) を参照してください（[FunAsrNanoProcessor](/docs/transformers/main/ja/model_doc/fun_asr_nano#transformers.FunAsrNanoProcessor) は音声の処理に [FunAsrNanoFeatureExtractor](/docs/transformers/main/ja/model_doc/fun_asr_nano#transformers.FunAsrNanoFeatureExtractor) を使用します）。

input_features_mask (`torch.Tensor`、形状 `(batch_size, feature_sequence_length)`) : パディングのフィーチャーインデックスに対するアテンションの計算を回避するためのマスク。

attention_mask (`torch.Tensor`、shape `(batch_size, sequence_length)`、*任意*) : padding トークンのインデックスに対する 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（self-attention ブロックおよび cross-attention ブロック内の key と value）です。通常、`use_cache=True` または `config.use_cache=True` の場合、モデルがデコードの以前の段階で返した `past_key_values` で構成されます。入力として許可されるのは [Cache](/docs/transformers/main/ja/internal/generation_utils#transformers.Cache) インスタンスのみです。[kv cache ガイド](https://huggingface.co/docs/transformers/en/kv_cache)を参照してください。`past_key_values` が渡されない場合、デフォルトで [DynamicCache](/docs/transformers/main/ja/internal/generation_utils#transformers.DynamicCache) が初期化されます。モデルは、入力として与えられたのと同じキャッシュ形式を出力します。`past_key_values` を使用する場合は、すべての `input_ids`（形状 `(batch_size, sequence_length)`）の代わりに、このモデルに過去の key value 状態が与えられていない未処理の `input_ids`（形状 `(batch_size, unprocessed_length)`）のみを入力する必要があります。

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`を参照）。

**戻り値:** `FunAsrNanoModelOutputWithPast` または `tuple(torch.FloatTensor)`

`FunAsrNanoModelOutputWithPast`、または `torch.FloatTensor` のタプル（`return_dict=False` が渡された場合、または `config.return_dict=False` の場合）。設定（[FunAsrNanoConfig](/docs/transformers/main/ja/model_doc/fun_asr_nano#transformers.FunAsrNanoConfig)）や入力に応じて、さまざまな要素で構成されます。

[FunAsrNanoModel](/docs/transformers/main/ja/model_doc/fun_asr_nano#transformers.FunAsrNanoModel)のforwardメソッドは、`__call__`特殊メソッドをオーバーライドします。

この関数内でフォワードパスの手順を定義する必要がありますが、その後、この関数ではなく`Module`インスタンスを呼び出すべきです。前者は前処理と後処理の実行を適切に処理するのに対し、後者はそれらを無視してしまいます。

- **audio_hidden_states** (`torch.FloatTensor`、*任意*) -- 投影されたオーディオの隠れ状態。

## FunAsrNanoForConditionalGeneration[[transformers.FunAsrNanoForConditionalGeneration]]

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

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

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

**パラメータ:**

config ([FunAsrNanoConfig](/docs/transformers/main/ja/model_doc/fun_asr_nano#transformers.FunAsrNanoConfig)) : モデルのパラメータをすべて含むモデル設定クラスです。設定ファイルで初期化しても、モデルに関連する重みは読み込まれず、設定のみが読み込まれます。モデルの重みをロードするには、[from_pretrained()](/docs/transformers/main/ja/main_classes/model#transformers.PreTrainedModel.from_pretrained) メソッドを確認してください。

音声認識用のFun-ASR-Nanoモデル: SenseVoice SAN-Mオーディオエンコーダー、Transformerアダプター、および言語モデリングヘッドを備えたQwen3言語モデル。

このモデルは [PreTrainedModel](/docs/transformers/main/ja/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.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/fun_asr_nano/modeling_fun_asr_nano.py#L564)

**パラメータ:**

input_ids (`torch.LongTensor`、shape `(batch_size, sequence_length)`、*任意*) : 語彙における入力シーケンスのトークンインデックスです。デフォルトでは、パディングは無視されます。インデックスは [AutoTokenizer](/docs/transformers/main/ja/model_doc/auto#transformers.AutoTokenizer) を使用して取得できます。詳細については、[PreTrainedTokenizer.encode()](/docs/transformers/main/ja/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) および [PreTrainedTokenizer.__call__()](/docs/transformers/main/ja/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) を参照してください。 [入力IDとは何ですか？](../glossary#input-ids)

input_features (`torch.FloatTensor`、shape `(batch_size, sequence_length, feature_dim)`、*任意*) : 入力音声特徴に対応するテンソルです。音声特徴は [FunAsrNanoFeatureExtractor](/docs/transformers/main/ja/model_doc/fun_asr_nano#transformers.FunAsrNanoFeatureExtractor) を使用して取得できます。詳細は [FunAsrNanoFeatureExtractor.__call__()](/docs/transformers/main/ja/model_doc/fun_asr_nano#transformers.FunAsrNanoFeatureExtractor.__call__) を参照してください（[FunAsrNanoProcessor](/docs/transformers/main/ja/model_doc/fun_asr_nano#transformers.FunAsrNanoProcessor) は音声の処理に [FunAsrNanoFeatureExtractor](/docs/transformers/main/ja/model_doc/fun_asr_nano#transformers.FunAsrNanoFeatureExtractor) を使用します）。

input_features_mask (`torch.Tensor`、形状 `(batch_size, feature_sequence_length)`) : パディングのフィーチャーインデックスに対するアテンションの計算を回避するためのマスク。

attention_mask (`torch.Tensor`、shape `(batch_size, sequence_length)`、*任意*) : padding トークンのインデックスに対する 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（self-attention ブロックおよび cross-attention ブロック内の key と value）です。通常、`use_cache=True` または `config.use_cache=True` の場合、モデルがデコードの以前の段階で返した `past_key_values` で構成されます。入力として許可されるのは [Cache](/docs/transformers/main/ja/internal/generation_utils#transformers.Cache) インスタンスのみです。[kv cache ガイド](https://huggingface.co/docs/transformers/en/kv_cache)を参照してください。`past_key_values` が渡されない場合、デフォルトで [DynamicCache](/docs/transformers/main/ja/internal/generation_utils#transformers.DynamicCache) が初期化されます。モデルは、入力として与えられたのと同じキャッシュ形式を出力します。`past_key_values` を使用する場合は、すべての `input_ids`（形状 `(batch_size, sequence_length)`）の代わりに、このモデルに過去の key value 状態が与えられていない未処理の `input_ids`（形状 `(batch_size, unprocessed_length)`）のみを入力する必要があります。

inputs_embeds (`torch.FloatTensor`、shape `(batch_size, sequence_length, hidden_size)`、*任意*) : `input_ids` を渡す代わりに、埋め込み表現を直接渡すこともできます。これは、モデル内部の埋め込み参照行列よりも、`input_ids` のインデックスを対応するベクトルに変換する方法をより細かく制御したい場合に有用です。

labels (`torch.LongTensor`、形状 `(batch_size, sequence_length)`、*任意*) : マスク言語モデリング損失を計算するためのラベル。

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 次元である必要があります。これは、パックされたテンソル形式（バッチとシーケンス長を単一の次元にまとめる形式）を使用する場合に有用です。

**戻り値:** `FunAsrNanoCausalLMOutputWithPast` または `tuple(torch.FloatTensor)`

`FunAsrNanoCausalLMOutputWithPast`、または `torch.FloatTensor` のタプル（`return_dict=False` が渡された場合、または `config.return_dict=False` の場合）。設定（[FunAsrNanoConfig](/docs/transformers/main/ja/model_doc/fun_asr_nano#transformers.FunAsrNanoConfig)）や入力に応じて、さまざまな要素で構成されます。

[FunAsrNanoForConditionalGeneration](/docs/transformers/main/ja/model_doc/fun_asr_nano#transformers.FunAsrNanoForConditionalGeneration)のforwardメソッドは、`__call__`特殊メソッドをオーバーライドします。

この関数内でフォワードパスの手順を定義する必要がありますが、その後、この関数ではなく`Module`インスタンスを呼び出すべきです。前者は前処理と後処理の実行を適切に処理するのに対し、後者はそれらを無視してしまいます。

- **loss** (`torch.FloatTensor`、shape `(1,)`、*optional*、`labels` が指定された場合に返されます) -- 言語モデリングの損失(次のトークンの予測用)。
- **logits** (`torch.FloatTensor`、形状 `(batch_size, sequence_length, config.vocab_size)`) -- 言語モデリングヘッドの予測スコア。
- **past_key_values** (`Cache`、*任意*、`use_cache=True` が渡された場合または `config.use_cache=True` の場合に返されます) -- [Cache](/docs/transformers/main/ja/internal/generation_utils#transformers.Cache) のインスタンスです。
- **hidden_states** (`tuple[torch.FloatTensor]`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) -- `torch.FloatTensor` のタプル（モデルに埋め込み層がある場合はその出力用 + 各層の出力用）で、形状は `(batch_size, sequence_length, hidden_size)` です。

  各層の出力におけるモデルのHidden-states、および任意の初期埋め込み出力。
- **attentions** (`tuple[torch.FloatTensor]`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) -- `torch.FloatTensor` のタプル（各レイヤーごとに1つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)`。

  アテンションのsoftmax後のアテンション重み。自己アテンションヘッド内で加重平均を計算するために使用されます。
- **audio_hidden_states** (`torch.FloatTensor`、*任意*) -- 投影後のオーディオエンコーダーの隠れ状態。

例:

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