# Qwen3 ASR ## 概要 Qwen3 ASRは、AlibabaのQwenチームが開発した自動音声認識モデルです。Whisperスタイルの音声エンコーダーとQwen3言語モデルデコーダーを組み合わせることで、音声からテキストへの書き起こしを実現します。このモデルは、自動言語検出と多言語対応の書き起こしをサポートしています。 強制アライナーモデルも含まれています。これは、提供された文字起こしとその音声にタイムスタンプを付与するために使用できます。このモデルは、単語の長さを予測する分類ヘッドを備えた、同じ音声エンコーダーモデルを使用しています。このモデルは、任意のASRモデルの文字起こしと組み合わせて使用できます（以下はParakeet CTCの例です）。 利用可能なチェックポイント: - [Qwen/Qwen3-ASR-1.7B-hf](https://huggingface.co/Qwen/Qwen3-ASR-1.7B-hf) - [Qwen/Qwen3-ASR-0.6B-hf](https://huggingface.co/Qwen/Qwen3-ASR-0.6B-hf) - [Qwen/Qwen3-ForcedAligner-0.6B-hf](https://huggingface.co/Qwen/Qwen3-ForcedAligner-0.6B-hf) サポートされている言語は以下の通りです: - `Qwen3-ASR-1.7B` および `Qwen3-ASR-0.6B`: 中国語 (zh)、英語 (en)、広東語 (yue)、アラビア語 (ar)、ドイツ語 (de)、フランス語 (fr)、スペイン語 (es)、ポルトガル語 (pt)、インドネシア語 (id)、イタリア語 (it)、韓国語 (ko)、ロシア語 (ru)、タイ語 (th)、ベトナム語 (vi)、日本語 (ja)、トルコ語 (tr)、ヒンディー語 (hi)、マレー語 (ms)、オランダ語 (nl)、スウェーデン語 (sv)、デンマーク語 (da)、フィンランド語 (fi)、ポーランド語 (pl)、チェコ語 (cs)、フィリピン語 (fil)、ペルシア語 (fa)、ギリシャ語 (el)、ハンガリー語 (hu)、マケドニア語 (mk)、ルーマニア語 (ro)。 - `Qwen3-ForcedAligner-0.6B`: 中国語 (zh)、英語 (en)、広東語 (yue)、フランス語 (fr)、ドイツ語 (de)、イタリア語 (it)、日本語 (ja)、韓国語 (ko)、ポルトガル語 (pt)、ロシア語 (ru)、スペイン語 (es)。 詳細については、[QwenLM/Qwen3-ASR](https://github.com/QwenLM/Qwen3-ASR)の元のリポジトリおよび[レポート](https://huggingface.co/papers/2601.21337)を参照してください。 このモデルは、[Eric Bezzam](https://huggingface.co/bezzam)氏と[Muhammed Tariq](https://huggingface.co/mbtariq82)氏によって提供されました。 ## 使用方法 ### 単純な文字起こし 音声の文字起こしを行う最もシンプルな方法は、`apply_transcription_request` を使用することです。この関数はチャットテンプレートの整形を自動で行うため、`apply_chat_template` のための便利なラッパーとして機能します（[Chat template](#chat-template) を参照）。 ```python from transformers import AutoProcessor, AutoModelForMultimodalLM model_id = "Qwen/Qwen3-ASR-1.7B-hf" processor = AutoProcessor.from_pretrained(model_id) model = AutoModelForMultimodalLM.from_pretrained(model_id, device_map="auto") print(f"Model loaded on {model.device} with dtype {model.dtype}") inputs = processor.apply_transcription_request( audio="https://huggingface.co/datasets/bezzam/audio_samples/resolve/main/librispeech_mr_quilter.wav", ).to(model.device, model.dtype) output_ids = model.generate(**inputs, max_new_tokens=256) generated_ids = output_ids[:, inputs["input_ids"].shape[1]:] # Raw output includes language tag and marker raw = processor.decode(generated_ids)[0] print(f"Raw: {raw}") # Parsed output: dict with "language" and "transcription" parsed = processor.decode(generated_ids, return_format="parsed")[0] print(f"Parsed: {parsed}") # Extract only the transcription text transcription = processor.decode(generated_ids, return_format="transcription_only")[0] print(f"Transcription: {transcription}") """ Raw: language EnglishMr. Quilter is the apostle of the middle classes, and we are glad to welcome his gospel. Parsed: {'language': 'English', 'transcription': 'Mr. Quilter is the apostle of the middle classes, and we are glad to welcome his gospel.'} Transcription: Mr. Quilter is the apostle of the middle classes, and we are glad to welcome his gospel. """ ``` ### 言語の強制 以下に示すように、転写言語を強制指定できます。 ```python from transformers import AutoProcessor, AutoModelForMultimodalLM model_id = "Qwen/Qwen3-ASR-1.7B-hf" processor = AutoProcessor.from_pretrained(model_id) model = AutoModelForMultimodalLM.from_pretrained(model_id, device_map="auto") # Without language hint (auto-detect) inputs = processor.apply_transcription_request( audio="https://huggingface.co/datasets/hf-internal-testing/dummy-audio-samples/resolve/main/mandarin_voxcpm_zh.wav", ).to(model.device, model.dtype) output_ids = model.generate(**inputs, max_new_tokens=256) generated_ids = output_ids[:, inputs["input_ids"].shape[1]:] print(f"Auto-detect: {processor.decode(generated_ids, return_format='transcription_only')[0]}") # With forced language inputs = processor.apply_transcription_request( audio="https://huggingface.co/datasets/hf-internal-testing/dummy-audio-samples/resolve/main/mandarin_voxcpm_zh.wav", language="Chinese", # or language code "zh" ).to(model.device, model.dtype) output_ids = model.generate(**inputs, max_new_tokens=256) generated_ids = output_ids[:, inputs["input_ids"].shape[1]:] print(f"Forced: {processor.decode(generated_ids, return_format='transcription_only')[0]}") ``` ### コンテキスト / ホットワード `prompt` を介して、自由形式のコンテキスト（例：ドメイン固有の語彙、名前、背景情報など）を渡すことで、文字起こしを偏らせることができます。 ```python from transformers import AutoProcessor, AutoModelForMultimodalLM model_id = "Qwen/Qwen3-ASR-1.7B-hf" processor = AutoProcessor.from_pretrained(model_id) model = AutoModelForMultimodalLM.from_pretrained(model_id, device_map="auto") inputs = processor.apply_transcription_request( audio="https://huggingface.co/datasets/bezzam/audio_samples/resolve/main/librispeech_mr_quilter.wav", prompt="Vocabulary: Quilter, apostle, gospel.", language="English", ).to(model.device, model.dtype) output_ids = model.generate(**inputs, max_new_tokens=256) generated_ids = output_ids[:, inputs["input_ids"].shape[1]:] print(processor.decode(generated_ids, return_format="transcription_only")[0]) ``` ### バッチ推論 listのオーディオを渡すことでバッチ推論が可能であり、指定された場合はlistの言語および/またはプロンプトも渡すことができます。 ```python from transformers import AutoProcessor, AutoModelForMultimodalLM model_id = "Qwen/Qwen3-ASR-1.7B-hf" audio = [ "https://huggingface.co/datasets/bezzam/audio_samples/resolve/main/librispeech_mr_quilter.wav", "https://huggingface.co/datasets/hf-internal-testing/dummy-audio-samples/resolve/main/mandarin_voxcpm_zh.wav", ] processor = AutoProcessor.from_pretrained(model_id) model = AutoModelForMultimodalLM.from_pretrained(model_id, device_map="auto") inputs = processor.apply_transcription_request( audio, prompt=["Vocabulary: Quilter, apostle, gospel.", None], language=[None, "zh"], # language codes ("zh") and full names ("Chinese") are both accepted ).to(model.device, model.dtype) output_ids = model.generate(**inputs, max_new_tokens=256) generated_ids = output_ids[:, inputs["input_ids"].shape[1]:] transcriptions = processor.decode(generated_ids, return_format="transcription_only") for i, text in enumerate(transcriptions): print(f"Audio {i + 1}: {text}") ``` ### チャットテンプレート Qwen3 ASR はチャットテンプレート形式の入力も受け入れます。上記の [上記](#simple-transcription) に示された `apply_transcription_request` の使い方は、`apply_chat_template` のための簡便なラッパーです。 *プリフィル*によってアシスタントのターンを`language `で事前入力し、`continue_final_message=True`を渡すことで、チャットテンプレートを通じて言語を強制指定できます。`apply_transcription_request`は内部でこの処理を行っています。なお、言語を強制指定する場合は、バッチ内のすべての音声に対してプリフィルを設定する必要があります（以下に示すように）。 ```python from transformers import AutoProcessor, Qwen3ASRForConditionalGeneration model_id = "Qwen/Qwen3-ASR-1.7B-hf" processor = AutoProcessor.from_pretrained(model_id) model = Qwen3ASRForConditionalGeneration.from_pretrained(model_id, device_map="auto") chat_template = [ [ # Context/hotwords as system message {"role": "system", "content": [{"type": "text", "text": "Vocabulary: Quilter, apostle, gospel."}]}, { "role": "user", "content": [ { "type": "audio", "path": "https://huggingface.co/datasets/bezzam/audio_samples/resolve/main/librispeech_mr_quilter.wav", }, ], }, # empty prefill since forcing language in the other sample {"role": "assistant", "content": [{"type": "text", "text": ""}]}, ], [ { "role": "user", "content": [ { "type": "audio", "path": "https://huggingface.co/datasets/hf-internal-testing/dummy-audio-samples/resolve/main/mandarin_voxcpm_zh.wav", }, ], }, {"role": "assistant", "content": [{"type": "text", "text": "language Chinese"}]}, ], ] inputs = processor.apply_chat_template( chat_template, tokenize=True, return_dict=True, continue_final_message=True, ).to(model.device, model.dtype) output_ids = model.generate(**inputs, max_new_tokens=256) generated_ids = output_ids[:, inputs["input_ids"].shape[1]:] transcriptions = processor.decode(generated_ids, return_format="transcription_only") for text in transcriptions: print(text) ``` ### トレーニング `transcription` を指定して、損失の計算に使用する`labels` を取得するために、ターゲットの文字起こしを`apply_transcription_request` に渡します。 ```python from datasets import Audio, load_dataset from transformers import AutoProcessor, Qwen3ASRForConditionalGeneration model_id = "Qwen/Qwen3-ASR-1.7B-hf" NUM_SAMPLES = 2 processor = AutoProcessor.from_pretrained(model_id) model = Qwen3ASRForConditionalGeneration.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() ``` ### 強制アライメント（単語レベルのタイムスタンプ） `Qwen3ASRForTokenClassification` を使用して、文字起こし結果から単語単位のタイムスタンプを取得します。まず ASR モデルで文字起こしを行い、その後、フォースドアライナーでアラインメントを実行します。 サポートされている言語は以下の通りです：中国語（zh）、英語（en）、広東語（yue）、フランス語（fr）、ドイツ語（de）、イタリア語（it）、日本語（ja）、韓国語（ko）、ポルトガル語（pt）、ロシア語（ru）、スペイン語（es）。 日本語には`nagisa`ライブラリ、韓国語には`soynlp`ライブラリが必要です: ``` pip install nagisa soynlp ``` #### Qwen3 ASR を使用して ```python import torch from transformers import AutoProcessor, AutoModelForMultimodalLM, AutoModelForTokenClassification asr_model_id = "Qwen/Qwen3-ASR-0.6B-hf" aligner_model_id = "Qwen/Qwen3-ForcedAligner-0.6B-hf" asr_processor = AutoProcessor.from_pretrained(asr_model_id) asr_model = AutoModelForMultimodalLM.from_pretrained(asr_model_id, device_map="auto") aligner_processor = AutoProcessor.from_pretrained(aligner_model_id) aligner_model = AutoModelForTokenClassification.from_pretrained( aligner_model_id, dtype=torch.bfloat16, device_map="auto" ) audio_url = "https://huggingface.co/datasets/bezzam/audio_samples/resolve/main/librispeech_mr_quilter.wav" # Step 1: Transcribe inputs = asr_processor.apply_transcription_request(audio=audio_url) inputs = inputs.to(asr_model.device, asr_model.dtype) output_ids = asr_model.generate(**inputs, max_new_tokens=256) generated_ids = output_ids[:, inputs["input_ids"].shape[1]:] parsed = asr_processor.decode(generated_ids, return_format="parsed")[0] transcript = parsed["transcription"] language = parsed["language"] or "English" # Step 2: Prepare alignment inputs aligner_inputs, word_lists = aligner_processor.prepare_forced_aligner_inputs( audio=audio_url, transcript=transcript, language=language, ) aligner_inputs = aligner_inputs.to(aligner_model.device, aligner_model.dtype) # Step 3: Run forced aligner with torch.inference_mode(): outputs = aligner_model(**aligner_inputs) # Step 4: Decode timestamps timestamps = aligner_processor.decode_forced_alignment( logits=outputs.logits, input_ids=aligner_inputs["input_ids"], word_lists=word_lists, timestamp_token_id=aligner_model.config.timestamp_token_id, )[0] for item in timestamps: print(f"{item['text']:<20} {item['start_time']:>8.3f}s → {item['end_time']:>8.3f}s") """ Word Start (s) End (s) ------------------------------------------ Mr 0.560 0.800 Quilter 0.800 1.280 is 1.280 1.440 the 1.440 1.520 apostle 1.520 2.080 ... """ ``` #### 別のASRモデルを使用する場合 強制アライナーはモデル非依存であり、任意のASRシステムからの文字起こし結果を提供できます。以下は、文字起こしに[NVIDIA Parakeet CTC](https://huggingface.co/nvidia/parakeet-ctc-1.1b)を使用するバッチ推論の例です。 ```python import torch from datasets import Audio, load_dataset from transformers import AutoModelForCTC, AutoProcessor, AutoModelForTokenClassification parakeet_processor = AutoProcessor.from_pretrained("nvidia/parakeet-ctc-1.1b") parakeet_model = AutoModelForCTC.from_pretrained( "nvidia/parakeet-ctc-1.1b", dtype="auto", device_map="auto", ) aligner_model_id = "Qwen/Qwen3-ForcedAligner-0.6B-hf" aligner_processor = AutoProcessor.from_pretrained(aligner_model_id) aligner_model = AutoModelForTokenClassification.from_pretrained( aligner_model_id, dtype=torch.bfloat16, device_map="auto", ) ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation") ds = ds.cast_column("audio", Audio(sampling_rate=parakeet_processor.feature_extractor.sampling_rate)) audio_arrays = [ds[i]["audio"]["array"] for i in range(3)] sr = ds[0]["audio"]["sampling_rate"] # Batch transcribe with Parakeet inputs = parakeet_processor(audio_arrays, sampling_rate=sr, return_tensors="pt", padding=True).to( parakeet_model.device, dtype=parakeet_model.dtype ) with torch.inference_mode(): outputs = parakeet_model.generate(**inputs) transcripts = parakeet_processor.decode(outputs) # Batch align with Qwen3 Forced Aligner aligner_inputs, word_lists = aligner_processor.prepare_forced_aligner_inputs( audio=audio_arrays, transcript=transcripts, language="English", ) aligner_inputs = aligner_inputs.to(aligner_model.device, aligner_model.dtype) with torch.inference_mode(): aligner_outputs = aligner_model(**aligner_inputs) batch_timestamps = aligner_processor.decode_forced_alignment( logits=aligner_outputs.logits, input_ids=aligner_inputs["input_ids"], word_lists=word_lists, timestamp_token_id=aligner_model.config.timestamp_token_id, ) for i, (transcript, timestamps) in enumerate(zip(transcripts, batch_timestamps)): print(f"\n[Sample {i}] {transcript}") for item in timestamps[:5]: print(f" {item['text']:<20} {item['start_time']:>8.3f}s → {item['end_time']:>8.3f}s") if len(timestamps) > 5: print(f" ... ({len(timestamps) - 5} more words)") ``` ### Torch compile ASRモデルとforced alignerモデルの両方で、より高速な推論のために`torch.compile`をサポートしています。forced alignerは自己回帰デコーディングを伴わない単一のフォワードパスで動作するため、コンパイルとの相性が特に良好です。これにより、**大量の音声タイムスタンプ付与**に最適です。任意のASRモデルで文字起こしを行い、その後、コンパイル済みのforced alignerでバッチアラインメントを実行することで、最大のスループットを実現できます。 #### 強制アライナー A100では、バッチサイズが4の場合に約1.2倍の高速化を確認しました（[スクリプト](https://gist.github.com/ebezzam/3e0551708631784aeb684e0e838299f3#file-benchmark_compile_forced_alignment-py)）。 ```python import torch from transformers import AutoProcessor, AutoModelForTokenClassification model_id = "Qwen/Qwen3-ForcedAligner-0.6B-hf" num_warmup = 5 batch_size = 4 processor = AutoProcessor.from_pretrained(model_id) model = AutoModelForTokenClassification.from_pretrained(model_id, dtype=torch.bfloat16).to("cuda") # Prepare a batch of 4 samples audio_url = "https://huggingface.co/datasets/bezzam/audio_samples/resolve/main/librispeech_mr_quilter.wav" transcript = "Mr. Quilter is the apostle of the middle classes." aligner_inputs, word_lists = processor.prepare_forced_aligner_inputs( audio=[audio_url] * batch_size, transcript=[transcript] * batch_size, language=["English"] * batch_size, ) aligner_inputs = aligner_inputs.to(model.device, torch.bfloat16) # Warm-up and apply model model = torch.compile(model) with torch.no_grad(): for _ in range(num_warmup): _ = model(**aligner_inputs) with torch.no_grad(): _ = model(**aligner_inputs) ``` #### ASRモデル(generate) 自己回帰型文字起こしでは、`CompileConfig` オブジェクトを指定して `generate` を設定すると、`generate` 内のトークンごとのフォワードパスが `torch.compile` によって高速化されます。 A100では、バッチサイズが4の場合、約3.8倍の高速化を確認しました（[スクリプト](https://gist.github.com/ebezzam/3e0551708631784aeb684e0e838299f3#file-benchmark_compile_generate-py)）。 ```python import torch from transformers import AutoProcessor, AutoModelForMultimodalLM, CompileConfig model_id = "Qwen/Qwen3-ASR-1.7B-hf" num_warmup = 3 max_new_tokens = 256 processor = AutoProcessor.from_pretrained(model_id) model = AutoModelForMultimodalLM.from_pretrained(model_id, dtype=torch.bfloat16).to("cuda").eval() audio_url = "https://huggingface.co/datasets/bezzam/audio_samples/resolve/main/librispeech_mr_quilter.wav" inputs = processor.apply_transcription_request( audio=[audio_url] * 4, # batch of 4 ).to(model.device, torch.bfloat16) compile_config = CompileConfig() # Warmup with torch.inference_mode(): for _ in range(num_warmup): _ = model.generate( **inputs, max_new_tokens=max_new_tokens, do_sample=False, cache_implementation="static", compile_config=compile_config, ) torch.cuda.synchronize() # Apply model with torch.inference_mode(): output_ids = model.generate( **inputs, max_new_tokens=max_new_tokens, do_sample=False, cache_implementation="static", compile_config=compile_config, ) generated_ids = output_ids[:, inputs["input_ids"].shape[1] :] text_compiled = processor.decode(generated_ids, return_format="transcription_only")[0] print(f"Output: {text_compiled}") ``` ### Pipelineの使用方法 ```python from transformers import pipeline model_id = "Qwen/Qwen3-ASR-1.7B-hf" pipe = pipeline("any-to-any", model=model_id, device_map="auto") chat_template = [ { "role": "user", "content": [ { "type": "audio", "path": "https://huggingface.co/datasets/bezzam/audio_samples/resolve/main/librispeech_mr_quilter.wav", }, ], } ] outputs = pipe(text=chat_template, return_full_text=False) raw_text = outputs[0]["generated_text"] print(f"Raw: {raw_text}") # Use processor helper to extract transcription transcription = pipe.processor.extract_transcription(raw_text) print(f"Transcription: {transcription}") ``` ## Qwen3ASRConfig[[transformers.Qwen3ASRConfig]] #### transformers.Qwen3ASRConfig[[transformers.Qwen3ASRConfig]] ```python transformers.Qwen3ASRConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, audio_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, text_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, audio_token_id: int = 151676, timestamp_token_id: int = 151705, pad_token_id: int = 151645, eos_token_id: list[int] | tuple[int, ...] | int = (151643, 151645), initializer_range: float = 0.02, tie_word_embeddings: bool = True, token_classification_bias: bool = False) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/qwen3_asr/configuration_qwen3_asr.py#L73) **パラメータ:** audio_config (*Union[dict, ~configuration_utils.PreTrainedConfig]*, *optional*) : 音声バックボーンの config オブジェクトまたは辞書。 text_config (*Union[dict, ~configuration_utils.PreTrainedConfig]*, *optional*) : テキストバックボーンの config オブジェクトまたは辞書。 audio_token_id (*int*、*optional*、デフォルト値は 151676) : 音声プロンプトをエンコードするための音声トークン ID。 timestamp_token_id (*int*、*optional*、デフォルトは 151705) : トークナイザの語彙における`&lt;timestamp>`マーカーのトークン ID。これらのマーカーは、強制アライメントの入力シーケンスにおける単語境界を区切ります。 pad_token_id (*int*、*optional*、デフォルトは *151645*) : 語彙内でパディングに使用されるトークンID。 eos_token_id (*Union[list[int], tuple[int, ...], int]*、*optional*、デフォルトは *(151643, 151645)*) : 語彙内でストリームの終了に使用されるトークンID。 initializer_range (*float*、*optional*、デフォルトは *0.02*) : すべての重み行列を初期化するための truncated_normal_initializer の標準偏差です。 tie_word_embeddings (*bool*、*optional*、デフォルトは *True*) : モデルの *tied_weights_keys* マッピングに従って、重み埋め込みをタイするかどうか。 token_classification_bias (*bool*、*optional*、デフォルトはFalse) : 強制アライメント用のトークン分類ヘッドにバイアス項を含めるかどうか。 これは、Qwen3ASRModel の設定を保存するための設定クラスです。指定された引数に基づいて Qwen3 Asr モデルをインスタンス化し、モデルのアーキテクチャを定義するために使用されます。デフォルト値で設定をインスタンス化すると、[Qwen/Qwen3-ASR-1.7B-hf](https://huggingface.co/Qwen/Qwen3-ASR-1.7B-hf) と同様の設定が得られます。 設定オブジェクトは [*PreTrainedConfig*] を継承し、モデルの出力を制御するために使用できます。詳細については、[*PreTrainedConfig*] のドキュメントを参照してください。 例: ```python >>> from transformers import Qwen3ASRForConditionalGeneration, Qwen3ASRConfig >>> # Initializing a Qwen3ASR style configuration >>> configuration = Qwen3ASRConfig() >>> # Initializing a model from the configuration >>> model = Qwen3ASRForConditionalGeneration(configuration) >>> # Accessing the model configuration >>> configuration = model.config ``` ## Qwen3ASREncoderConfig[[transformers.Qwen3ASREncoderConfig]] #### transformers.Qwen3ASREncoderConfig[[transformers.Qwen3ASREncoderConfig]] ```python transformers.Qwen3ASREncoderConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, num_mel_bins: int = 128, encoder_layers: int = 24, encoder_attention_heads: int = 16, encoder_ffn_dim: int = 4096, d_model: int = 1024, dropout: float | int = 0.0, attention_dropout: float | int = 0.0, activation_function: str = 'gelu', activation_dropout: float | int = 0.0, scale_embedding: bool = False, initializer_range: float = 0.02, n_window: int = 50, output_dim: int = 3584, n_window_infer: int = 800, downsample_hidden_size: int = 480, max_position_embeddings: int = 13) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/qwen3_asr/configuration_qwen3_asr.py#L30) **パラメータ:** num_mel_bins (*int*、*optional*、デフォルトは *128*) : 入力フレームごとに使用されるメル特徴の数を指定します。*AutoFeatureExtractor* クラスで使用された値と一致させる必要があります。 encoder_layers (*int*、*optional*、デフォルトは *24*) : Transformerエンコーダーの隠れ層の数。*num_layers* が設定されていない場合、同じ値が使用されます。 encoder_attention_heads (*int*、*optional*、デフォルトは *16*) : Transformerエンコーダーの各アテンション層におけるアテンションヘッドの数。 encoder_ffn_dim (*int*、*optional*、デフォルトは *4096*) : エンコーダー内の「intermediate」（feed-forward とも呼ばれる）層の次元数。 d_model (*int*、*optional*、デフォルトは *1024*) : エンコーダ層とプーラー層のサイズ。 dropout (*Union[float, int]*、*optional*、デフォルトは *0.0*) : 全 dropout 層の比率です。 attention_dropout (*Union[float, int]*、*optional*、デフォルトは *0.0*) : 注意確率の dropout 率です。 activation_function (*str*、*optional*、デフォルトは *gelu*) : デコーダーで使用する非線形活性化関数（関数または文字列）。例えば、*"gelu"*、*"relu"*、*"silu"* など。 activation_dropout (*Union[float, int]*、*optional*、デフォルトは *0.0*) : 全結合層内の活性化の dropout 率です。 scale_embedding (*bool*、*optional*、デフォルトは *False*) : sqrt(d_model) で割ることで埋め込みをスケーリングするかどうか。 initializer_range (*float*、*optional*、デフォルトは *0.02*) : すべての重み行列を初期化するための truncated_normal_initializer の標準偏差です。 n_window (*int*、*optional*、デフォルト値は 50) : エンコーダの 1 つのチャンクに含まれる mel フレーム数の半分です。conv スタックによって処理される各チャンクには `2 * n_window` 個の mel フレームが含まれます（10 ms の hop を持つ 16 kHz の音声では 1 秒分です）。 output_dim (*int*, *optional*, デフォルトは 3584) : 出力の次元数。 n_window_infer (*int*、*optional*、デフォルトは 800) : 各アテンションウィンドウがまたぐ、mel フレーム相当の音声の長さ。`n_window * 2` の倍数でなければならず、アテンションウィンドウがエンコーダーのチャンクと整合するようになります。 downsample_hidden_size (*int*, *optional*, デフォルトは 480) : 畳み込みダウンサンプリングスタックの隠れ層サイズ。 max_position_embeddings (*int*、*optional*、デフォルトは *13*) : このモデルが使用される可能性のある最大シーケンス長です。 これは、Qwen3ASRModel の設定を保存するための設定クラスです。指定された引数に基づいて Qwen3 Asr モデルをインスタンス化し、モデルのアーキテクチャを定義するために使用されます。デフォルト値で設定をインスタンス化すると、[Qwen/Qwen3-ASR-1.7B-hf](https://huggingface.co/Qwen/Qwen3-ASR-1.7B-hf) と同様の設定が得られます。 設定オブジェクトは [*PreTrainedConfig*] を継承し、モデルの出力を制御するために使用できます。詳細については、[*PreTrainedConfig*] のドキュメントを参照してください。 ## Qwen3ASRFeatureExtractor[[transformers.Qwen3ASRFeatureExtractor]] #### transformers.Qwen3ASRFeatureExtractor[[transformers.Qwen3ASRFeatureExtractor]] ```python transformers.Qwen3ASRFeatureExtractor(feature_size = 128, sampling_rate = 16000, hop_length = 160, chunk_length = 30, n_fft = 400, padding_value = 0.0, dither = 0.0, return_attention_mask = True, n_window = 50, min_length = 8000, **kwargs) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/qwen3_asr/feature_extraction_qwen3_asr.py#L31) **パラメータ:** feature_size (*int*、*optional*、デフォルトは 128) : メルフィルタバンクの数。 sampling_rate (*int*、*optional*、デフォルトは 16000) : Hz 単位のオーディオサンプリングレート。 hop_length (*int*, *optional*, デフォルトは 160) : Mel 周波数係数を取得するために使用される STFT の重複ウィンドウの長さ。 chunk_length (*int*、*optional*、デフォルトは 30) : `padding="max_length"` の場合、トリム/パディングに使用する最大音声長（秒）。 n_fft (*int*, *optional*, デフォルトは 400) : フーリエ変換のサイズ。 padding_value (*float*、*optional*、デフォルト値は 0.0) : 生オーディオをパディングするために使用されるパディング値。 dither (*float*、*optional*、デフォルト値は 0.0) : 0 以外の場合、各 STFT フレームにガウスノイズ (*std = dither*) を加えます。 return_attention_mask (*bool*、*optional*、デフォルトは *True*) : パディングされたメルフレームに対応するアテンションマスクを返すかどうか。 n_window (*int*、*optional*、デフォルト値は 50) : パディングに使用される mel フレームのチャンクサイズの半分。log-mel 時間軸は、`2 * n_window` の倍数になるように右パディングされます。 min_length (*int*、*optional*、デフォルト値は 8000) : 各オーディオクリップの最小サンプル数。この値より短いクリップはゼロパディングされ、元の Qwen3-ASR ライブラリの動作と一致します。 Qwen3 ASR の特徴抽出器を構築します。 生の音声から128ビンのlog-mel特徴量を抽出し、melの時間軸を`2 * n_window`の倍数になるよう右パディングします。 #### __call__[[transformers.Qwen3ASRFeatureExtractor.__call__]] ```python __call__(raw_speech: numpy.ndarray | list[float] | list[numpy.ndarray] | list[list[float]], truncation: bool = False, pad_to_multiple_of: int | None = None, return_tensors: str | None = 'pt', return_attention_mask: bool | None = None, padding: str | None = 'max_length', max_length: int | None = None, sampling_rate: int | None = None, n_window: int | None = None, device: str | None = 'cpu', **kwargs) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/qwen3_asr/feature_extraction_qwen3_asr.py#L129) **パラメータ:** raw_speech (*np.ndarray*、*list[float]*、*list[np.ndarray]*、*list[list[float]]*) : パディング対象のシーケンスまたはシーケンスのバッチです。モノラル音声のみ対応しています。 pad_to_multiple_of (*int*, *optional*) : 設定されている場合、生オーディオをこの値（サンプル数）の倍数にパディングします。`n_window`とは異なり、これはメルフレーム軸に適用されます。 n_window (*int*, *optional*) : この呼び出しにおいて、インスタンスの`n_window`をオーバーライドします。mel軸は`2 * n_window`の倍数にパディングされます。mel軸のパディングを完全にスキップするには`0`を設定します。 device (*str*、*optional*、デフォルトは *"cpu"*) : log-mel スペクトログラムの計算に使用されるデバイス。 1つ以上のオーディオシーケンスからlog-mel特徴量を準備します。 ## Qwen3ASRProcessor[[transformers.Qwen3ASRProcessor]] #### transformers.Qwen3ASRProcessor[[transformers.Qwen3ASRProcessor]] ```python transformers.Qwen3ASRProcessor(feature_extractor = None, tokenizer = None, chat_template = None, timestamp_segment_time: float = 80) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/qwen3_asr/processing_qwen3_asr.py#L349) **パラメータ:** feature_extractor (`Qwen3ASRFeatureExtractor`) : 特徴抽出器は必須の入力です。 tokenizer (`Qwen2Tokenizer`) : トークナイザーは必須の入力です。 chat_template (`str`) : チャット内のメッセージのリストをトークン化可能な文字列に変換するための Jinja テンプレート。 timestamp_segment_time (`float`, *optional*) : タイムスタンプクラスあたりのミリ秒数。デフォルトは 80 ms です。 Qwen3ASRProcessor を構築します。このクラスは、feature extractor と tokenizer を単一の processor にラップします。 [Qwen3ASRProcessor](/docs/transformers/main/ja/model_doc/qwen3_asr#transformers.Qwen3ASRProcessor) は、[Qwen3ASRFeatureExtractor](/docs/transformers/main/ja/model_doc/qwen3_asr#transformers.Qwen3ASRFeatureExtractor) と [Qwen2Tokenizer](/docs/transformers/main/ja/model_doc/qwen2#transformers.Qwen2Tokenizer) のすべての機能を提供します。詳細については、[~Qwen3ASRFeatureExtractor](/docs/transformers/main/ja/model_doc/qwen3_asr#transformers.Qwen3ASRFeatureExtractor) および [~Qwen2Tokenizer](/docs/transformers/main/ja/model_doc/qwen2#transformers.Qwen2Tokenizer) を参照してください。 #### __call__[[transformers.Qwen3ASRProcessor.__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']], output_labels: bool | None = False, **kwargs: *) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/qwen3_asr/processing_qwen3_asr.py#L372) **パラメータ:** 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.Qwen3ASRProcessor.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, transcription: str | list[str] | None = None, tokenize: bool = True, **kwargs: *) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/qwen3_asr/processing_qwen3_asr.py#L440) **パラメータ:** audio (*AudioInput* または *list[AudioInput]*) : 文字起こしを行う音声。URL 文字列、ローカルパス、numpy 配列、またはこれらのリストを指定できます。 language (*str* または *list[str]*、*optional*) : 文字起こしで強制する言語。正式名称（例: `"English"`、`"Chinese"`）または ISO コード（例: `"en"`、`"zh"`）を受け取ります。リストの場合、オーディオバッチの長さと一致する必要があります。元の実装に従い、生成プロンプトの後に `language &lt;NAME>&lt;asr_text>` を追加することで言語を強制し、モデルは文字起こしテキストのみを生成します。`None` の場合、モデルは自動言語検出を実行し、`language &lt;NAME>&lt;asr_text>...` を自身で出力します。 prompt (*str* または *list[str]*、*optional*) : システムプロンプトとして含めるコンテキストやホットワードです。例えば、転写を特定の方向に誘導するためのドメイン固有の単語やフレーズなどが挙げられます。リストの場合、オーディオバッチの長さと一致する必要があります。*None* の場合、システムプロンプトは空のままになります。 transcription (*str* または *list[str]*、*任意*) : 学習用のターゲット文字起こし。1 つの音声につき 1 つです。指定された場合、各文字起こしはアシスタントのターンとして書き込まれ、*labels* が返されます（[*~Qwen3ASRProcessor.__call__*] の *output_labels* を参照）。*language* が指定されている場合、モデルの出力形式に合わせるため、文字起こしには `language &lt;NAME>&lt;asr_text>` というプレフィックスが付与されます。指定されていない場合は、そのまま書き込まれるため、事前学習時の挙動を維持するには、すでにその形式である必要があります。 tokenize (*bool*、*optional*、デフォルトは *True*) : プロンプトをトークナイズし、オーディオを処理するかどうか。*False* の場合、オーディオは読み込まれず、プロンプトは展開されていないオーディオプレースホルダーを含む文字列として返されます。これらをオーディオとともにプロセッサに渡す *processor(text=prompts, audio=audio)* とすると、*tokenize=True* と同じ出力が得られます。 - ****kwargs** : [*~Qwen3ASRProcessor.apply_chat_template*] に転送される追加のキーワード引数。プロセッサの引数（*text_kwargs*、*audio_kwargs* など）は、*processor_kwargs=&lcub;...}* として渡す必要があります。 **戻り値:** [*BatchFeature*] または *list[str]* *tokenize=False* の場合は 1 つのオーディオにつき 1 つのプロンプトが出力され、それ以外の場合は [*Qwen3ASRForConditionalGeneration.generate*] に渡す準備が整った出力、または *transcription* が指定されている場合は損失を計算するために [*Qwen3ASRForConditionalGeneration.forward*] に渡す準備が整った出力が、プロセッサから返されます。 手動でチャットテンプレートを書かずに、推論用、または*transcription*が指定されている場合は学習用に、自動音声認識の入力を準備します。 #### prepare_forced_aligner_inputs[[transformers.Qwen3ASRProcessor.prepare_forced_aligner_inputs]] ```python prepare_forced_aligner_inputs(audio: typing.Union[numpy.ndarray, ForwardRef('torch.Tensor'), collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence['torch.Tensor']], transcript: str | list[str], language: str | list[str] | None = None, **kwargs) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/qwen3_asr/processing_qwen3_asr.py#L662) **パラメータ:** audio (*AudioInput*) : 音声入力。パス、URL、NumPy配列、またはこれらのリストを受け入れます。 transcript (*str* または *list[str]*) : 音声にアラインするトランスクリプト。 language (*str*、*list[str]*、または *None*、*任意*) : 言語のヒント。現在、トークナイゼーションでは使用されていませんが、言語固有のトークナイザー（例：日本語、韓国語）のために予約されています。 - ****kwargs** : [*~Qwen3ASRProcessor.apply_chat_template*] に転送される追加のキーワード引数。 **戻り値:** *tuple[BatchFeature, list[list[str]]]* - `inputs`: 強制アライナーモデル用に準備された`input_ids`、`attention_mask`、`input_features`、`input_features_mask`を含む[*BatchFeature*]。 - `word_lists`: 入力の構築に使用される単語レベルのトークンリストのリスト（サンプルごとに1つ）。タイムスタンプを単語と対応付けるには、これらを[*~Qwen3ASRProcessor.decode_forced_alignment*]に渡します。 強制アライナーモデルの入力を準備します。 #### decode_forced_alignment[[transformers.Qwen3ASRProcessor.decode_forced_alignment]] ```python decode_forced_alignment(logits, input_ids, word_lists: list, timestamp_token_id: int, timestamp_segment_time: float | None = None) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/qwen3_asr/processing_qwen3_asr.py#L735) **パラメータ:** logits (*torch.Tensor*、形状 *(batch_size, seq_len, num_labels)*) : [*Qwen3ASRForTokenClassification*] からの分類ロジスト。 input_ids (*torch.LongTensor*、形状 *(batch_size, seq_len)*) : 前向きパスで使用される入力トークンID。 word_lists (*list[list[str]]*) : [*~Qwen3ASRProcessor.prepare_forced_aligner_inputs*] が返す単語レベルのトークンリストです。 timestamp_token_id (*int*) : `&lt;timestamp>`マーカーのトークンID(`model.config.timestamp_token_id`から取得)。 timestamp_segment_time (*float*, *optional*) : タイムスタンプクラスあたりのミリ秒数。指定されない場合、*self.timestamp_segment_time*が使用されます。 **戻り値:** *list[list[dict]]* サンプルごとに1つのリスト。各内側のリストには、キー`"text"` (*str*)、`"start_time"` (*float*、秒)、および`"end_time"` (*float*、秒) を持つ辞書が含まれます。 強制アライナーモデルの出力を単語レベルのタイムスタンプにデコードします。 #### decode[[transformers.Qwen3ASRProcessor.decode]] ```python decode(*args, return_format = 'raw', **kwargs) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/qwen3_asr/processing_qwen3_asr.py#L528) **パラメータ:** return_format (*str*、*optional*、デフォルトは *"raw"*) : オプション: - `"raw"`: トークナイザーから生（raw）のデコード済み文字列を返します。 - `"parsed"`: `"language"` と `"transcription"` キーを持つ dict（または dict のリスト）を返します。 - `"transcription_only"`: 転写されたテキストのみ（`&lt;asr_text>` の後）を抽出します。 `skip_special_tokens` は `"parsed"` および `"transcription_only"` の場合、`True` に固定されます。 トークナイザーのdecodeに引数を転送し、必要に応じてASRの出力を解析します。 Qwen3 ASRは、`language &lt;LANG>&lt;asr_text>transcribed text`という形式で文字起こしを出力します。 ## Qwen3ASREncoder[[transformers.Qwen3ASREncoder]] #### transformers.Qwen3ASREncoder[[transformers.Qwen3ASREncoder]] ```python transformers.Qwen3ASREncoder(config: Qwen3ASREncoderConfig) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/qwen3_asr/modeling_qwen3_asr.py#L328) **パラメータ:** config ([Qwen3ASREncoderConfig](/docs/transformers/main/ja/model_doc/qwen3_asr#transformers.Qwen3ASREncoderConfig)) : モデルのパラメータをすべて含むモデル設定クラスです。設定ファイルで初期化しても、モデルに関連する重みは読み込まれず、設定のみが読み込まれます。モデルの重みをロードするには、[from_pretrained()](/docs/transformers/main/ja/main_classes/model#transformers.PreTrainedModel.from_pretrained) メソッドを確認してください。 ヘッドや投影が一切付加されていない Qwen3 ASR の音声モデルです。 このモデルは [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.Qwen3ASREncoder.forward]] ```python forward(input_features: Tensor, input_features_mask: Tensor, **kwargs) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/qwen3_asr/modeling_qwen3_asr.py#L372) **パラメータ:** input_features (`torch.Tensor`、形状 `(batch_size, sequence_length, feature_dim)`) : 入力音声特徴に対応するテンソルです。音声特徴は [Qwen3ASRFeatureExtractor](/docs/transformers/main/ja/model_doc/qwen3_asr#transformers.Qwen3ASRFeatureExtractor) を使用して取得できます。詳細は [Qwen3ASRFeatureExtractor.__call__()](/docs/transformers/main/ja/model_doc/qwen3_asr#transformers.Qwen3ASRFeatureExtractor.__call__) を参照してください（[Qwen3ASRProcessor](/docs/transformers/main/ja/model_doc/qwen3_asr#transformers.Qwen3ASRProcessor) は音声の処理に [Qwen3ASRFeatureExtractor](/docs/transformers/main/ja/model_doc/qwen3_asr#transformers.Qwen3ASRFeatureExtractor) を使用します）。 input_features_mask (`torch.LongTensor`、shape `(batch_size, padded_feature_length)`) : 有効な mel フレームには 1、パディングには 0。 **戻り値:** [BaseModelOutputWithPooling](/docs/transformers/main/ja/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) または `tuple(torch.Tensor)` `torch.Tensor` のタプル（`return_dict=False` が渡された場合、または `config.return_dict=False` の場合）または [BaseModelOutputWithPooling](/docs/transformers/main/ja/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling)。設定（[Qwen3ASRConfig](/docs/transformers/main/ja/model_doc/qwen3_asr#transformers.Qwen3ASRConfig)）と入力に応じて、さまざまな要素で構成されます。 [Qwen3ASREncoder](/docs/transformers/main/ja/model_doc/qwen3_asr#transformers.Qwen3ASREncoder)のforwardメソッドは、`__call__`特殊メソッドをオーバーライドします。 この関数内でフォワードパスの手順を定義する必要がありますが、その後、この関数ではなく`Module`インスタンスを呼び出すべきです。前者は前処理と後処理の実行を適切に処理するのに対し、後者はそれらを無視してしまいます。 - **last_hidden_state** (`torch.Tensor`、形状 `(batch_size, sequence_length, hidden_size)`) -- モデルの最終層の出力における隠れ状態のシーケンス。 - **pooler_output** (`torch.Tensor`、形状 `(batch_size, hidden_size)`) -- 補助的な事前学習タスクに使用される層をさらに通して処理された後、シーケンスの最初のトークン（分類トークン）の最終層の隠れ状態です。例えば、BERT系のモデルでは、線形層とtanh活性化関数を経て処理された後の分類トークンを返します。この線形層の重みは、事前学習中の次の文予測（分類）目的から学習されます。 - **hidden_states** (`tuple(torch.Tensor)`、*optional*、`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)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) -- `torch.Tensor` のタプル（各レイヤーごとに1つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)`。 アテンションのsoftmax後のアテンション重み。自己アテンションヘッド内で加重平均を計算するために使用されます。 ## Qwen3ASRModel[[transformers.Qwen3ASRModel]] #### transformers.Qwen3ASRModel[[transformers.Qwen3ASRModel]] ```python transformers.Qwen3ASRModel(config: Qwen3ASRConfig) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/qwen3_asr/modeling_qwen3_asr.py#L474) **パラメータ:** config ([Qwen3ASRConfig](/docs/transformers/main/ja/model_doc/qwen3_asr#transformers.Qwen3ASRConfig)) : モデルのすべてのパラメータを含むモデル設定クラスです。設定ファイルで初期化しても、モデルに関連する重みは読み込まれず、設定のみが読み込まれます。モデルの重みをロードするには、[from_pretrained()](/docs/transformers/main/ja/main_classes/model#transformers.PreTrainedModel.from_pretrained) メソッドを確認してください。 Qwen3ASRモデル（ファインチューニング済みのWhisperエンコーダー、マルチモーダルプロジェクター、Qwen2言語モデル）で、言語モデリングヘッドは含まれません。 このモデルは [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.Qwen3ASRModel.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: *) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/qwen3_asr/modeling_qwen3_asr.py#L532) **パラメータ:** 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.Tensor`、形状 `(batch_size, sequence_length, feature_dim)`、*任意*) : 入力音声特徴に対応するテンソルです。音声特徴は [Qwen3ASRFeatureExtractor](/docs/transformers/main/ja/model_doc/qwen3_asr#transformers.Qwen3ASRFeatureExtractor) を使用して取得できます。詳細は [Qwen3ASRFeatureExtractor.__call__()](/docs/transformers/main/ja/model_doc/qwen3_asr#transformers.Qwen3ASRFeatureExtractor.__call__) を参照してください（[Qwen3ASRProcessor](/docs/transformers/main/ja/model_doc/qwen3_asr#transformers.Qwen3ASRProcessor) は音声の処理に [Qwen3ASRFeatureExtractor](/docs/transformers/main/ja/model_doc/qwen3_asr#transformers.Qwen3ASRFeatureExtractor) を使用します）。 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.Tensor`、shape `(batch_size, sequence_length, hidden_size)`、*任意*) : `input_ids` を渡す代わりに、埋め込み表現を直接渡すこともできます。これは、モデル内部の埋め込み参照行列よりも、`input_ids` のインデックスを対応するベクトルに変換する方法をより細かく制御したい場合に有用です。 use_cache (`bool`, *任意*) : `True`に設定すると、`past_key_values`のキーバリュー状態が返され、デコーディングの高速化に利用できます（`past_key_values`を参照）。 **戻り値:** `Qwen3ASRModelOutputWithPast` または `tuple(torch.Tensor)` `Qwen3ASRModelOutputWithPast` または、`return_dict=False` が渡された場合、または `config.return_dict=False` の場合、`torch.Tensor` のタプル。構成（[Qwen3ASRConfig](/docs/transformers/main/ja/model_doc/qwen3_asr#transformers.Qwen3ASRConfig)）や入力に応じて、さまざまな要素で構成されます。 [Qwen3ASRModel](/docs/transformers/main/ja/model_doc/qwen3_asr#transformers.Qwen3ASRModel)のforwardメソッドは、`__call__`特殊メソッドをオーバーライドします。 この関数内でフォワードパスの手順を定義する必要がありますが、その後、この関数ではなく`Module`インスタンスを呼び出すべきです。前者は前処理と後処理の実行を適切に処理するのに対し、後者はそれらを無視してしまいます。 - **audio_hidden_states** (`torch.Tensor`、*任意*) -- 投影されたオーディオの隠れ状態。 #### get_audio_features[[transformers.Qwen3ASRModel.get_audio_features]] ```python get_audio_features(input_features: Tensor, input_features_mask: LongTensor, **kwargs: *) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/qwen3_asr/modeling_qwen3_asr.py#L486) **パラメータ:** input_features (`torch.Tensor`、形状 `(batch_size, sequence_length, feature_dim)`) : 入力音声特徴に対応するテンソルです。音声特徴は [Qwen3ASRFeatureExtractor](/docs/transformers/main/ja/model_doc/qwen3_asr#transformers.Qwen3ASRFeatureExtractor) を使用して取得できます。詳細は [Qwen3ASRFeatureExtractor.__call__()](/docs/transformers/main/ja/model_doc/qwen3_asr#transformers.Qwen3ASRFeatureExtractor.__call__) を参照してください（[Qwen3ASRProcessor](/docs/transformers/main/ja/model_doc/qwen3_asr#transformers.Qwen3ASRProcessor) は音声の処理に [Qwen3ASRFeatureExtractor](/docs/transformers/main/ja/model_doc/qwen3_asr#transformers.Qwen3ASRFeatureExtractor) を使用します）。 input_features_mask (`torch.LongTensor`、shape `(batch_size, padded_feature_length)`) : 有効な mel フレームには 1、パディングには 0。 **戻り値:** [BaseModelOutputWithPooling](/docs/transformers/main/ja/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) または `tuple(torch.Tensor)` `torch.Tensor` のタプル（`return_dict=False` が渡された場合、または `config.return_dict=False` の場合）または [BaseModelOutputWithPooling](/docs/transformers/main/ja/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling)。設定（[Qwen3ASRConfig](/docs/transformers/main/ja/model_doc/qwen3_asr#transformers.Qwen3ASRConfig)）と入力に応じて、さまざまな要素で構成されます。 このメソッドは、入力特徴量（ログメルスペクトログラム）から音声埋め込みを取得するために使用されます。 - **last_hidden_state** (`torch.Tensor`、形状 `(batch_size, sequence_length, hidden_size)`) -- モデルの最終層の出力における隠れ状態のシーケンス。 - **pooler_output** (`torch.Tensor`、形状 `(batch_size, hidden_size)`) -- 補助的な事前学習タスクに使用される層をさらに通して処理された後、シーケンスの最初のトークン（分類トークン）の最終層の隠れ状態です。例えば、BERT系のモデルでは、線形層とtanh活性化関数を経て処理された後の分類トークンを返します。この線形層の重みは、事前学習中の次の文予測（分類）目的から学習されます。 - **hidden_states** (`tuple(torch.Tensor)`、*optional*、`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)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) -- `torch.Tensor` のタプル（各レイヤーごとに1つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)`。 アテンションのsoftmax後のアテンション重み。自己アテンションヘッド内で加重平均を計算するために使用されます。 #### get_placeholder_mask[[transformers.Qwen3ASRModel.get_placeholder_mask]] ```python get_placeholder_mask(input_ids: LongTensor, inputs_embeds: Tensor, audio_features: Tensor) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/qwen3_asr/modeling_qwen3_asr.py#L508) `input_ids`または`inputs_embeds`からマルチモーダルのプレースホルダーマスクを取得し、プレースホルダートークンの数がマルチモーダル機能の長さと等しいことを確認します。長さが異なる場合、エラーが発生します。 ## Qwen3ASRForConditionalGeneration[[transformers.Qwen3ASRForConditionalGeneration]] #### transformers.Qwen3ASRForConditionalGeneration[[transformers.Qwen3ASRForConditionalGeneration]] ```python transformers.Qwen3ASRForConditionalGeneration(config: Qwen3ASRConfig) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/qwen3_asr/modeling_qwen3_asr.py#L614) **パラメータ:** config ([Qwen3ASRConfig](/docs/transformers/main/ja/model_doc/qwen3_asr#transformers.Qwen3ASRConfig)) : モデルのすべてのパラメータを含むモデル設定クラスです。設定ファイルで初期化しても、モデルに関連する重みは読み込まれず、設定のみが読み込まれます。モデルの重みをロードするには、[from_pretrained()](/docs/transformers/main/ja/main_classes/model#transformers.PreTrainedModel.from_pretrained) メソッドを確認してください。 音声エンコーダーと言語モデルで構成されるQwen3ASRモデル。 このモデルは [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.Qwen3ASRForConditionalGeneration.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: *) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/qwen3_asr/modeling_qwen3_asr.py#L627) **パラメータ:** 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.Tensor`、形状 `(batch_size, sequence_length, feature_dim)`、*任意*) : 入力音声特徴に対応するテンソルです。音声特徴は [Qwen3ASRFeatureExtractor](/docs/transformers/main/ja/model_doc/qwen3_asr#transformers.Qwen3ASRFeatureExtractor) を使用して取得できます。詳細は [Qwen3ASRFeatureExtractor.__call__()](/docs/transformers/main/ja/model_doc/qwen3_asr#transformers.Qwen3ASRFeatureExtractor.__call__) を参照してください（[Qwen3ASRProcessor](/docs/transformers/main/ja/model_doc/qwen3_asr#transformers.Qwen3ASRProcessor) は音声の処理に [Qwen3ASRFeatureExtractor](/docs/transformers/main/ja/model_doc/qwen3_asr#transformers.Qwen3ASRFeatureExtractor) を使用します）。 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.Tensor`、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 次元である必要があります。これは、パックされたテンソル形式（バッチとシーケンス長を単一の次元にまとめる形式）を使用する場合に有用です。 **戻り値:** `Qwen3ASRCausalLMOutputWithPast` または `tuple(torch.Tensor)` `Qwen3ASRCausalLMOutputWithPast` または、`return_dict=False` が渡された場合、または `config.return_dict=False` の場合、`torch.Tensor` のタプル。構成（[Qwen3ASRConfig](/docs/transformers/main/ja/model_doc/qwen3_asr#transformers.Qwen3ASRConfig)）や入力に応じて、さまざまな要素で構成されます。 [Qwen3ASRForConditionalGeneration](/docs/transformers/main/ja/model_doc/qwen3_asr#transformers.Qwen3ASRForConditionalGeneration)のforwardメソッドは、`__call__`特殊メソッドをオーバーライドします。 この関数内でフォワードパスの手順を定義する必要がありますが、その後、この関数ではなく`Module`インスタンスを呼び出すべきです。前者は前処理と後処理の実行を適切に処理するのに対し、後者はそれらを無視してしまいます。 - **loss** (`torch.Tensor`、形状 `(1,)`、*任意*、`labels` が指定された場合に返されます) -- 言語モデリングの損失(次のトークンの予測用)。 - **logits** (`torch.Tensor`、形状 `(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.Tensor]`、*optional*、`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]`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) -- `torch.Tensor` のタプル（各レイヤーごとに1つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)`。 アテンションのsoftmax後のアテンション重み。自己アテンションヘッド内で加重平均を計算するために使用されます。 - **audio_hidden_states** (`torch.Tensor`, *オプション*) -- 投影後のオーディオエンコーダーの隠れ状態。 例: ```python >>> from transformers import Qwen3ASRForConditionalGeneration, AutoProcessor >>> model_id = "Qwen/Qwen3-ASR-1.7B-hf" >>> processor = AutoProcessor.from_pretrained(model_id) >>> model = Qwen3ASRForConditionalGeneration.from_pretrained(model_id, device_map="auto") ``` #### get_audio_features[[transformers.Qwen3ASRForConditionalGeneration.get_audio_features]] ```python get_audio_features(input_features, input_features_mask, **kwargs) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/qwen3_asr/modeling_qwen3_asr.py#L624) ## Qwen3ASRForTokenClassification[[transformers.Qwen3ASRForTokenClassification]] #### transformers.Qwen3ASRForTokenClassification[[transformers.Qwen3ASRForTokenClassification]] ```python transformers.Qwen3ASRForTokenClassification(config) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/qwen3_asr/modeling_qwen3_asr.py#L695) **パラメータ:** config ([`[``GenericForTokenClassification``]`]) : モデルのパラメータをすべて含むモデル設定クラスです。設定ファイルで初期化しても、モデルに関連する重みは読み込まれず、設定のみが読み込まれます。モデルの重みをロードするには、[from_pretrained()](/docs/transformers/main/ja/main_classes/model#transformers.PreTrainedModel.from_pretrained)メソッドを参照してください。 タイムスタンプ予測（強制アライメント）用のトークン分類ヘッドを備えた Qwen3 ASR モデル。 このモデルは [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.Qwen3ASRForTokenClassification.forward]] ```python forward(input_ids: torch.LongTensor | None = None, attention_mask: torch.Tensor | None = None, position_ids: torch.LongTensor | None = None, past_key_values: Cache | None = None, inputs_embeds: torch.Tensor | None = None, labels: torch.LongTensor | None = None, use_cache: bool | None = None, **kwargs: Unpack[TransformersKwargs]) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_layers.py#L275) **パラメータ:** 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) 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`, *任意*) : 逐次デコードを高速化するために使用できる、事前計算された隠れ状態（自己アテンションブロックおよびクロスアテンションブロック内のキーとバリュー）です。通常、`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)`）の代わりに、このモデルに過去のキーバリュー状態が与えられていない未処理の `input_ids`（形状 `(batch_size, unprocessed_length)`）のみを入力する必要があります。 inputs_embeds (`torch.Tensor`、shape `(batch_size, sequence_length, hidden_size)`、*任意*) : `input_ids` を渡す代わりに、埋め込み表現を直接渡すこともできます。これは、モデル内部の埋め込み参照行列よりも、`input_ids` のインデックスを対応するベクトルに変換する方法をより細かく制御したい場合に有用です。 labels (`torch.LongTensor`、shape `(batch_size, sequence_length)`、*optional*) : トークン分類損失を計算するためのラベル。インデックスは `[0, ..., config.num_labels - 1]` の範囲である必要があります。 use_cache (`bool`, *任意*) : `True`に設定すると、`past_key_values`のキーバリュー状態が返され、デコーディングの高速化に利用できます（`past_key_values`を参照）。 **戻り値:** `TokenClassifierOutput` `GenericForTokenClassification`のforwardメソッドは、`__call__`特殊メソッドをオーバーライドします。 この関数内でフォワードパスの手順を定義する必要がありますが、その後、この関数ではなく`Module`インスタンスを呼び出すべきです。前者は前処理と後処理の実行を適切に処理するのに対し、後者はそれらを無視してしまいます。