# Whisper [Whisper](https://huggingface.co/papers/2212.04356)は、68万時間のラベル付き音声データで事前学習されたエンコーダー・デコーダー（シーケンス・ツー・シーケンス）型Transformerです。この規模の事前学習データにより、英語をはじめとする多くの言語の音声タスクにおいて、ゼロショットでの性能を発揮できます。デコーダーにより、Whisperは追加のファインチューニングなしで、エンコーダーが学習した音声表現をテキストなどの有用な出力に変換できます。Whisperはそのままの状態で動作します。 すべてのオリジナルのWhisperチェックポイントは、[Whisper](https://huggingface.co/collections/openai/whisper-release-6501bba2cf999715fd953013)コレクション内で確認できます。 > [!TIP] > Whisperをさまざまな音声タスクに適用する方法の例については、右側のサイドバーにあるWhisperモデルをクリックしてください。 > > `use_kernels=True` を [from_pretrained()](/docs/transformers/v5.23.0/ja/main_classes/model#transformers.PreTrainedModel.from_pretrained) に設定すると、対応するレイヤーが Hub からの最適化されたカーネルに置き換えられます。詳細は [カーネルの読み込み](../kernel_doc/loading_kernels) を参照してください。 以下の例では、[Pipeline](/docs/transformers/v5.23.0/ja/main_classes/pipelines#transformers.Pipeline)または[AutoModel](/docs/transformers/v5.23.0/ja/model_doc/auto#transformers.AutoModel)クラスを使用して、音声からテキストへ自動的に書き起こす方法を示しています。 ```python from transformers import pipeline pipeline = pipeline( task="automatic-speech-recognition", model="openai/whisper-large-v3-turbo", device=0 ) pipeline("https://huggingface.co/datasets/Narsil/asr_dummy/resolve/main/mlk.flac") ``` ```python # pip install datasets from datasets import load_dataset from transformers import AutoProcessor, WhisperForConditionalGeneration processor = AutoProcessor.from_pretrained( "openai/whisper-large-v3-turbo", ) model = WhisperForConditionalGeneration.from_pretrained( "openai/whisper-large-v3-turbo", device_map="auto", attn_implementation="sdpa" ) ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation") audio_sample = ds[0]["audio"] input_features = processor( audio_sample["array"], sampling_rate=audio_sample["sampling_rate"], return_tensors="pt" ).input_features input_features = input_features.to(model.device, dtype=model.dtype) predicted_ids = model.generate(input_features, cache_implementation="static") transcription = processor.batch_decode(predicted_ids, skip_special_tokens=True) transcription[0] ``` ## 注記 - Whisper は推論にカスタムの `generate` に依存しているため、以下のドキュメントを確認してください。 - [WhisperProcessor](/docs/transformers/v5.23.0/ja/model_doc/whisper#transformers.WhisperProcessor)は、音声の準備や、予測されたidをテキストに戻すデコードに使用できます。 ## WhisperConfig[[transformers.WhisperConfig]] #### transformers.WhisperConfig[[transformers.WhisperConfig]] ```python transformers.WhisperConfig(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, 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, is_encoder_decoder: bool = True, vocab_size: int = 51865, num_mel_bins: int = 80, encoder_layers: int = 4, encoder_attention_heads: int = 6, decoder_layers: int = 4, decoder_attention_heads: int = 6, decoder_ffn_dim: int = 1536, encoder_ffn_dim: int = 1536, encoder_layerdrop: float | int = 0.0, decoder_layerdrop: float | int = 0.0, decoder_start_token_id: int = 50257, use_cache: bool = True, activation_function: str = 'gelu', d_model: int = 384, dropout: float | int = 0.0, attention_dropout: float | int = 0.0, activation_dropout: float | int = 0.0, init_std: float = 0.02, scale_embedding: bool = False, max_source_positions: int = 1500, max_target_positions: int = 448, pad_token_id: int | None = 50256, bos_token_id: int | None = 50256, eos_token_id: int | list[int] | None = 50256, suppress_tokens: list | None = None, begin_suppress_tokens: list[int] | tuple[int, ...] | None = (220, 50256), use_weighted_layer_sum: bool = False, classifier_proj_size: int = 256, apply_spec_augment: bool = False, mask_time_prob: float | int = 0.05, mask_time_length: int = 10, mask_time_min_masks: int = 2, mask_feature_prob: float | int = 0.0, mask_feature_length: int = 10, mask_feature_min_masks: int = 0, median_filter_width: int = 7, tie_word_embeddings: bool = True) ``` [ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/whisper/configuration_whisper.py#L50) **パラメータ:** is_encoder_decoder (`bool`、*任意*、デフォルトは`True`) : モデルがエンコーダー/デコーダーとして使用されるかどうかを示します。 vocab_size (`int`、*任意*、デフォルトは`51865`) : モデルの語彙サイズ。`input_ids`で表現できるトークンの種類数を定義します。 num_mel_bins (`int`、*任意*、デフォルトは`80`) : 入力フレームごとに使用されるメル特徴の数を指定します。`AutoFeatureExtractor`クラスで使用される値と一致させる必要があります。 encoder_layers (`int`、*任意*、デフォルトは`4`) : Transformerエンコーダーの隠れ層の数。設定されていない場合は、`num_layers`と同じ値が使用されます。 encoder_attention_heads (`int`、*任意*、デフォルトは`6`) : Transformerエンコーダーの各アテンション層におけるアテンションヘッドの数。 decoder_layers (`int`、*任意*、デフォルトは`4`) : Transformer デコーダーの隠れ層の数。設定されていない場合は、`num_layers` と同じ値が使用されます。 decoder_attention_heads (`int`、*任意*、デフォルトは `6`) : Transformer デコーダーの各アテンション層におけるアテンションヘッドの数。 decoder_ffn_dim (`int`、*任意*、デフォルトは`1536`) : デコーダー内の「intermediate」（feed-forward とも呼ばれる）層の次元数。 encoder_ffn_dim (`int`、*optional*、デフォルトは`1536`) : エンコーダー内の「intermediate」（feed-forward層とも呼ばれる）層の次元数。 encoder_layerdrop (`Union[float, int]`、*任意*、デフォルトは`0.0`) : エンコーダーのLayerDrop確率です。詳細については、[LayerDrop論文](see https://huggingface.co/papers/1909.11556)を参照してください。 decoder_layerdrop (`Union[float, int]`、*任意*、デフォルトは`0.0`) : デコーダーの LayerDrop 確率です。詳細については、[LayerDrop の論文](see https://huggingface.co/papers/1909.11556)を参照してください。 decoder_start_token_id (`int`、*optional*、デフォルトは`50257`) : エンコーダーデコーダーモデルが`bos`以外のトークンでデコーディングを開始する場合、そのトークンのID。 use_cache (`bool`、*任意*、デフォルトは `True`) : モデルが最後のキー/バリューアテンションを返すかどうか（すべてのモデルで利用されるわけではありません）。`config.is_decoder=True` の場合、またはモデルがデコーダー専用の生成モデルである場合にのみ関連します。 activation_function (`str`、*任意*、デフォルトは`gelu`) : デコーダーで使用する非線形活性化関数（関数または文字列）。例えば、`"gelu"`、`"relu"`、`"silu"`など。 d_model (`int`、*任意*、デフォルトは`384`) : エンコーダ層とプーラー層のサイズ。 dropout (`Union[float, int]`、*任意*、デフォルトは`0.0`) : すべての dropout レイヤーの比率。 attention_dropout (`Union[float, int]`、*任意*、デフォルトは`0.0`) : 注意確率のドロップアウト率。 activation_dropout (`Union[float, int]`、*任意*、デフォルトは`0.0`) : 全結合層内の活性化に対する dropout 率。 init_std (`float`、*任意*、デフォルトは`0.02`) : すべての重み行列を初期化するためのtruncated_normal_initializerの標準偏差です。 scale_embedding (`bool`、*任意*、デフォルトは`False`) : sqrt(d_model) で割って埋め込みをスケーリングするかどうか。 max_source_positions (`int`、*任意*、デフォルトは 1500) : このモデルが使用される可能性がある log-mel フィルターバンク特徴量の最大シーケンス長です。 max_target_positions (`int`, *optional*, デフォルトは 448) : このモデルが使用される可能性のある最大シーケンス長です。念のため、通常は大きめの値 (例: 512、1024、2048) に設定します。 pad_token_id (`int`, *任意*, デフォルトは `50256`) : 語彙内でパディングに使用されるトークンID。 bos_token_id (`int`, *任意*, デフォルトは `50256`) : 語彙内でストリームの開始に使用されるトークン ID。 eos_token_id (`Union[int, list[int]]`、*任意*、デフォルトは`50256`) : 語彙内でストリーム終了に使用されるトークン ID。 suppress_tokens (`list[int]`, *optional*) : `generate` 関数内の logit processor が使用する、非音声トークンを含むリストです。NON_SPEECH_TOKENS と NON_SPEECH_TOKENS_MULTI は、それぞれ `english-only` モデルと `multilingual` モデルに対応しています。 begin_suppress_tokens (`list[int]`、*任意*、デフォルトは`[220,50256]`) : サンプリング処理の開始時に抑制されるトークンを含むリスト。`" "`（`blank_token_id`）のトークンと`eos_token_id`で初期化されます。 use_weighted_layer_sum (`bool`、*任意*、デフォルトは`False`) : 学習された重みを用いた層の出力の加重平均を使用するかどうか。[WhisperForAudioClassification](/docs/transformers/v5.23.0/ja/model_doc/whisper#transformers.WhisperForAudioClassification)のインスタンスを使用する場合にのみ関連します。 classifier_proj_size (`int`、*optional*、デフォルトは 256) : 分類のためのトークン平均プーリング前の射影の次元数。[WhisperForAudioClassification](/docs/transformers/v5.23.0/ja/model_doc/whisper#transformers.WhisperForAudioClassification) のインスタンスを使用する場合にのみ関連します。 apply_spec_augment (`bool`, *任意*, デフォルトは `False`) : 特徴量エンコーダーの出力に *SpecAugment* データ拡張を適用するかどうか。参考として [SpecAugment: A Simple Data Augmentation Method for Automatic Speech Recognition](https://huggingface.co/papers/1904.08779) を参照してください。 mask_time_prob (`float`、*任意*、デフォルト値は 0.05) : 時間軸に沿ったすべての特徴量ベクトルの中で、マスクされる割合 (0 から 1 の間)。マスク処理では、軸に対して `mask_time_prob*len(time_axis)/mask_time_length` 個の独立したマスクが生成されます。マスクされるベクトルスパンの開始点として各特徴量ベクトルが選択される確率から推論する場合、*mask_time_prob* は `prob_vector_start*mask_time_length` であるべきです。重複により、実際にマスクされるベクトルの割合が低下する可能性があります。これは `apply_spec_augment == True` の場合のみ関連します。 mask_time_length (`int`, *optional*, デフォルトは 10) : 時間軸に沿ったベクトルスパンの長さ。 mask_time_min_masks (`int`、*optional*、デフォルトは 2)、: `mask_feature_prob` に関係なく、時間軸に沿って生成される長さ `mask_feature_length` のマスクの最小数。各タイムステップごとに適用されます。''mask_time_prob*len(time_axis)/mask_time_length < mask_time_min_masks'' の場合のみ関連します。 mask_feature_prob (`float`、*任意*、デフォルト値は 0.0) : 特徴軸に沿ったすべての特徴ベクトルの中で、マスクされる割合 (0 から 1 の間)。マスク処理では、軸に対して `mask_feature_prob*len(feature_axis)/mask_time_length` 個の独立したマスクが生成されます。マスクされるベクトル範囲の開始点として各特徴ベクトルが選択される確率から推論する場合、*mask_feature_prob* は `prob_vector_start*mask_feature_length` であるべきです。重複により、実際にマスクされるベクトルの割合が減少する可能性があります。これは `apply_spec_augment is True` の場合のみ関連します。 mask_feature_prob (`Union[float, int]`、*任意*、デフォルトは `0.0`) : 特徴軸に沿ったすべての特徴ベクトルの中で、マスクされる割合（0 から 1 の間）。マスク処理では、軸に対して `mask_feature_prob*len(feature_axis)/mask_time_length` 個の独立したマスクが生成されます。マスクされるベクトル範囲の開始点として各特徴ベクトルが選択される確率から考えると、*mask_feature_prob* は `prob_vector_start*mask_feature_length` であるべきです。重複により、実際にマスクされるベクトルの割合が低下する可能性があります。これは `apply_spec_augment` が `True` の場合のみ関連します。 mask_feature_length (`int`, *任意*, デフォルトは 10) : 特徴量軸に沿ったベクトルスパンの長さ。 mask_feature_min_masks (`int`, *optional*, デフォルト値は 0) : `mask_feature_prob` に関係なく、各タイムステップにおいて、特徴軸に沿って生成される長さ `mask_feature_length` のマスクの最小数です。`mask_feature_prob*len(feature_axis)/mask_feature_length < mask_feature_min_masks` の場合のみ関連します。 median_filter_width (`int`、*optional*、デフォルトは 7) : トークンタイムスタンプを計算する際に、クロスアテンションの出力を平滑化するために使用される中央値フィルタの幅です。奇数である必要があります。 tie_word_embeddings (`bool`、*任意*、デフォルトは`True`) : モデルの`tied_weights_keys`マッピングに従って重み埋め込みを共有するかどうか。 これはWhisperModelの設定を保存するための設定クラスです。指定された引数に基づいてWhisperモデルをインスタンス化し、モデルのアーキテクチャを定義するために使用されます。デフォルト値で設定をインスタンス化すると、[openai/whisper-tiny](https://huggingface.co/openai/whisper-tiny)と類似した設定が得られます。 設定オブジェクトは [PreTrainedConfig](/docs/transformers/v5.23.0/ja/main_classes/configuration#transformers.PreTrainedConfig) を継承し、モデルの出力を制御するために使用できます。詳細については、[PreTrainedConfig](/docs/transformers/v5.23.0/ja/main_classes/configuration#transformers.PreTrainedConfig) のドキュメントを参照してください。 例: ```python >>> from transformers import WhisperConfig, WhisperModel >>> # Initializing a Whisper tiny style configuration >>> configuration = WhisperConfig() >>> # Initializing a model (with random weights) from the tiny style configuration >>> model = WhisperModel(configuration) >>> # Accessing the model configuration >>> configuration = model.config ``` ## WhisperTokenizer[[transformers.WhisperTokenizer]] #### transformers.WhisperTokenizer[[transformers.WhisperTokenizer]] ```python transformers.WhisperTokenizer(vocab: str | dict[str, int] | None = None, merges = None, normalizer_file = None, unk_token = '<|endoftext|>', bos_token = '<|endoftext|>', eos_token = '<|endoftext|>', add_prefix_space = False, language = None, task = None, predict_timestamps = False, **kwargs) ``` [ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/whisper/tokenization_whisper.py#L163) **パラメータ:** vocab_file (`str`, *任意*) : 語彙ファイルへのパス。 merges_file (`str`, *任意*) : マージファイルへのパス。 normalizer_file (`str`, *任意*) : normalizer_file ファイルへのパス。 tokenizer_file (`str`, *任意*) : トークナイザーを読み込むために必要な情報がすべて含まれている、[tokenizers](https://github.com/huggingface/tokenizers) ファイルへのパス（通常は .json 拡張子を持っています）。 unk_token (`str`、*任意*、デフォルトは `"<|endoftext|>"`) : 不明トークンです。語彙に存在しないトークンは ID に変換できず、代わりにこのトークンが設定されます。 bos_token (`str`、*任意*、デフォルトは`"<|endoftext|>"`) : シーケンスの開始トークンです。生成時に`decoder_start_token_id`が使用され、最初のトークンを`"<|startoftranscript|>"`に設定します。 eos_token (`str`、*任意*、デフォルトは `"<|endoftext|>"`) : シーケンスの終了トークンです。 add_prefix_space (`bool`、*任意*、デフォルトは`False`) : 入力に先頭スペースを追加するかどうか。これにより、先頭の単語を他の単語と同様に扱うことができます。(Whisper トークナイザーは、先行するスペースによって単語の開始を検出します)。 language (`str`, *任意*) : 転写テキストの言語です。多言語音声認識および音声翻訳タスクでは、対応する言語 ID トークンがシーケンスの先頭に追加されます。例えば、スペイン語の場合、トークン`"<|es|>"`がシーケンスの先頭に追加されます。これは多言語ファインチューニングでのみ使用する必要があります。 task (`str`, *任意*) : シーケンスの先頭に追加するタスク識別子（ある場合）。これは多言語ファインチューニングで使用するもので、音声認識には`"transcribe"`、音声翻訳には`"translate"`を指定します。 predict_timestamps (`bool`、*任意*、デフォルトは`False`) : シーケンスの先頭にある`<|notimestamps|>`トークンを省略するかどうか。 HuggingFaceの*tokenizers*ライブラリをバックエンドとする「高速」Whisperトークナイザーを構築します。 このトークナイザーは、[PreTrainedTokenizerFast](/docs/transformers/v5.23.0/ja/main_classes/tokenizer#transformers.TokenizersBackend) を継承しており、主要なメソッドのほとんどが含まれています。これらのメソッドに関する詳細については、このスーパークラスを参照してください。 #### set_prefix_tokens[[transformers.WhisperTokenizer.set_prefix_tokens]] ```python set_prefix_tokens(language: str | None = None, task: str | None = None, predict_timestamps: bool | None = None) ``` [ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/whisper/tokenization_whisper.py#L585) **パラメータ:** language (`str`、*任意*、デフォルトは`None`) : 文字起こしテキストの言語。 task (`str`、*任意*、デフォルトは`None`) : シーケンスの先頭に追加するタスク識別子（ある場合）。 predict_timestamps (`bool`、*任意*、デフォルトは`None`) : シーケンスの先頭にある`<|notimestamps|>`トークンを省略するかどうか。 ラベルシーケンスの先頭に追加されるプレフィックストークンをオーバーライドします。このメソッドは単独で使用することもでき ファインチューニング時に必要に応じてプレフィックストークンを更新します。例: ```python >>> # instantiate the tokenizer and set the prefix token to Spanish >>> tokenizer = WhisperTokenizerFast.from_pretrained("openai/whisper-tiny", language="spanish") >>> # now switch the prefix token from Spanish to French >>> tokenizer.set_prefix_tokens(language="french") ``` #### get_special_tokens_mask[[transformers.WhisperTokenizer.get_special_tokens_mask]] ```python get_special_tokens_mask(token_ids_0: list[int], token_ids_1: list[int] | None = None, already_has_special_tokens: bool = False) ``` [ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/whisper/tokenization_whisper.py#L669) **パラメータ:** token_ids_0 (`list[int]`) : ID のリスト。 token_ids_1 (`list[int]`, *任意*) : シーケンスペア用の任意の第2のIDリスト。 already_has_special_tokens (`bool`、*任意*、デフォルトは`False`) : トークンリストが、モデル用の特殊トークンを含む形式で既に整形されているかどうかを示します。 **戻り値:** `list[int]` 範囲 [0, 1] の整数のリスト: 特殊トークンは 1、シーケンストークンは 0。 特殊トークンが追加されていないトークンリストからシーケンスIDを取得します。このメソッドは、トークナイザーの`prepare_for_model`メソッドを使用して特殊トークンを追加する際に呼び出されます。 #### save_vocabulary[[transformers.WhisperTokenizer.save_vocabulary]] ```python save_vocabulary(save_directory: str, filename_prefix: str | None = None) ``` [ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/whisper/tokenization_whisper.py#L555) #### batch_decode[[transformers.WhisperTokenizer.batch_decode]] ```python batch_decode(sequences: list[int] | list[list[int]] | np.ndarray | torch.Tensor, skip_special_tokens: bool = False, clean_up_tokenization_spaces: bool | None = None, **kwargs) ``` [ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_utils_base.py#L2932) **パラメータ:** sequences (`Union[list[int], list[list[int]], np.ndarray, torch.Tensor]`) : トークン化された入力 ID のリスト。`__call__` メソッドを使用して取得できます。 skip_special_tokens (`bool`、*任意*、デフォルトは`False`) : デコーディング時に特殊トークンを削除するかどうか。 clean_up_tokenization_spaces (`bool`、*任意*) : トークナイズのスペースをクリーンアップするかどうか。`None`の場合、`self.clean_up_tokenization_spaces`がデフォルトとして使用されます。 kwargs （追加のキーワード引数、*任意*）：基礎となるモデル固有のデコードメソッドに渡されます。 **戻り値:** `list[str]` デコードされた文のリスト。 decode を呼び出して、トークン ID のリストのリストを文字列のリストに変換します。 このメソッドは後方互換性のために提供されています。`decode`メソッドは現在、バッチ入力をネイティブで処理するため、`batch_decode`の代わりに`decode`を直接使用できます。 #### decode[[transformers.WhisperTokenizer.decode]] ```python decode(token_ids, skip_special_tokens: bool = False, clean_up_tokenization_spaces: bool | None = None, output_offsets: bool = False, time_precision: float = 0.02, decode_with_timestamps: bool = False, normalize: bool = False, basic_normalize: bool = False, remove_diacritics: bool = False, **kwargs) ``` [ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/whisper/tokenization_whisper.py#L432) **パラメータ:** token_ids (`Union[int, list[int], np.ndarray, torch.Tensor]`) : トークン化された入力 ID のリスト。`__call__` メソッドを使用して取得できます。 skip_special_tokens (`bool`、*任意*、デフォルトは`False`) : デコーディング時に特殊トークンを削除するかどうか。存在する場合、以前のトークン（プロンプト前）も削除されます。 clean_up_tokenization_spaces (`bool`, *任意*) : トークナイズのスペースをクリーンアップするかどうか。`None`の場合、`self.clean_up_tokenization_spaces`（`tokenizer_config`で利用可能）がデフォルトとして使用されます。 output_offsets (`bool`、*任意*、デフォルトは`False`) : トークンのオフセットを出力するかどうか。これは、モデルがタイムスタンプを予測した場合にのみ設定すべきです。デコード対象の先行トークン（プロンプト以前）が存在する場合、タイムスタンプトークンを含む場合のみ、デコードされたテキストに表示されます。 time_precision (`float`、*任意*、デフォルトは 0.02) : トークンから時間へ変換するための時間比率です。 decode_with_timestamps (`bool`, *任意*, デフォルトは `False`) : 生テキストにタイムスタンプを含めてデコードするかどうか。 normalize (`bool`、*任意*、デフォルトは`False`) : 復号化されたテキストに英語テキスト正規化器を適用するかどうか。対象テキストが英語の場合にのみ適用されます。それ以外の場合は、基本的なテキスト正規化器を適用する必要があります。 basic_normalize (`bool`、*任意*、デフォルトは`False`) : 復号化されたテキストにBasicテキスト正規化器を適用するかどうか。多言語のターゲットテキストに適用可能です。 remove_diacritics (`bool`、*任意*、デフォルトは`False`) : Basic テキスト正規化を適用する際に、発音記号（アクセント記号）を除去するかどうか。発音記号の除去はデコードされたテキストの情報破壊につながる可能性があるため、注意して使用してください。 kwargs （追加のキーワード引数、*任意*）：基礎となるモデル固有のデコードメソッドに渡されます。 **戻り値:** `str` デコードされた文。 トークナイザと語彙を使用して、文字列内のIDのシーケンスを変換します。特殊トークンの削除や、トークナイズスペースのクリーンアップなどのオプションが利用できます。 `self.convert_tokens_to_string(self.convert_ids_to_tokens(token_ids))` を実行するのと似ています。 #### basic_normalize[[transformers.WhisperTokenizer.basic_normalize]] ```python basic_normalize(text, remove_diacritics = False) ``` [ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/whisper/tokenization_whisper.py#L546) `BasicTextNormalizer` クラスを使用して、指定された文字列を正規化します。このクラスは、多言語テキストに対する一般的な変換を実行します。 #### normalize[[transformers.WhisperTokenizer.normalize]] ```python normalize(text) ``` [ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/whisper/tokenization_whisper.py#L538) `EnglishTextNormalizer`クラスを使用して、指定された文字列を正規化します。このクラスは、英語テキストに対する一般的な変換を実行します。 ## WhisperFeatureExtractor[[transformers.WhisperFeatureExtractor]] #### transformers.WhisperFeatureExtractor[[transformers.WhisperFeatureExtractor]] ```python transformers.WhisperFeatureExtractor(feature_size = 80, sampling_rate = 16000, hop_length = 160, chunk_length = 30, n_fft = 400, padding_value = 0.0, dither = 0.0, return_attention_mask = False, **kwargs) ``` [ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/whisper/feature_extraction_whisper.py#L33) **パラメータ:** feature_size (`int`、*任意*、デフォルトは 80) : 抽出された特徴量の次元数。 sampling_rate (`int`、*optional*、デフォルトは 16000) : 音声ファイルをデジタル化するためのサンプリングレート（ヘルツ (Hz) 単位）。 hop_length (`int`, *optional*, デフォルトは 160) : Mel 周波数係数を取得するために使用される STFT の、重複ウィンドウの長さ。 chunk_length (`int`、*任意*、デフォルトは 30) : より長いまたは短い音声シーケンスをトリムおよびパディングするために使用される、`sampling_rate` サンプルのチャンクの最大数。 n_fft (`int`, *optional*, デフォルトは 400) : フーリエ変換のサイズ。 padding_value (`float`、*optional*、デフォルト値は 0.0) : 音声のパディングに使用される値です。無音に対応する値である必要があります。 dither (`float`、*任意*、デフォルトは 0.0) : ディザリングを追加します。つまり、各フレームに小さなガウスノイズを加えます。例えば、0.0001 を指定すると、平均 0.0、標準偏差 0.0001 の正規分布によるディザリングが追加されます（raw_speech の範囲が [-1,+1] であると仮定）。値が 0.0 の場合はディザリングを行いません。ディザリングは `spectrogram(mel_floor=...)` と同様の効果を持ち、信号に VAD カットオフが存在する場合、ハードゼロ区間を持つ信号の log_mel_fbank の高い値を低減します。 Whisper の特徴量抽出器を構築します。 このフィーチャーエクストラクターは、主要なメソッドの大部分を含む [SequenceFeatureExtractor](/docs/transformers/v5.23.0/ja/main_classes/feature_extractor#transformers.SequenceFeatureExtractor) を継承しています。これらのメソッドに関する詳細については、このスーパークラスを参照してください。 このクラスは、`Short Time Fourier Transform` のカスタムな numpy 実装を使用して、生音声からメルフィルタバンク特徴量を抽出します。この実装は、PyTorch の `torch.stft` と同等の結果を出力するようになっています。 #### __call__[[transformers.WhisperFeatureExtractor.__call__]] ```python __call__(raw_speech: numpy.ndarray | list[float] | list[numpy.ndarray] | list[list[float]], truncation: bool = True, pad_to_multiple_of: int | None = None, return_tensors: str | transformers.utils.generic.TensorType | None = None, return_attention_mask: bool | None = None, padding: str | None = 'max_length', max_length: int | None = None, sampling_rate: int | None = None, do_normalize: bool | None = None, device: str | None = 'cpu', **kwargs) ``` [ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/whisper/feature_extraction_whisper.py#L193) **パラメータ:** raw_speech (`np.ndarray`、`list[float]`、`list[np.ndarray]`、`list[list[float]]`) : パディング対象のシーケンスまたはシーケンスのバッチです。各シーケンスは、NumPy 配列、浮動小数点数のリスト、NumPy 配列のリスト、または浮動小数点数のリストのリストであることができます。ステレオではなくモノラルのオーディオで、つまり 1 タイムステップあたり 1 つの浮動小数点数である必要があります。 truncation (`bool`、*任意*、デフォルトは`True`) : 入力シーケンスの切り詰め処理を有効にし、*max_length*を超える長さのシーケンスを*max_length*まで短くします。 pad_to_multiple_of (`int`、*任意*、デフォルトは None) : 設定すると、シーケンスを指定された値の倍数にパディングします。これは、計算能力 `>= 7.5` (Volta) を持つ NVIDIA ハードウェアで Tensor Cores を使用可能にするため、また、シーケンス長が 128 の倍数であることで恩恵を受ける TPU において、特に有用です。 return_tensors (`str` または [TensorType](/docs/transformers/v5.23.0/ja/internal/file_utils#transformers.TensorType)、*optional*) : 設定されている場合、Python の整数のリストではなくテンソルを返します。指定可能な値は以下の通りです。 - `'pt'`: PyTorch の `torch.Tensor` オブジェクトを返します。 - `'np'`: Numpy の `np.ndarray` オブジェクトを返します。 return_attention_mask (`bool`, *任意*) : アテンションマスクを返すかどうか。デフォルトのままにすると、特定の feature_extractor のデフォルトに従ってアテンションマスクを返します。 [アテンションマスクとは?](../glossary#attention-mask) Whisper モデルでは、微妙なバグを避けるために、バッチ推論では常に `attention_mask` を渡す必要があります。 padding (`str` または [PaddingStrategy](/docs/transformers/v5.23.0/ja/internal/file_utils#transformers.utils.PaddingStrategy)、*optional*、デフォルトは `'max_length'`) : パディングの有効化と制御を行います。以下の値を受け付けます: - `'longest'`: バッチ内の最長のシーケンスの長さにパディングします（単一のシーケンスのみが提供された場合は、パディングを行いません）。 - `'max_length'`（デフォルト）: 引数 `max_length` で指定された最大長、またはその引数が提供されていない場合はモデルが受け付ける最大入力長までパディングします。 - `'do_not_pad'`: パディングを行いません（つまり、長さが異なるシーケンスのバッチを出力できます）。 max_length (`int`, *optional*) : 切り詰め/パディングパラメータのいずれかによって使用される最大長を制御します。 未設定のまま、または `None` に設定されている場合、切り詰め/パディングパラメータのいずれかが最大長を必要とする場合、事前に定義されたモデルの最大長が使用されます。 モデルに特定の最大入力長がない場合（XLNet など）、最大長への切り詰め/パディングは無効になります。 sampling_rate (`int`, *任意*) : `raw_speech` 入力がサンプリングされたレートです。サイレントエラーを防ぎ、自動音声認識パイプラインを有効にするため、forward 呼び出し時に `sampling_rate` を渡すことを強く推奨します。 do_normalize (`bool`、*任意*、デフォルトは`False`) : 入力を平均0・分散1に正規化するかどうかを指定します。正規化を行うことで、モデルの性能が大幅に向上する場合があります。 device (`str`、*任意*、デフォルトは `'cpu'`) : `_torch_extract_fbank_features` メソッドにおいて、音声信号の log-mel スペクトログラムを計算する際に使用するデバイスを指定します（例: "cpu"、"cuda"）。 - ****kwargs** : __call__()ではWhisperFeatureExtractorによってサポートされておらず、無視されます。 1つ以上のシーケンスを特徴量化し、モデル用に準備するための主要なメソッドです。実装では、利用可能な場合はSTFTの計算にPyTorchを使用し、利用できない場合はより低速なNumPyベースの処理を使用します。 ## WhisperProcessor[[transformers.WhisperProcessor]] #### transformers.WhisperProcessor[[transformers.WhisperProcessor]] ```python transformers.WhisperProcessor(feature_extractor, tokenizer) ``` [ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/whisper/processing_whisper.py#L23) **パラメータ:** feature_extractor (`WhisperFeatureExtractor`) : 特徴量抽出器は必須の入力です。 tokenizer (`WhisperTokenizer`) : トークナイザーは必須の入力です。 WhisperProcessorを構築します。これは、フィーチャーエクストラクターとトークナイザーを単一のプロセッサーにラップします。 [WhisperProcessor](/docs/transformers/v5.23.0/ja/model_doc/whisper#transformers.WhisperProcessor) は、[WhisperFeatureExtractor](/docs/transformers/v5.23.0/ja/model_doc/whisper#transformers.WhisperFeatureExtractor) と [WhisperTokenizer](/docs/transformers/v5.23.0/ja/model_doc/whisper#transformers.WhisperTokenizer) のすべての機能を提供します。詳細については、[~WhisperFeatureExtractor](/docs/transformers/v5.23.0/ja/model_doc/whisper#transformers.WhisperFeatureExtractor) および [~WhisperTokenizer](/docs/transformers/v5.23.0/ja/model_doc/whisper#transformers.WhisperTokenizer) を参照してください。 #### __call__[[transformers.WhisperProcessor.__call__]] ```python __call__(*args, **kwargs) ``` [ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/whisper/processing_whisper.py#L30) **パラメータ:** return_tensors (`str` または [TensorType](/docs/transformers/v5.23.0/ja/internal/file_utils#transformers.TensorType)、*optional*) : 設定されている場合、特定のフレームワークのテンソルを返します。受け入れ可能な値は以下の通りです: - `'pt'`: PyTorch の `torch.Tensor` オブジェクトを返します。 - `'np'`: NumPy の `np.ndarray` オブジェクトを返します。 #### from_pretrained[[transformers.WhisperProcessor.from_pretrained]] ```python from_pretrained(pretrained_model_name_or_path: str | os.PathLike, cache_dir: str | os.PathLike | None = None, force_download: bool = False, local_files_only: bool = False, token: str | bool | None = None, revision: str = 'main', **kwargs) ``` [ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/processing_utils.py#L1799) **パラメータ:** pretrained_model_name_or_path (`str` または `os.PathLike`) : 以下のいずれかです: - huggingface.co のモデルリポジトリにホストされている事前学習済み feature_extractor の *model id* を示す文字列。 - [save_pretrained()](/docs/transformers/v5.23.0/ja/main_classes/feature_extractor#transformers.FeatureExtractionMixin.save_pretrained) メソッドを使用して feature extractor ファイルを保存した *ディレクトリ* へのパス。例: `./my_model_directory/`。 - 保存された feature extractor の JSON *ファイル* へのパス。例: `./my_model_directory/preprocessor_config.json`。 - ****kwargs** : [from_pretrained()](/docs/transformers/v5.23.0/ja/main_classes/feature_extractor#transformers.FeatureExtractionMixin.from_pretrained) と `~tokenization_utils_base.PreTrainedTokenizer.from_pretrained` の両方に渡される追加のキーワード引数。 事前学習済みモデルに関連付けられたプロセッサをインスタンス化します。 このクラスメソッドは、単にフィーチャーエクストラクターの [from_pretrained()](/docs/transformers/v5.23.0/ja/main_classes/feature_extractor#transformers.FeatureExtractionMixin.from_pretrained)、イメージプロセッサーの [ImageProcessingMixin](/docs/transformers/v5.23.0/ja/internal/image_processing_utils#transformers.ImageProcessingMixin)、およびトークナイザーの `~tokenization_utils_base.PreTrainedTokenizer.from_pretrained` メソッドを呼び出しています。詳細については、上記のメソッドのドキュメント文字列を参照してください。 #### save_pretrained[[transformers.WhisperProcessor.save_pretrained]] ```python save_pretrained(save_directory, push_to_hub: bool = False, **kwargs) ``` [ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/processing_utils.py#L1182) **パラメータ:** save_directory (`str` または `os.PathLike`) : 特徴量抽出器の JSON ファイルとトークナイザーのファイルを保存するディレクトリ（存在しない場合は作成されます）。 push_to_hub (`bool`、*任意*、デフォルトは`False`) : モデルを保存した後、Hugging Face モデルハブにプッシュするかどうかを指定します。プッシュ先のリポジトリは`repo_id`で指定できます（指定しない場合、`save_directory`の名前があなたのネームスペース内でデフォルトとして使用されます）。 kwargs (`dict[str, Any]`、*省略可*) : [push_to_hub()](/docs/transformers/v5.23.0/ja/main_classes/model#transformers.utils.PushToHubMixin.push_to_hub) メソッドに渡される追加のキーワード引数。 このプロセッサ（フィーチャーエクストラクター、トークナイザーなど）の属性を指定されたディレクトリに保存し、[from_pretrained()](/docs/transformers/v5.23.0/ja/model_doc/wav2vec2#transformers.Wav2Vec2Processor.from_pretrained) メソッドによって再読み込みできるようにします。 このクラスメソッドは、[save_pretrained()](/docs/transformers/v5.23.0/ja/main_classes/feature_extractor#transformers.FeatureExtractionMixin.save_pretrained)と[save_pretrained()](/docs/transformers/v5.23.0/ja/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.save_pretrained)を呼び出すだけです。詳細については、上記のメソッドのドキュメント文字列を参照してください。 #### batch_decode[[transformers.WhisperProcessor.batch_decode]] ```python batch_decode(*args, **kwargs) ``` [ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/processing_utils.py#L2054) このメソッドは、すべての引数を PreTrainedTokenizer の [batch_decode()](/docs/transformers/v5.23.0/ja/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.batch_decode) に転送します。詳細については、このメソッドのドキュメント文字列を参照してください。 #### decode[[transformers.WhisperProcessor.decode]] ```python decode(*args, **kwargs) ``` [ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/processing_utils.py#L2063) このメソッドは、すべての引数を PreTrainedTokenizer の [decode()](/docs/transformers/v5.23.0/ja/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.decode) に転送します。詳細については、このメソッドのドキュメント文字列を参照してください。 ## WhisperModel[[transformers.WhisperModel]] #### transformers.WhisperModel[[transformers.WhisperModel]] ```python transformers.WhisperModel(config: WhisperConfig) ``` [ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/whisper/modeling_whisper.py#L826) **パラメータ:** config ([WhisperConfig](/docs/transformers/v5.23.0/ja/model_doc/whisper#transformers.WhisperConfig)) : モデルのパラメータをすべて含むモデル設定クラスです。設定ファイルで初期化しても、モデルに関連する重みは読み込まれず、設定のみが読み込まれます。モデルの重みをロードするには、[from_pretrained()](/docs/transformers/v5.23.0/ja/main_classes/model#transformers.PreTrainedModel.from_pretrained) メソッドを確認してください。 特定のヘッドを付加せずに、生のhidden-statesを出力する素のWhisper Model。 このモデルは [PreTrainedModel](/docs/transformers/v5.23.0/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.WhisperModel.forward]] ```python forward(input_features: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.LongTensor] = None, decoder_input_ids: typing.Optional[torch.LongTensor] = None, decoder_attention_mask: typing.Optional[torch.LongTensor] = None, encoder_outputs: tuple[tuple[torch.Tensor]] | None = None, past_key_values: transformers.cache_utils.Cache | None = None, decoder_inputs_embeds: tuple[torch.Tensor] | None = None, decoder_position_ids: tuple[torch.LongTensor] | None = None, use_cache: bool | None = None, **kwargs) ``` [ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/whisper/modeling_whisper.py#L891) **パラメータ:** input_features (`torch.Tensor`、形状 `(batch_size, sequence_length, feature_dim)`、*任意*) : 入力音声特徴に対応するテンソルです。音声特徴は [WhisperFeatureExtractor](/docs/transformers/v5.23.0/ja/model_doc/whisper#transformers.WhisperFeatureExtractor) を使用して取得できます。詳細は [WhisperFeatureExtractor.__call__()](/docs/transformers/v5.23.0/ja/model_doc/whisper#transformers.WhisperFeatureExtractor.__call__) を参照してください（[WhisperProcessor](/docs/transformers/v5.23.0/ja/model_doc/whisper#transformers.WhisperProcessor) は音声の処理に [WhisperFeatureExtractor](/docs/transformers/v5.23.0/ja/model_doc/whisper#transformers.WhisperFeatureExtractor) を使用します）。 attention_mask (`torch.LongTensor`、shape `(batch_size, sequence_length)`、*任意*) : padding トークンインデックスに対する attention を行わないためのマスク。`[0, 1]` から選択されるマスク値: - **マスクされない**トークンは 1、- **マスクされる**トークンは 0。 [attention マスクとは?](../glossary#attention-mask) decoder_input_ids (`torch.LongTensor`、形状 `(batch_size, target_sequence_length)`、*任意*) : 語彙におけるデコーダー入力シーケンスのトークンインデックス。[WhisperTokenizer](/docs/transformers/v5.23.0/ja/model_doc/whisper#transformers.WhisperTokenizer) を使用してインデックスを取得できます。詳細は [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/ja/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) および [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/ja/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) を参照してください。[デコーダー入力 ID とは何か？](../glossary#decoder-input-ids) Whisper は `decoder_input_ids` の生成の開始トークンとして `decoder_start_token_id` を使用します。`past_key_values` を使用する場合、オプションとして最後の `decoder_input_ids` だけを入力すれば十分です（`past_key_values` を参照）。 decoder_attention_mask (`torch.LongTensor`、形状 `(batch_size, target_sequence_length)`、*任意*) : デフォルトの動作: `decoder_input_ids` 内の pad トークンを無視するテンソルを生成します。デフォルトでは、カウザルマスクも使用されます。パディングの動作を変更する場合は、`modeling_whisper._prepare_decoder_attention_mask` を読み、必要に応じて修正してください。デフォルトの戦略に関する詳細は、[BART の論文](https://huggingface.co/papers/1910.13461) の図 1 を参照してください。 encoder_outputs (`tuple[tuple[torch.Tensor]]`, *任意*) : (`last_hidden_state`, *任意*: `hidden_states`, *任意*: `attentions`) のタプルです。`last_hidden_state` は形状 `(batch_size, sequence_length, hidden_size)` を持ち、*任意* です。エンコーダーの最終層の出力における隠れ状態のシーケンスです。デコーダーのクロスアテンションで使用されます。 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/v5.23.0/ja/internal/generation_utils#transformers.Cache) インスタンスのみです。[kv cache ガイド](https://huggingface.co/docs/transformers/en/kv_cache)を参照してください。`past_key_values` が渡されない場合、デフォルトで [DynamicCache](/docs/transformers/v5.23.0/ja/internal/generation_utils#transformers.DynamicCache) が初期化されます。モデルは、入力として与えられたのと同じキャッシュ形式を出力します。`past_key_values` を使用する場合は、すべての `input_ids`（形状 `(batch_size, sequence_length)`）の代わりに、このモデルに過去の key value 状態が与えられていない未処理の `input_ids`（形状 `(batch_size, unprocessed_length)`）のみを入力する必要があります。 decoder_inputs_embeds (`tuple[torch.Tensor]`、形状 `(batch_size, target_sequence_length, hidden_size)`、*任意*) : `decoder_input_ids` を渡す代わりに、埋め込み表現を直接渡すこともできます。`past_key_values` を使用する場合、`decoder_inputs_embeds` の最後の部分のみを入力すればよい場合があります（`past_key_values` を参照）。`decoder_input_ids` のインデックスを関連するベクトルに変換する方法を、モデル内部の埋め込み検索行列よりも細かく制御したい場合に便利です。 `decoder_input_ids` と `decoder_inputs_embeds` の両方が設定されていない場合、`decoder_inputs_embeds` は `inputs_embeds` の値を取ります。 decoder_position_ids (`torch.LongTensor`、shape `(batch_size, sequence_length)`、*任意*) : 各入力シーケンスのトークンが位置埋め込み内で占める位置のインデックスです。`[0, config.n_positions - 1]` の範囲から選択されます。 [位置 ID とは何か？](../glossary#position-ids) use_cache (`bool`, *任意*) : `True`に設定すると、`past_key_values`のキーバリュー状態が返され、デコーディングの高速化に利用できます（`past_key_values`を参照）。 **戻り値:** [Seq2SeqModelOutput](/docs/transformers/v5.23.0/ja/main_classes/output#transformers.modeling_outputs.Seq2SeqModelOutput) または `tuple(torch.Tensor)` 設定（[WhisperConfig](/docs/transformers/v5.23.0/ja/model_doc/whisper#transformers.WhisperConfig)）と入力に応じて、さまざまな要素で構成される、[Seq2SeqModelOutput](/docs/transformers/v5.23.0/ja/main_classes/output#transformers.modeling_outputs.Seq2SeqModelOutput)または`torch.Tensor`のタプル（`return_dict=False`が渡された場合、または`config.return_dict=False`の場合）。 [WhisperModel](/docs/transformers/v5.23.0/ja/model_doc/whisper#transformers.WhisperModel)のforwardメソッドは、`__call__`特殊メソッドをオーバーライドします。 この関数内でフォワードパスの手順を定義する必要がありますが、その後、この関数ではなく`Module`インスタンスを呼び出すべきです。前者は前処理と後処理の実行を適切に処理するのに対し、後者はそれらを無視してしまいます。 - **last_hidden_state** (`torch.Tensor`、形状 `(batch_size, sequence_length, hidden_size)`) -- モデルのデコーダーの最終層の出力における、隠れ状態のシーケンスです。 `past_key_values`が使用されている場合、出力されるのは、形状`(batch_size, 1, hidden_size)`のシーケンスの最後の隠れ状態のみです。 - **past_key_values** (`EncoderDecoderCache`、*任意*、`use_cache=True` が渡された場合または `config.use_cache=True` の場合に返されます) -- [EncoderDecoderCache](/docs/transformers/v5.23.0/ja/internal/generation_utils#transformers.EncoderDecoderCache) のインスタンスです。詳細については、[kv cache ガイド](https://huggingface.co/docs/transformers/en/kv_cache)を参照してください。 逐次デコーディングを高速化するために使用できる（`past_key_values` 入力参照）、事前計算済みの隠れ状態（自己アテンションブロックおよびクロスアテンションブロックのキーとバリュー）が含まれます。 - **decoder_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、および任意の初期埋め込み出力。 - **decoder_attentions** (`tuple(torch.Tensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) -- `torch.Tensor` のタプル（各レイヤーごとに1つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)`。 自己アテンションヘッドにおける加重平均を計算するために使用される、アテンションのsoftmax後のデコーダーのアテンション重み。 - **cross_attentions** (`tuple(torch.Tensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) -- `torch.Tensor` のタプル（各レイヤーごとに1つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)`。 クロスアテンション層のアテンション重みは、アテンションのsoftmax適用後に計算され、クロスアテンションヘッドにおける加重平均の計算に使用されます。 - **encoder_last_hidden_state** (`torch.Tensor`、形状 `(batch_size, sequence_length, hidden_size)`、*任意*) -- モデルのエンコーダーの最終層の出力における隠れ状態のシーケンス。 - **encoder_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、および任意の初期埋め込み出力。 - **encoder_attentions** (`tuple(torch.Tensor)`、*任意*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) -- 各レイヤーごとに 1 つの `torch.Tensor` からなるタプルで、形状は `(batch_size, num_heads, sequence_length, sequence_length)` です。 アテンションのsoftmaxを適用した後のエンコーダーのアテンション重み。自己アテンションヘッドにおける加重平均の計算に使用されます。 例: ```python >>> import torch >>> from transformers import AutoFeatureExtractor, WhisperModel >>> from datasets import load_dataset >>> model = WhisperModel.from_pretrained("openai/whisper-base") >>> feature_extractor = AutoFeatureExtractor.from_pretrained("openai/whisper-base") >>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation") >>> inputs = feature_extractor(ds[0]["audio"]["array"], return_tensors="pt") >>> input_features = inputs.input_features >>> decoder_input_ids = torch.tensor([[1, 1]]) * model.config.decoder_start_token_id >>> last_hidden_state = model(input_features, decoder_input_ids=decoder_input_ids).last_hidden_state >>> list(last_hidden_state.shape) [1, 2, 512] ``` #### _mask_input_features[[transformers.WhisperModel._mask_input_features]] ```python _mask_input_features(input_features: Tensor, attention_mask: typing.Optional[torch.LongTensor] = None) ``` [ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/whisper/modeling_whisper.py#L848) [SpecAugment](https://huggingface.co/papers/1904.08779) に従って、時間軸および/または特徴量軸に沿った特徴をマスクします。 ## WhisperForConditionalGeneration[[transformers.WhisperForConditionalGeneration]] #### transformers.WhisperForConditionalGeneration[[transformers.WhisperForConditionalGeneration]] ```python transformers.WhisperForConditionalGeneration(config: WhisperConfig) ``` [ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/whisper/modeling_whisper.py#L990) **パラメータ:** config ([WhisperConfig](/docs/transformers/v5.23.0/ja/model_doc/whisper#transformers.WhisperConfig)) : モデルのパラメータをすべて含むモデル設定クラスです。設定ファイルで初期化しても、モデルに関連する重みは読み込まれず、設定のみが読み込まれます。モデルの重みをロードするには、[from_pretrained()](/docs/transformers/v5.23.0/ja/main_classes/model#transformers.PreTrainedModel.from_pretrained) メソッドを確認してください。 言語モデリングヘッドを備えたWhisperモデル。自動音声認識に使用できます。 このモデルは [PreTrainedModel](/docs/transformers/v5.23.0/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.WhisperForConditionalGeneration.forward]] ```python forward(input_features: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.LongTensor] = None, decoder_input_ids: typing.Optional[torch.LongTensor] = None, decoder_attention_mask: typing.Optional[torch.LongTensor] = None, encoder_outputs: tuple[tuple[torch.Tensor]] | None = None, past_key_values: transformers.cache_utils.Cache | None = None, decoder_inputs_embeds: tuple[torch.Tensor] | None = None, decoder_position_ids: tuple[torch.LongTensor] | None = None, labels: typing.Optional[torch.LongTensor] = None, use_cache: bool | None = None, **kwargs) ``` [ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/whisper/modeling_whisper.py#L1034) **パラメータ:** input_features (`torch.Tensor`、形状 `(batch_size, sequence_length, feature_dim)`、*任意*) : 入力音声特徴に対応するテンソルです。音声特徴は [WhisperFeatureExtractor](/docs/transformers/v5.23.0/ja/model_doc/whisper#transformers.WhisperFeatureExtractor) を使用して取得できます。詳細は [WhisperFeatureExtractor.__call__()](/docs/transformers/v5.23.0/ja/model_doc/whisper#transformers.WhisperFeatureExtractor.__call__) を参照してください（[WhisperProcessor](/docs/transformers/v5.23.0/ja/model_doc/whisper#transformers.WhisperProcessor) は音声の処理に [WhisperFeatureExtractor](/docs/transformers/v5.23.0/ja/model_doc/whisper#transformers.WhisperFeatureExtractor) を使用します）。 attention_mask (`torch.LongTensor`、shape `(batch_size, sequence_length)`、*任意*) : padding トークンインデックスに対する attention を行わないためのマスク。`[0, 1]` から選択されるマスク値: - **マスクされない**トークンは 1、- **マスクされる**トークンは 0。 [attention マスクとは?](../glossary#attention-mask) decoder_input_ids (`torch.LongTensor`、形状 `(batch_size, target_sequence_length)`、*任意*) : 語彙におけるデコーダー入力シーケンスのトークンインデックス。[WhisperTokenizer](/docs/transformers/v5.23.0/ja/model_doc/whisper#transformers.WhisperTokenizer) を使用してインデックスを取得できます。詳細は [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/ja/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) および [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/ja/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) を参照してください。[デコーダー入力 ID とは何か？](../glossary#decoder-input-ids) Whisper は `decoder_input_ids` の生成の開始トークンとして `decoder_start_token_id` を使用します。`past_key_values` を使用する場合、オプションとして最後の `decoder_input_ids` だけを入力すれば十分です（`past_key_values` を参照）。 decoder_attention_mask (`torch.LongTensor`、形状 `(batch_size, target_sequence_length)`、*任意*) : デフォルトの動作: `decoder_input_ids` 内の pad トークンを無視するテンソルを生成します。デフォルトでは、カウザルマスクも使用されます。パディングの動作を変更する場合は、`modeling_whisper._prepare_decoder_attention_mask` を読み、必要に応じて修正してください。デフォルトの戦略に関する詳細は、[BART の論文](https://huggingface.co/papers/1910.13461) の図 1 を参照してください。 encoder_outputs (`tuple[tuple[torch.Tensor]]`, *任意*) : (`last_hidden_state`, *任意*: `hidden_states`, *任意*: `attentions`) のタプルです。`last_hidden_state` は形状 `(batch_size, sequence_length, hidden_size)` を持ち、*任意* です。エンコーダーの最終層の出力における隠れ状態のシーケンスです。デコーダーのクロスアテンションで使用されます。 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/v5.23.0/ja/internal/generation_utils#transformers.Cache) インスタンスのみです。[kv cache ガイド](https://huggingface.co/docs/transformers/en/kv_cache)を参照してください。`past_key_values` が渡されない場合、デフォルトで [DynamicCache](/docs/transformers/v5.23.0/ja/internal/generation_utils#transformers.DynamicCache) が初期化されます。モデルは、入力として与えられたのと同じキャッシュ形式を出力します。`past_key_values` を使用する場合は、すべての `input_ids`（形状 `(batch_size, sequence_length)`）の代わりに、このモデルに過去の key value 状態が与えられていない未処理の `input_ids`（形状 `(batch_size, unprocessed_length)`）のみを入力する必要があります。 decoder_inputs_embeds (`tuple[torch.Tensor]`、形状 `(batch_size, target_sequence_length, hidden_size)`、*任意*) : `decoder_input_ids` を渡す代わりに、埋め込み表現を直接渡すこともできます。`past_key_values` を使用する場合、`decoder_inputs_embeds` の最後の部分のみを入力すればよい場合があります（`past_key_values` を参照）。`decoder_input_ids` のインデックスを関連するベクトルに変換する方法を、モデル内部の埋め込み検索行列よりも細かく制御したい場合に便利です。 `decoder_input_ids` と `decoder_inputs_embeds` の両方が設定されていない場合、`decoder_inputs_embeds` は `inputs_embeds` の値を取ります。 decoder_position_ids (`torch.LongTensor`、shape `(batch_size, sequence_length)`、*任意*) : 各入力シーケンスのトークンが位置埋め込み内で占める位置のインデックスです。`[0, config.n_positions - 1]` の範囲から選択されます。 [位置 ID とは何か？](../glossary#position-ids) labels (`torch.LongTensor`、形状 `(batch_size, sequence_length)`、*任意*) : 言語モデリング損失を計算するためのラベル。インデックスは `[0, ..., config.vocab_size]` の範囲内であるか、-100 である必要があります（`input_ids` のドキュメント文字列を参照）。インデックスが `-100` に設定されたトークンは無視（マスク）され、損失は `[0, ..., config.vocab_size]` の範囲内のラベルを持つトークンのみに対して計算されます。`sequence_length` は `config.max_target_positions` 以下である必要があります。 use_cache (`bool`, *任意*) : `True`に設定すると、`past_key_values`のキーバリュー状態が返され、デコーディングの高速化に利用できます（`past_key_values`を参照）。 **戻り値:** [Seq2SeqLMOutput](/docs/transformers/v5.23.0/ja/main_classes/output#transformers.modeling_outputs.Seq2SeqLMOutput) または `tuple(torch.Tensor)` 設定（[WhisperConfig](/docs/transformers/v5.23.0/ja/model_doc/whisper#transformers.WhisperConfig)）と入力に応じて、さまざまな要素で構成される、[Seq2SeqLMOutput](/docs/transformers/v5.23.0/ja/main_classes/output#transformers.modeling_outputs.Seq2SeqLMOutput)または`torch.Tensor`のタプル（`return_dict=False`が渡された場合、または`config.return_dict=False`の場合）。 [WhisperForConditionalGeneration](/docs/transformers/v5.23.0/ja/model_doc/whisper#transformers.WhisperForConditionalGeneration)のforwardメソッドは、`__call__`特殊メソッドをオーバーライドします。 この関数内でフォワードパスの手順を定義する必要がありますが、その後、この関数ではなく`Module`インスタンスを呼び出すべきです。前者は前処理と後処理の実行を適切に処理するのに対し、後者はそれらを無視してしまいます。 - **loss** (`torch.Tensor`、形状 `(1,)`、*任意*、`labels` が指定された場合に返されます) -- 言語モデリングの損失。 - **logits** (`torch.Tensor`、形状 `(batch_size, sequence_length, config.vocab_size)`) -- 言語モデリングヘッドの予測スコア（SoftMax 適用前の各語彙トークンのスコア）。 - **past_key_values** (`EncoderDecoderCache`、*任意*、`use_cache=True` が渡された場合または `config.use_cache=True` の場合に返されます) -- [EncoderDecoderCache](/docs/transformers/v5.23.0/ja/internal/generation_utils#transformers.EncoderDecoderCache) のインスタンスです。詳細については、[kv cache ガイド](https://huggingface.co/docs/transformers/en/kv_cache)を参照してください。 逐次デコーディングを高速化するために使用できる（`past_key_values` 入力参照）、事前計算済みの隠れ状態（自己アテンションブロックおよびクロスアテンションブロックのキーとバリュー）が含まれます。 - **decoder_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)` です。 各層の出力および初期埋め込み出力における、デコーダーの隠れ状態。 - **decoder_attentions** (`tuple(torch.Tensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) -- `torch.Tensor` のタプル（各レイヤーごとに1つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)`。 自己アテンションヘッドにおける加重平均を計算するために使用される、アテンションのsoftmax後のデコーダーのアテンション重み。 - **cross_attentions** (`tuple(torch.Tensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) -- `torch.Tensor` のタプル（各レイヤーごとに1つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)`。 クロスアテンション層のアテンション重みは、アテンションのsoftmax適用後に計算され、クロスアテンションヘッドにおける加重平均の計算に使用されます。 - **encoder_last_hidden_state** (`torch.Tensor`、形状 `(batch_size, sequence_length, hidden_size)`、*任意*) -- モデルのエンコーダーの最終層の出力における隠れ状態のシーケンス。 - **encoder_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)` です。 各層の出力および初期埋め込み出力におけるエンコーダーの隠れ状態。 - **encoder_attentions** (`tuple(torch.Tensor)`、*任意*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) -- 各レイヤーごとに 1 つの `torch.Tensor` からなるタプルで、形状は `(batch_size, num_heads, sequence_length, sequence_length)` です。 アテンションのsoftmaxを適用した後のエンコーダーのアテンション重み。自己アテンションヘッドにおける加重平均の計算に使用されます。 例: ```python >>> import torch >>> from transformers import AutoProcessor, WhisperForConditionalGeneration >>> from datasets import load_dataset >>> processor = AutoProcessor.from_pretrained("openai/whisper-tiny.en") >>> model = WhisperForConditionalGeneration.from_pretrained("openai/whisper-tiny.en") >>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation") >>> inputs = processor(ds[0]["audio"]["array"], return_tensors="pt") >>> input_features = inputs.input_features >>> generated_ids = model.generate(inputs=input_features) >>> transcription = processor.batch_decode(generated_ids, skip_special_tokens=True)[0] >>> transcription ' Mr. Quilter is the apostle of the middle classes, and we are glad to welcome his gospel.' ``` #### generate[[transformers.WhisperForConditionalGeneration.generate]] ```python generate(input_features: typing.Optional[torch.Tensor] = None, generation_config: transformers.generation.configuration_utils.GenerationConfig | None = None, logits_processor: transformers.generation.logits_process.LogitsProcessorList | None = None, stopping_criteria: transformers.generation.stopping_criteria.StoppingCriteriaList | None = None, prefix_allowed_tokens_fn: collections.abc.Callable[[int, torch.Tensor], list[int]] | None = None, synced_gpus: bool = False, return_timestamps: bool | None = None, task: str | None = None, language: str | list[str] | None = None, is_multilingual: bool | None = None, prompt_ids: typing.Optional[torch.Tensor] = None, prompt_condition_type: str | None = None, condition_on_prev_tokens: bool | None = None, temperature: float | tuple[float, ...] | None = None, compression_ratio_threshold: float | None = None, logprob_threshold: float | None = None, no_speech_threshold: float | None = None, num_segment_frames: int | None = None, attention_mask: typing.Optional[torch.Tensor] = None, time_precision: float = 0.02, time_precision_features: float = 0.01, return_token_timestamps: bool | None = None, return_segments: bool = False, return_dict_in_generate: bool | None = None, force_unique_generate_call: bool | None = None, monitor_progress: collections.abc.Callable[[torch.Tensor], None] | None = None, **kwargs) ``` [ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/whisper/generation_whisper.py#L383) **パラメータ:** input_features (`torch.Tensor`、shape `(batch_size, feature_size, sequence_length)`、*任意*) : 生の音声波形から抽出された log-mel 特徴量の浮動小数点数値。生の音声波形は、`.flac` または `.wav` 形式のオーディオファイルを `list[float]`、`numpy.ndarray`、または `torch.Tensor` 型の配列として読み込むことで取得できます。*例えば*、torchcodec ライブラリ（`pip install torchcodec`）や soundfile ライブラリ（`pip install soundfile`）を通じて行います。`input_features` として配列を準備するには、mel 特徴量の抽出、パディング、および `torch.Tensor` 型への変換を行うために [AutoFeatureExtractor](/docs/transformers/v5.23.0/ja/model_doc/auto#transformers.AutoFeatureExtractor) を使用してください。詳細は [__call__()](/docs/transformers/v5.23.0/ja/model_doc/whisper#transformers.WhisperFeatureExtractor.__call__) を参照してください。 generation_config ([GenerationConfig](/docs/transformers/v5.23.0/ja/main_classes/text_generation#transformers.GenerationConfig), *optional*) : 生成呼び出しのベースパラメータ化として使用される生成設定。`generation_config` の属性と一致する `**kwargs` が generate に渡された場合、それらは上書きされます。`generation_config` が指定されない場合、デフォルトが使用されます。その読み込み優先順位は以下の通りです: 1) `generation_config.json` モデルファイルが存在する場合、そこから読み込む; 2) モデル設定から読み込む。未指定のパラメータは [GenerationConfig](/docs/transformers/v5.23.0/ja/main_classes/text_generation#transformers.GenerationConfig) のデフォルト値を継承することに注意してください。生成をパラメータ化するには、そのドキュメントを確認する必要があります。 logits_processor (`LogitsProcessorList`, *任意*) : 引数や生成設定から構築されるデフォルトの logits プロセッサを補完する、カスタムの logits プロセッサです。引数や生成設定で既に作成済みの logits プロセッサが渡された場合、エラーが発生します。この機能は上級ユーザー向けです。 stopping_criteria (`StoppingCriteriaList`, *任意*) : 引数と生成設定から構築されるデフォルトの停止条件を補完する、カスタムの停止条件です。引数や生成設定からすでに作成された停止条件が渡された場合、エラーが発生します。この機能は上級ユーザー向けです。 prefix_allowed_tokens_fn (`Callable[[int, torch.Tensor], list[int]]`、*任意*) : 指定された場合、この関数はビームサーチを各ステップで許可されたトークンのみに制限します。指定されない場合、制約は適用されません。この関数は2つの引数を受け取ります: バッチID `batch_id` と `input_ids`。バッチID `batch_id` と以前に生成されたトークン `inputs_ids` に条件付けられた次の生成ステップの許可トークンのリストを返す必要があります。この引数は、[Autoregressive Entity Retrieval](https://huggingface.co/papers/2010.00904) に記載されているような、プレフィックスに条件付けられた制約付き生成に有用です。 synced_gpus (`bool`、*任意*、デフォルトは`False`) : `FullyShardedDataParallel`およびDeepSpeed ZeRO Stage 3でのデッドロックを回避するために必要です。max_lengthに達するまでwhileループの実行を継続するかどうかを指定します。 return_timestamps (`bool`, *任意*) : テキストとともにタイムスタンプを返すかどうか。これにより`WhisperTimestampsLogitsProcessor`が有効になります。30秒を超える音声の場合、`return_timestamps=True`を設定する必要があります。 task (`str`, *任意*) : 生成に使用するタスク。"translate" または "transcribe" のいずれかです。 language (`str` または `str` のリスト、*任意*) : 生成に使用する言語トークンです。`<|en|>`、`en`、または `english` のいずれかの形式で指定できます。バッチ生成を行う場合は、言語トークンのリストを渡すことができます。使用可能なすべての言語トークンは、`model.generation_config.lang_to_id` ディクショナリで確認できます。 is_multilingual (`bool`, *任意*) : モデルが多言語対応かどうかを示します。 prompt_ids (`torch.Tensor`, *任意*) : `get_prompt_ids()` にテキストを渡して作成される、トークン ID の Rank-1 テンソルです。各チャンクのプロンプトとして提供されます。これにより、文字起こしのためのコンテキストを提供したり、「プロンプトエンジニアリング」を行ったりできます。例えば、カスタム語彙や固有名詞を指定することで、それらの単語を正しく予測する可能性を高めることができます。`decoder_start_token_id` と併用することはできません。この値を上書きするためです。 prompt_condition_type (`str`, *任意*) : 長文転写の場合のみ関連します。`prompt_ids`の条件付けタイプです。'first-segment' は、最初のセグメントのみが`prompt_ids`の条件付けの対象であることを意味します。'all-segments' は、各セグメントが`prompt_ids`の条件付けの対象であることを意味します。'all-segments' を使用する場合は、`condition_on_prev_tokens`を有効にしてください。デフォルトは 'first-segment' です。短文転写の場合、'first-segment' のみ可能です。 condition_on_prev_tokens (`bool`, *任意*) : 長文の文字起こしでのみ関連します。各セグメントを直前のセグメントに条件付けするかどうか。[Whisper の論文](https://cdn.openai.com/papers/whisper.pdf)に示されているように、これによりパフォーマンスを向上させることができます。 temperature (`float` または `float` のリスト、*任意*) : 生成に使用する温度です。単一の `float` 値と `do_sample=True` を渡すと、サンプリングを用いた生成が有効になります。長文の文字起こしでは、(0.0, 0.2, 0.4, 0.6, 0.8, 1.0) のような float 値のリストを渡すことで、温度フォールバックを有効にできます。[Whisper の論文](https://cdn.openai.com/papers/whisper.pdf) に示されているように、これによりパフォーマンスを向上させることができます。 compression_ratio_threshold (`float`, *任意*) : 長文の文字起こしでのみ関連します。定義されている場合、各セグメントの zlib 圧縮率が計算されます。セグメントの圧縮率が `compression_ratio_threshold` より高い場合、temperature フォールバックが有効になります。生成されたセグメントは破棄され、より高い temperature を使用して生成が繰り返されます。この機能の根拠は、圧縮率が非常に高いセグメントは多くの反復に苦しむという点です。temperature を上げてランダム性を高めることで、不要な反復を減らすことができます。`compression_ratio_threshold` が定義されている場合は、`temperature` が値のリストであることを確認してください。`compression_ratio_threshold` の一般的な値は 1.35 です。[Whisper の論文](https://cdn.openai.com/papers/whisper.pdf)に示されているように、これによりパフォーマンスを向上させることができます。 logprob_threshold (`float`, *任意*) : 長文の文字起こしでのみ関連します。定義されている場合、各セグメントの平均対数尤度が計算されます。特定のセグメントの対数尤度が`logprob_threshold`より低い場合、温度フォールバックが有効になります。生成されたセグメントは破棄され、より高い温度を使用して生成が繰り返されます。この機能の根底にある考え方は、対数尤度の低いセグメントは、温度を上げてより多くのランダム性を注入することで改善できるというものです。`logprob_threshold`が定義されている場合は、`temperature`が値のリストであることを確認してください。`logprob_threshold`の一般的な値は-1.0です。[Whisper論文](https://cdn.openai.com/papers/whisper.pdf)に示されているように、これによりパフォーマンスを向上させることができます。 no_speech_threshold (`float`, *任意*) : 長文の文字起こしでのみ関連します。定義されている場合、"no-speech" トークンと `logprob_threshold` を組み合わせて、セグメントが沈黙のみを含むかどうかを判定します。この場合、該当セグメントの文字起こしはスキップされます。[Whisper の論文](https://cdn.openai.com/papers/whisper.pdf) に示されているように、これによりパフォーマンスを向上させることができます。 num_segment_frames (`int`, *optional*) : 1つのセグメントを構成するフレーム数です。定義されていない場合、`num_segment_frames`はモデルのストライドに最大入力長を掛けた値がデフォルトとして使用されます。 attention_mask (`torch.Tensor`, *任意*) : バッチサイズが 1 より大きい場合の長文転写を行うには、`attention_mask` を渡す必要があります。 time_precision (`int`, *任意*、デフォルトは 0.02) : 出力トークンの秒数です。*例えば*、0.02 は、生成されたトークンが平均して 20 ms を占めることを意味します。 time_precision_features (`int`、*optional*、デフォルトは 0.01) : 特徴フレームが表す秒数。 return_token_timestamps (`bool`, *任意*) : テキストとともにトークンレベルのタイムスタンプを返すかどうか。`return_timestamps`オプションの有無にかかわらず使用できます。単語レベルのタイムスタンプを取得するには、トークナイザを使用してトークンを単語にグループ化してください。 return_segments (`bool`、*任意*、デフォルトは`False`) : すべてのセグメントのリストを返すかどうか。このオプションは、長文の文字起こしを行う場合にのみ有効にできます。 return_dict_in_generate (`bool`、*任意*、デフォルトは`False`) : 生成されたトークンを返すだけでなく、[ModelOutput](/docs/transformers/v5.23.0/ja/main_classes/output#transformers.utils.ModelOutput)を返すかどうかを指定します。長文の文字起こしを行う場合、`return_dict_in_generate`は`return_segments`がTrueに設定されている場合のみ有効になります。この場合、各セグメントの生成出力が各セグメントに追加されます。 force_unique_generate_call (`bool`, *任意*) : 基底の GenerationMixin の [generate()](/docs/transformers/v5.23.0/ja/main_classes/text_generation#transformers.GenerationMixin.generate) メソッドへの呼び出しを一意に強制するかどうか。これは、アシストデコーディングやテストの目的で、[generate()](/docs/transformers/v5.23.0/ja/main_classes/text_generation#transformers.GenerationMixin.generate) への呼び出しが1回のみ行われることを保証し、それによりデコーダーの入力トークンIDとeosトークンIDが返されることを確認するために有用です。 monitor_progress (`Callable[[torch.Tensor], None]`, *任意*) : 指定された場合、この関数を呼び出して音声転写の進捗を報告できます。この関数は、テンソル引数 `p` を受け取ります。その形状は `(n, 2)` で、`n` はバッチサイズです。`p[i, 0]` には、バッチ項目 `i` について現在転写されている音声フレームのインデックスが含まれます。`p[i, 1]` には、バッチ項目 `i` のフレームの総数が含まれます。戻り値は期待されていません。 kwargs (`dict[str, Any]`、*任意*) : `generate_config` のアドホックなパラメータ化、および/またはモデルの `forward` 関数に転送される追加のモデル固有の kwargs です。モデルがエンコーダー・デコーダーモデルの場合、エンコーダー固有の kwargs にはプレフィックスを付与せず、デコーダー固有の kwargs には *decoder_* をプレフィックスとして付与してください。 **戻り値:** [ModelOutput](/docs/transformers/v5.23.0/ja/main_classes/output#transformers.utils.ModelOutput) または `dict[str, Any]` または `torch.LongTensor` 次のいずれか: - `return_dict_in_generate=True` かつ (`return_timestamps=False` または `force_unique_generate_call=True`) の場合、[ModelOutput](/docs/transformers/v5.23.0/ja/main_classes/output#transformers.utils.ModelOutput) を返します。デコーダーの入力 ID とシーケンス終了 ID を含みます。 - `dict[str, Any]`（`return_dict_in_generate=True` かつ `return_timestamps=True` の場合、または `return_segments=True` または `return_token_timestamps=True` の場合）。 - デコーダー入力IDおよびシーケンス終了IDを除く、その他のすべてのケースでは`torch.LongTensor`です。 考えられる[ModelOutput](/docs/transformers/v5.23.0/ja/main_classes/output#transformers.utils.ModelOutput)の型は以下の通りです: - [GenerateEncoderDecoderOutput](/docs/transformers/v5.23.0/ja/internal/generation_utils#transformers.generation.GenerateEncoderDecoderOutput) - [GenerateBeamEncoderDecoderOutput](/docs/transformers/v5.23.0/ja/internal/generation_utils#transformers.generation.GenerateBeamEncoderDecoderOutput) `segments` は、`segment` のリストのリスト（バッチ要素ごとに1つのリスト）です。`segment` は、キーとして `start`、`end`、`tokens`、`idxs`、`result` を持つ辞書です。 - `start`: セグメントの開始タイムスタンプ。 - `end`: セグメントの終了タイムスタンプ。 - `tokens`: セグメントのトークン。デコーダー入力IDおよびシーケンス終了IDは除外されます。 - `idxs`: `result` に含まれる、GenerationMixin の [generate()](/docs/transformers/v5.23.0/ja/main_classes/text_generation#transformers.GenerationMixin.generate) への元の呼び出しにおける、そのセグメントの `tokens` の開始インデックス（含む）と終了インデックス（含まない）。 - `result`: [generate()](/docs/transformers/v5.23.0/ja/main_classes/text_generation#transformers.GenerationMixin.generate)への下層呼び出しの結果。 `return_timestamps=True`の場合、`return_dict_in_generate=True`は、基底のGenerationMixinの[generate()](/docs/transformers/v5.23.0/ja/main_classes/text_generation#transformers.GenerationMixin.generate)の各呼び出しに適用され、出力は各`segment`の`result`に格納されます。 log-mel入力特徴を、自己回帰的に生成されたトークンIDのシーケンスに転写または翻訳します。 生成を制御するほとんどのパラメータは`generation_config`で設定されます。この引数が渡されない場合、モデルのデフォルトの生成設定が使用されます。`generation_config`の任意の値は、generate()に該当するパラメータを渡すことで上書きできます。例: `.generate(inputs, num_beams=4, do_sample=True)`。 生成戦略の概要とコード例については、[次のガイド](../generation_strategies)を参照してください。 例: - *長尺トランスクリプション*: 30秒を超える音声の文字起こしまたは翻訳を行う場合は、音声を切り詰めずに処理し、すべてのmel特徴量を一度にgenerateに渡します。`return_timestamps=True`を設定する必要があります。 実際、長文の文字起こしは、タイムスタンプの予測に基づく逐次アルゴリズムを使用しており、圧縮率の閾値、対数尤度の閾値、温度フォールバックなどのヒューリスティックが用いられます。このアルゴリズムは、[Whisperの原著論文](https://cdn.openai.com/papers/whisper.pdf)の*3.8節「Long-form Transcription」*で説明されています。 ```python >>> import torch >>> from transformers import AutoProcessor, WhisperForConditionalGeneration >>> from datasets import load_dataset, Audio >>> processor = AutoProcessor.from_pretrained("openai/whisper-tiny.en") >>> model = WhisperForConditionalGeneration.from_pretrained("openai/whisper-tiny.en") >>> model.cuda() >>> # load audios > 30 seconds >>> ds = load_dataset("distil-whisper/meanwhile", "default")["test"] >>> # resample to 16kHz >>> ds = ds.cast_column("audio", Audio(sampling_rate=16000)) >>> # take first 8 audios and retrieve array >>> audio = ds[:8]["audio"] >>> audio = [x["array"] for x in audio] >>> # make sure to NOT truncate the input audio, to return the `attention_mask` and to pad to the longest audio >>> inputs = processor(audio, return_tensors="pt", truncation=False, padding="longest", return_attention_mask=True, sampling_rate=16_000) >>> inputs = inputs.to("cuda", torch.float32) >>> # transcribe audio to ids >>> generated_ids = model.generate(**inputs, return_timestamps=True) >>> transcription = processor.batch_decode(generated_ids, skip_special_tokens=True) >>> transcription[0] " Folks, if you watch the show, you know, I spent a lot of time right over there. Patiently and astutely scrutinizing the boxwood and mahogany chest set of the day's biggest stories developing the central headline pawns, definitely maneuvering an oso topical night to F6, fainting a classic Sicilian, nade door variation on the news, all the while seeing eight moves deep and patiently marshalling the latest press releases into a fisher's shows in Lip Nitsky attack that culminates in the elegant lethal slow-played, all-passant checkmate that is my nightly monologue. But sometimes, sometimes, folks, I. CHEERING AND APPLAUSE Sometimes I startle away, cubside down in the monkey bars of a condemned playground on a super fun site. Get all hept up on goofballs. Rummage that were discarded tag bag of defective toys. Yank out a fist bowl of disembodied doll limbs, toss them on a stained kid's place mat from a defunct dennies. set up a table inside a rusty cargo container down by the Wharf and challenged toothless drifters to the godless bughouse blitz of tournament that is my segment. Meanwhile." ``` `monitor_progress` コールバックは、文字起こしの進捗を監視するために使用できます。 ```python >>> from tqdm import tqdm >>> # prepare inputs like above >>> # define a callback to monitor the progress of the transcription. >>> with tqdm(desc="Progress") as pbar: >>> def monitor_progress(p_batch): >>> i = torch.argmax(p_batch[:, 1]) >>> p = p_batch[i].detach().cpu() >>> pbar.total = int(p[1]) >>> pbar.n = int(p[0]) >>> pbar.update() >>> # transcribe audio to ids >>> generated_ids = model.generate(**inputs, return_timestamps=True, monitor_progress=monitor_progress) >>> transcription = processor.batch_decode(generated_ids, skip_special_tokens=True) >>> transcription[0] Progress: 95%|█████████████████████████████████████████████████████████████████████████████████████████████████▎ | 8497/8901 [00:04<00:00, 2052.79it/s] " Folks, if you watch the show, you know, I spent a lot of time right over there. Patiently and astutely scrutinizing the boxwood and mahogany chest set of the day's biggest stories developing the central headline pawns, definitely maneuvering an oso topical night to F6, fainting a classic Sicilian, nade door variation on the news, all the while seeing eight moves deep and patiently marshalling the latest press releases into a fisher's shows in Lip Nitsky attack that culminates in the elegant lethal slow-played, all-passant checkmate that is my nightly monologue. But sometimes, sometimes, folks, I. CHEERING AND APPLAUSE Sometimes I startle away, cubside down in the monkey bars of a condemned playground on a super fun site. Get all hept up on goofballs. Rummage that were discarded tag bag of defective toys. Yank out a fist bowl of disembodied doll limbs, toss them on a stained kid's place mat from a defunct dennies. set up a table inside a rusty cargo container down by the Wharf and challenged toothless drifters to the godless bughouse blitz of tournament that is my segment. Meanwhile." ``` - *ショートフォーム転写*: 渡されたメル入力特徴が30秒以下の場合、2つの可能性があります: - `return_timestamps=False`: 音声全体が、GenerationMixinの[generate()](/docs/transformers/v5.23.0/ja/main_classes/text_generation#transformers.GenerationMixin.generate)への単一の呼び出しによって書き起こされます。 - `return_timestamps=True`: 音声は、長尺トランスクリプションと同じロジックを使用して文字起こしされます。 ```python >>> import torch >>> from transformers import AutoProcessor, WhisperForConditionalGeneration >>> from datasets import load_dataset >>> processor = AutoProcessor.from_pretrained("openai/whisper-tiny.en") >>> model = WhisperForConditionalGeneration.from_pretrained("openai/whisper-tiny.en") >>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation") >>> inputs = processor(ds[0]["audio"]["array"], return_tensors="pt") >>> input_features = inputs.input_features >>> generated_ids = model.generate(inputs=input_features) >>> transcription = processor.batch_decode(generated_ids, skip_special_tokens=True)[0] >>> transcription ' Mr. Quilter is the apostle of the middle classes, and we are glad to welcome his gospel.' ``` ## WhisperForCausalLM[[transformers.WhisperForCausalLM]] #### transformers.WhisperForCausalLM[[transformers.WhisperForCausalLM]] ```python transformers.WhisperForCausalLM(config: WhisperConfig) ``` [ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/whisper/modeling_whisper.py#L1171) **パラメータ:** config ([WhisperConfig](/docs/transformers/v5.23.0/ja/model_doc/whisper#transformers.WhisperConfig)) : モデルのパラメータをすべて含むモデル設定クラスです。設定ファイルで初期化しても、モデルに関連する重みは読み込まれず、設定のみが読み込まれます。モデルの重みをロードするには、[from_pretrained()](/docs/transformers/v5.23.0/ja/main_classes/model#transformers.PreTrainedModel.from_pretrained) メソッドを確認してください。 Whisperデコーダーの上部に言語モデリングヘッド（入力埋め込みの重みと共有される線形層）を備えた構成。 このモデルは [PreTrainedModel](/docs/transformers/v5.23.0/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.WhisperForCausalLM.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, encoder_outputs: tuple[torch.Tensor] | None = 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, **kwargs) ``` [ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/whisper/modeling_whisper.py#L1197) **パラメータ:** input_ids (`torch.LongTensor`、shape `(batch_size, sequence_length)`、*任意*) : 語彙における入力シーケンスのトークンインデックスです。デフォルトでは、パディングは無視されます。インデックスは [AutoTokenizer](/docs/transformers/v5.23.0/ja/model_doc/auto#transformers.AutoTokenizer) を使用して取得できます。詳細については、[PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/ja/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) および [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/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) encoder_outputs (`torch.Tensor`、形状 `(batch_size, sequence_length, hidden_size)`、*任意*) : エンコーダーの最終層の出力における隠れ状態のシーケンス。モデルがデコーダーとして設定されている場合、クロスアテンションで使用されます。 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/v5.23.0/ja/internal/generation_utils#transformers.Cache) インスタンスのみです。[kv cache ガイド](https://huggingface.co/docs/transformers/en/kv_cache)を参照してください。`past_key_values` が渡されない場合、デフォルトで [DynamicCache](/docs/transformers/v5.23.0/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)`、*任意*) : 言語モデリング損失の計算に使用するラベル。インデックスは `[0, ..., config.vocab_size]` の範囲内、または -100 である必要があります（`input_ids` のドキュメント文字列を参照）。インデックスが `-100` に設定されたトークンは無視（マスク）され、損失は `[0, ..., config.vocab_size]` の範囲内のラベルを持つトークンに対してのみ計算されます。モデル内部ではラベルは**シフトされません**。`labels[..., i]` は `logits[..., i, :]` のターゲットとなるため、次のトークン予測を行う場合は、ラベルは `input_ids` に対して既に 1 位置左にシフトされている必要があります。 use_cache (`bool`, *任意*) : `True`に設定すると、`past_key_values`のキーバリュー状態が返され、デコーディングの高速化に利用できます（`past_key_values`を参照）。 **戻り値:** [CausalLMOutputWithCrossAttentions](/docs/transformers/v5.23.0/ja/main_classes/output#transformers.modeling_outputs.CausalLMOutputWithCrossAttentions) または `tuple(torch.Tensor)` A [CausalLMOutputWithCrossAttentions](/docs/transformers/v5.23.0/ja/main_classes/output#transformers.modeling_outputs.CausalLMOutputWithCrossAttentions) or a tuple of `torch.Tensor` (if `return_dict=False` is passed or when `config.return_dict=False`) comprising various elements depending on the configuration ([WhisperConfig](/docs/transformers/v5.23.0/ja/model_doc/whisper#transformers.WhisperConfig)) and inputs. [WhisperForCausalLM](/docs/transformers/v5.23.0/ja/model_doc/whisper#transformers.WhisperForCausalLM)のforwardメソッドは、`__call__`特殊メソッドをオーバーライドします。 この関数内でフォワードパスの手順を定義する必要がありますが、その後、この関数ではなく`Module`インスタンスを呼び出すべきです。前者は前処理と後処理の実行を適切に処理するのに対し、後者はそれらを無視してしまいます。 - **loss** (`torch.Tensor`、形状 `(1,)`、*任意*、`labels` が指定された場合に返されます) -- 言語モデリングの損失(次のトークンの予測用)。 - **logits** (`torch.Tensor`、形状 `(batch_size, sequence_length, config.vocab_size)`) -- 言語モデリングヘッドの予測スコア（SoftMax 適用前の各語彙トークンのスコア）。 - **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後のアテンション重み。自己アテンションヘッド内で加重平均を計算するために使用されます。 - **cross_attentions** (`tuple(torch.Tensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) -- `torch.Tensor` のタプル（各レイヤーごとに1つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)`。 クロスアテンションのsoftmax後の重み。クロスアテンションヘッドにおける加重平均の計算に使用されます。 - **past_key_values** (`Cache`、*任意*、`use_cache=True` が渡された場合または `config.use_cache=True` の場合に返されます) -- [Cache](/docs/transformers/v5.23.0/ja/internal/generation_utils#transformers.Cache) のインスタンスです。詳細については、[kv cache ガイド](https://huggingface.co/docs/transformers/en/kv_cache)を参照してください。 シーケンシャルなデコーディングを高速化するために使用できる（`past_key_values` 入力参照）、事前計算済みの hidden-states（アテンションブロック内のキーとバリュー）が含まれます。 例: ```python >>> from transformers import WhisperForCausalLM, WhisperForConditionalGeneration, WhisperProcessor >>> import torch >>> from datasets import load_dataset >>> processor = WhisperProcessor.from_pretrained("openai/whisper-large-v2") >>> model = WhisperForConditionalGeneration.from_pretrained("openai/whisper-large-v2") >>> assistant_model = WhisperForCausalLM.from_pretrained("distil-whisper/distil-large-v2") >>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation") >>> sample = ds[0]["audio"] >>> input_features = processor( ... sample["array"], sampling_rate=sample["sampling_rate"], return_tensors="pt" ... ).input_features >>> predicted_ids = model.generate(input_features, assistant_model=assistant_model) >>> # decode token ids to text >>> transcription = processor.batch_decode(predicted_ids, skip_special_tokens=True)[0] >>> transcription ' Mr. Quilter is the apostle of the middle classes and we are glad to welcome his gospel.' ``` ## WhisperForAudioClassification[[transformers.WhisperForAudioClassification]] #### transformers.WhisperForAudioClassification[[transformers.WhisperForAudioClassification]] ```python transformers.WhisperForAudioClassification(config: WhisperConfig) ``` [ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/whisper/modeling_whisper.py#L1288) **パラメータ:** config ([WhisperConfig](/docs/transformers/v5.23.0/ja/model_doc/whisper#transformers.WhisperConfig)) : モデルのパラメータをすべて含むモデル設定クラスです。設定ファイルで初期化しても、モデルに関連する重みは読み込まれず、設定のみが読み込まれます。モデルの重みをロードするには、[from_pretrained()](/docs/transformers/v5.23.0/ja/main_classes/model#transformers.PreTrainedModel.from_pretrained) メソッドを確認してください。 SUPERB Keyword Spottingなどのタスク向けに、プーリングされた出力の上に線形層を配置したシーケンス分類ヘッドを備えたWhisper Encoder Model。 このモデルは [PreTrainedModel](/docs/transformers/v5.23.0/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.WhisperForAudioClassification.forward]] ```python forward(input_features: typing.Optional[torch.LongTensor] = None, encoder_outputs: tuple[tuple[torch.Tensor]] | None = None, labels: typing.Optional[torch.LongTensor] = None, **kwargs) ``` [ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/whisper/modeling_whisper.py#L1315) **パラメータ:** input_features (`torch.LongTensor`、形状 `(batch_size, sequence_length, feature_dim)`、*任意*) : 入力音声特徴に対応するテンソルです。音声特徴は [WhisperFeatureExtractor](/docs/transformers/v5.23.0/ja/model_doc/whisper#transformers.WhisperFeatureExtractor) を使用して取得できます。詳細は [WhisperFeatureExtractor.__call__()](/docs/transformers/v5.23.0/ja/model_doc/whisper#transformers.WhisperFeatureExtractor.__call__) を参照してください（[WhisperProcessor](/docs/transformers/v5.23.0/ja/model_doc/whisper#transformers.WhisperProcessor) は音声の処理に [WhisperFeatureExtractor](/docs/transformers/v5.23.0/ja/model_doc/whisper#transformers.WhisperFeatureExtractor) を使用します）。 encoder_outputs (`tuple[tuple[torch.Tensor]]`, *任意*) : (`last_hidden_state`, *任意*: `hidden_states`, *任意*: `attentions`) のタプルです。`last_hidden_state` は形状 `(batch_size, sequence_length, hidden_size)` を持ち、*任意* です。エンコーダーの最終層の出力における隠れ状態のシーケンスです。デコーダーのクロスアテンションで使用されます。 labels (`torch.LongTensor`、形状 `(batch_size,)`、*任意*) : シーケンス分類/回帰の損失を計算するためのラベル。インデックスは `[0, ..., config.num_labels - 1]` の範囲である必要があります。`config.num_labels == 1` の場合は回帰損失（平均二乗誤差）が計算され、`config.num_labels > 1` の場合は分類損失（クロスエントロピー）が計算されます。 **戻り値:** [SequenceClassifierOutput](/docs/transformers/v5.23.0/ja/main_classes/output#transformers.modeling_outputs.SequenceClassifierOutput) または `tuple(torch.Tensor)` 設定（[WhisperConfig](/docs/transformers/v5.23.0/ja/model_doc/whisper#transformers.WhisperConfig)）や入力に応じて、さまざまな要素で構成される、[SequenceClassifierOutput](/docs/transformers/v5.23.0/ja/main_classes/output#transformers.modeling_outputs.SequenceClassifierOutput) または `torch.Tensor` のタプル（`return_dict=False` が渡された場合、または `config.return_dict=False` の場合）。 [WhisperForAudioClassification](/docs/transformers/v5.23.0/ja/model_doc/whisper#transformers.WhisperForAudioClassification)のforwardメソッドは、`__call__`特殊メソッドをオーバーライドします。 この関数内でフォワードパスの手順を定義する必要がありますが、その後、この関数ではなく`Module`インスタンスを呼び出すべきです。前者は前処理と後処理の実行を適切に処理するのに対し、後者はそれらを無視してしまいます。 - **loss** (`torch.Tensor`、shape `(1,)`、*optional*、`labels` が指定された場合に返されます) -- 分類損失（config.num_labels==1 の場合は回帰損失）。 - **logits** (`torch.Tensor`、形状 `(batch_size, config.num_labels)`) -- SoftMax 適用前の分類（または config.num_labels==1 の場合は回帰）スコア。 - **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後のアテンション重み。自己アテンションヘッド内で加重平均を計算するために使用されます。 例: ```python >>> import torch >>> from transformers import AutoFeatureExtractor, WhisperForAudioClassification >>> from datasets import load_dataset >>> feature_extractor = AutoFeatureExtractor.from_pretrained("sanchit-gandhi/whisper-medium-fleurs-lang-id") >>> model = WhisperForAudioClassification.from_pretrained("sanchit-gandhi/whisper-medium-fleurs-lang-id") >>> ds = load_dataset("google/fleurs", "all", split="validation", streaming=True) >>> sample = next(iter(ds)) >>> inputs = feature_extractor( ... sample["audio"]["array"], sampling_rate=sample["audio"]["sampling_rate"], return_tensors="pt" ... ) >>> input_features = inputs.input_features >>> with torch.no_grad(): ... logits = model(input_features).logits >>> predicted_class_ids = torch.argmax(logits).item() >>> predicted_label = model.config.id2label[predicted_class_ids] >>> predicted_label 'Afrikaans' ```