# MOSS-Transcribe-Diarize ## 概要 **MOSS-Transcribe-Diarize 0.9B**は、長時間の複数話者音声の文字起こし、話者分離、タイムスタンプ付与のためのエンドツーエンドの音声理解モデルです。Whisperスタイルのエンコーダー、4×フレームマージステップ、マルチモーダルプロジェクター、Qwen3言語モデルを組み合わせています。 モデルのチェックポイントは、[itazap/MOSS-Transcribe-Diarize-HF](https://huggingface.co/itazap/MOSS-Transcribe-Diarize-HF) で利用できます。 主な機能には、以下が含まれます。 * **同時転写と話者分離**を1パスで実行し、セグメントは`[start][S01]text[end]`の形式で出力されます。 * **長時間音声**は、プロセッサの上流でWhisperウィンドウチャンク分割により処理され、モデルがサンプルごとにチャンクを再構成します。 * `apply_transcription_request` またはチャットテンプレートによる**プロンプト可能な文字起こし**。 * 50以上の言語にわたる**多言語対応**。 このモデルは、Hugging Face チームの [Ita Zaporozhets](https://huggingface.co/itazap) によって提供されました。詳細については、[モデルカード](https://huggingface.co/itazap/MOSS-Transcribe-Diarize-HF) および [OpenMOSS リポジトリ](https://github.com/OpenMOSS/MOSS-Transcribe-Diarize) を参照してください。 ## 使用方法 > [!NOTE] > 以下のほとんどの例では、チャットテンプレートを構築する便利な関数である`apply_transcription_request`を使用しています。`apply_chat_template`の同等の呼び出しについては、[チャットテンプレートによる高度な使用法](#advanced-usage-with-the-chat-template)を参照してください。 ### 基本的な文字起こしと話者分離 各スピーカーのターンは、`[start][S0N]text[end]` セグメントとしてデコードされます。`processor.decode` は、生デコード文字列、辞書のリストとして解析されたセグメント（`return_format="parsed"`）、または連結された文字起こしのみ（`return_format="transcription_only"`）を返すことができます。 ```python from transformers import AutoProcessor, AutoModelForCausalLM model_id = "itazap/MOSS-Transcribe-Diarize-HF" processor = AutoProcessor.from_pretrained(model_id) model = AutoModelForCausalLM.from_pretrained(model_id, device_map="auto") audio_url = "https://huggingface.co/datasets/itazap/audio_samples/resolve/main/podcast_sample.wav" inputs = processor.apply_transcription_request(audio_url) inputs = inputs.to(model.device, dtype=model.dtype) outputs = model.generate(**inputs, do_sample=False, max_new_tokens=512) generated_ids = outputs[:, inputs.input_ids.shape[1] :] decoded = processor.decode(generated_ids, skip_special_tokens=True) print("RAW OUTPUT:", decoded) parsed = processor.decode(generated_ids, return_format="parsed")[0] print("\nPARSED (list of dicts):") for segment in parsed: print(segment) transcription = processor.decode(generated_ids, return_format="transcription_only") print("\nTRANSCRIPTION ONLY:", transcription[0]) """ RAW OUTPUT: ["[0.48][S01] Hey everyone, welcome back to the show.[2.43][2.46][S01] Today, we're talking about the best way to learn a new skill.[5.22][5.43][S01] I'm here with Jordan to dig into it.[7.14][8.40][S02] Thanks for having me.[9.42][9.63][S02] My take is that consistency beats intensity every single time.[12.87][13.14][S01] That makes sense.[13.92][13.92][S01] Even 20 minutes a day adds up over a few months.[16.17][16.32][S02] Exactly, and writing down small wins keeps you motivated along the way.[19.62]"] PARSED (list of dicts): {'Start': 0.48, 'End': 2.43, 'Speaker': 1, 'Content': 'Hey everyone, welcome back to the show.'} {'Start': 2.46, 'End': 5.22, 'Speaker': 1, 'Content': "Today, we're talking about the best way to learn a new skill."} {'Start': 5.43, 'End': 7.14, 'Speaker': 1, 'Content': "I'm here with Jordan to dig into it."} {'Start': 8.4, 'End': 9.42, 'Speaker': 2, 'Content': 'Thanks for having me.'} {'Start': 9.63, 'End': 12.87, 'Speaker': 2, 'Content': 'My take is that consistency beats intensity every single time.'} {'Start': 13.14, 'End': 13.92, 'Speaker': 1, 'Content': 'That makes sense.'} {'Start': 13.92, 'End': 16.17, 'Speaker': 1, 'Content': 'Even 20 minutes a day adds up over a few months.'} {'Start': 16.32, 'End': 19.62, 'Speaker': 2, 'Content': 'Exactly, and writing down small wins keeps you motivated along the way.'} TRANSCRIPTION ONLY: Hey everyone, welcome back to the show. Today, we're talking about the best way to learn a new skill. I'm here with Jordan to dig into it. Thanks for having me. My take is that consistency beats intensity every single time. That makes sense. Even 20 minutes a day adds up over a few months. Exactly, and writing down small wins keeps you motivated along the way. """ ``` ### カスタムプロンプトとホットワード `apply_transcription_request` は、特定の用語（固有名詞や分野固有の語彙など）への転写をバイアスさせるために `keywords` を受け取ります。これらはチャットテンプレート内で`热词列表：`（ホットワードリスト）としてレンダリングされます。追加のコンテキストとして、カスタムの `prompt` を同時に渡すこともできます。 以下では、"Yorùbá" に言及する音声クリップの文字起こしを行い、キーワードとして渡した場合と渡さなかった場合を比較します。 ```python from transformers import AutoProcessor, AutoModelForCausalLM model_id = "itazap/MOSS-Transcribe-Diarize-HF" processor = AutoProcessor.from_pretrained(model_id) model = AutoModelForCausalLM.from_pretrained(model_id, device_map="auto") audio_url = "https://huggingface.co/datasets/itazap/audio_samples/resolve/main/languages_sample.wav" # Without keywords inputs = processor.apply_transcription_request(audio_url) inputs = inputs.to(model.device, dtype=model.dtype) outputs = model.generate(**inputs, do_sample=False, max_new_tokens=128) transcription = processor.decode(outputs[:, inputs.input_ids.shape[1] :], return_format="transcription_only") print(f"WITHOUT keywords: {transcription[0]}") # With keywords inputs = processor.apply_transcription_request(audio_url, keywords=["Mandarin", "Yorùbá"]) inputs = inputs.to(model.device, dtype=model.dtype) outputs = model.generate(**inputs, do_sample=False, max_new_tokens=128) transcription = processor.decode(outputs[:, inputs.input_ids.shape[1] :], return_format="transcription_only") print(f"WITH keywords : {transcription[0]}") """ WITHOUT keywords: Let's talk about the most spoken languages in the world. Mandarin Chinese has the most native speakers, followed by Spanish, English, and Hindi. In West Africa, one of the most widely spoken languages is Yoruba, with over 50 million speakers. WITH keywords : Let's talk about the most spoken languages in the world. Mandarin Chinese has the most native speakers, followed by Spanish, English, and Hindi. In West Africa, one of the most widely spoken languages is Yorùbá, with over 50 million speakers. """ ``` ### チャットテンプレートを使った高度な使い方 `apply_transcription_request` は、オーディオのみを含むユーザーターンを持つチャットテンプレートと同等です。 ```python from transformers import AutoProcessor, AutoModelForCausalLM model_id = "itazap/MOSS-Transcribe-Diarize-HF" processor = AutoProcessor.from_pretrained(model_id) model = AutoModelForCausalLM.from_pretrained(model_id, device_map="auto") audio_url = "https://huggingface.co/datasets/itazap/audio_samples/resolve/main/intro_sample.wav" conversation = [ { "role": "user", "content": [ {"type": "audio", "url": audio_url}, ], }, ] inputs = processor.apply_chat_template( conversation, tokenize=True, add_generation_prompt=True, return_dict=True, ).to(model.device, dtype=model.dtype) outputs = model.generate(**inputs, do_sample=False, max_new_tokens=128) decoded = processor.decode( outputs[:, inputs.input_ids.shape[1] :], skip_special_tokens=True, ) print(decoded) ``` ### バッチ推論 オーディオのリストを渡し、必要に応じてプロンプトおよび/またはキーワードの対応するリストを渡すことで、1回の呼び出しでバッチを転写できます。特定のサンプルでスキップする場合は、そのエントリを`None`に設定してください。 ```python from transformers import AutoProcessor, AutoModelForCausalLM model_id = "itazap/MOSS-Transcribe-Diarize-HF" processor = AutoProcessor.from_pretrained(model_id) # `from_pretrained` is used here for convenience, the model can also be built from a config directly. model = AutoModelForCausalLM.from_pretrained(model_id, device_map="auto") audio = [ "https://huggingface.co/datasets/itazap/audio_samples/resolve/main/intro_sample.wav", "https://huggingface.co/datasets/itazap/audio_samples/resolve/main/languages_sample.wav", ] keywords = [None, ["Mandarin", "Yorùbá"]] inputs = processor.apply_transcription_request(audio, keywords=keywords) inputs = inputs.to(model.device, dtype=model.dtype) outputs = model.generate(**inputs, do_sample=False, max_new_tokens=128) transcription = processor.decode(outputs[:, inputs.input_ids.shape[1] :], return_format="transcription_only") print(transcription) ``` ### トレーニング MOSS-Transcribe-Diarize は、`labels` が提供された際にモデルが返す損失で学習できます。ユーザーターンに音声、アシスタントターンに目標文字起こしを配置して会話を構築し、トークン化時に `output_labels=True` を設定すると、プロセッサがラベルを構築してくれます（音声トークンとパディングトークンは `-100` でマスクされます）。 ```python from transformers import AutoProcessor, AutoModelForCausalLM model_id = "itazap/MOSS-Transcribe-Diarize-HF" processor = AutoProcessor.from_pretrained(model_id) model = AutoModelForCausalLM.from_pretrained(model_id, device_map="auto") model.train() conversation = [ [ { "role": "user", "content": [ { "type": "audio", "url": "https://huggingface.co/datasets/itazap/audio_samples/resolve/main/intro_sample.wav", }, ], }, { "role": "assistant", "content": [ { "type": "text", "text": "[0.00][S01] Mister quilter is apostle of the middle classes, and we are glad to welcome his gospel.[3.00]", }, ], }, ], ] inputs = processor.apply_chat_template( conversation, tokenize=True, return_dict=True, output_labels=True, ).to(model.device, dtype=model.dtype) loss = model(**inputs).loss print("Loss:", loss.item()) loss.backward() ``` ### Torch compile モデルは、推論/学習を高速化するためにコンパイルできます。`device_map="auto"` はフォワードパスを `accelerate` のフックでラップするため、再コンパイルが繰り返されます。代わりに、モデルを単一のデバイスに直接ロードしてください。 B200では、バッチサイズが4の場合に約2.1倍の高速化を確認しました。 ```python import time import torch from transformers import AutoProcessor, AutoModelForCausalLM model_id = "itazap/MOSS-Transcribe-Diarize-HF" num_warmup = 5 num_runs = 20 # Load processor + model processor = AutoProcessor.from_pretrained(model_id) model = AutoModelForCausalLM.from_pretrained(model_id).to("cuda") # Prepare static inputs audio_url = "https://huggingface.co/datasets/itazap/audio_samples/resolve/main/intro_sample.wav" inputs = processor.apply_transcription_request([audio_url] * 4).to(model.device, torch.bfloat16) # Benchmark without compile print("Warming up without compile...") with torch.no_grad(): for _ in range(num_warmup): _ = model(**inputs) torch.accelerator.synchronize() print("\nBenchmarking without torch.compile...") torch.accelerator.synchronize() start = time.time() with torch.no_grad(): for _ in range(num_runs): _ = model(**inputs) torch.accelerator.synchronize() no_compile_time = (time.time() - start) / num_runs print(f"Average time without compile: {no_compile_time:.4f}s") # Benchmark with compile print("\nCompiling model...") model = torch.compile(model) print("Warming up with compile (includes graph capture)...") with torch.no_grad(): for _ in range(num_warmup): _ = model(**inputs) torch.accelerator.synchronize() print("\nBenchmarking with torch.compile...") torch.accelerator.synchronize() start = time.time() with torch.no_grad(): for _ in range(num_runs): _ = model(**inputs) torch.accelerator.synchronize() compile_time = (time.time() - start) / num_runs print(f"Average time with compile: {compile_time:.4f}s") speedup = no_compile_time / compile_time print(f"\nSpeedup: {speedup:.2f}x") ``` 自動回帰型文字起こしでは、`model.forward`を直接コンパイルするのではなく、`CompileConfig`オブジェクトを渡すことで、`generate`内のトークンごとのフォワードパスを`torch.compile`が高速化します。 ```python import torch from transformers import AutoProcessor, AutoModelForCausalLM, CompileConfig model_id = "itazap/MOSS-Transcribe-Diarize-HF" num_warmup = 3 processor = AutoProcessor.from_pretrained(model_id) model = AutoModelForCausalLM.from_pretrained(model_id).to("cuda") audio_url = "https://huggingface.co/datasets/itazap/audio_samples/resolve/main/intro_sample.wav" inputs = processor.apply_transcription_request([audio_url] * 4).to(model.device, torch.bfloat16) compile_config = CompileConfig() # Warmup for _ in range(num_warmup): _ = model.generate(**inputs, max_new_tokens=128, cache_implementation="static", compile_config=compile_config) # Apply model generated_ids = model.generate( **inputs, max_new_tokens=128, cache_implementation="static", compile_config=compile_config ) transcription = processor.decode(generated_ids[:, inputs.input_ids.shape[1] :], return_format="transcription_only") print(transcription) ``` ## MossTranscribeDiarizeConfig[[transformers.MossTranscribeDiarizeConfig]] #### transformers.MossTranscribeDiarizeConfig[[transformers.MossTranscribeDiarizeConfig]] ```python transformers.MossTranscribeDiarizeConfig(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 = 151671, projector_hidden_act: str = 'silu', projector_bias: bool = True, audio_merge_size: int = 4, audio_chunk_size: int = 480000, tie_word_embeddings: bool = True) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/moss_transcribe_diarize/configuration_moss_transcribe_diarize.py#L73) **パラメータ:** audio_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *任意*) : 音声バックボーンの config オブジェクトまたは辞書。 text_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *任意*) : テキストバックボーンの config オブジェクトまたは辞書。 audio_token_id (`int`、*任意*、デフォルトは`151671`) : 入力音声のプレースホルダーとして使用されるオーディオトークンのインデックス。 projector_hidden_act (`str`、*任意*、デフォルトは`silu`) : マルチモーダルプロジェクターで使用される活性化関数。 projector_bias (`bool`、*任意*、デフォルトは`True`) : マルチモーダルプロジェクターでバイアスを使用するかどうか。 audio_merge_size (`int`、*optional*、デフォルトは 4) : マルチモーダルプロジェクターに接続する前に、Whisper エンコーダーのフレームを連続して連結する数。 audio_chunk_size (`int`、*optional*、デフォルトは 480000) : `padding_mask` と組み合わせて `audio_chunk_mapping` を復元するために使用される、生オーディオサンプル単位の Whisper エンコーダのウィンドウサイズ。 tie_word_embeddings (`bool`、*任意*、デフォルトは`True`) : モデルの`tied_weights_keys`マッピングに従って重み埋め込みを共有するかどうか。 これは、MossTranscribeDiarizeModel の設定を保存するための設定クラスです。指定された引数に基づいて Moss Transcribe Diarize モデルをインスタンス化し、モデルのアーキテクチャを定義するために使用されます。デフォルト値で設定をインスタンス化すると、[hf-audio/MOSS-Transcribe-Diarize-HF](https://huggingface.co/hf-audio/MOSS-Transcribe-Diarize-HF) と同様の設定が得られます。 設定オブジェクトは [PreTrainedConfig](/docs/transformers/main/ja/main_classes/configuration#transformers.PreTrainedConfig) を継承し、モデルの出力を制御するために使用できます。詳細については、[PreTrainedConfig](/docs/transformers/main/ja/main_classes/configuration#transformers.PreTrainedConfig) のドキュメントを参照してください。 例: ```python >>> from transformers import MossTranscribeDiarizeForConditionalGeneration, MossTranscribeDiarizeConfig >>> # Initializing a MossTranscribeDiarize configuration >>> configuration = MossTranscribeDiarizeConfig() >>> # Initializing a model from the configuration >>> model = MossTranscribeDiarizeForConditionalGeneration(configuration) >>> # Accessing the model configuration >>> configuration = model.config ``` ## MossTranscribeDiarizeAudioConfig[[transformers.MossTranscribeDiarizeAudioConfig]] #### transformers.MossTranscribeDiarizeAudioConfig[[transformers.MossTranscribeDiarizeAudioConfig]] ```python transformers.MossTranscribeDiarizeAudioConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, num_mel_bins: int = 80, num_hidden_layers: int = 24, num_attention_heads: int = 16, intermediate_size: int = 4096, activation_function: str = 'gelu', hidden_size: int = 1024, dropout: float | int = 0.0, attention_dropout: float | int = 0.0, activation_dropout: float | int = 0.0, initializer_range: float = 0.02, max_source_positions: int = 1500) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/moss_transcribe_diarize/configuration_moss_transcribe_diarize.py#L30) **パラメータ:** num_mel_bins (`int`、*任意*、デフォルトは`80`) : 入力フレームごとに使用されるメル特徴の数を指定します。`AutoFeatureExtractor`クラスで使用される値と一致させる必要があります。 num_hidden_layers (`int`、*optional*、デフォルトは `24`) : Transformer デコーダーの隠れ層の数。 num_attention_heads (`int`、*任意*、デフォルトは`16`) : Transformerデコーダーの各アテンション層におけるアテンションヘッドの数。 intermediate_size (`int`、*任意*、デフォルトは`4096`) : MLP 表現の次元数。 activation_function (`str`、*任意*、デフォルトは`gelu`) : デコーダーで使用する非線形活性化関数（関数または文字列）。例えば、`"gelu"`、`"relu"`、`"silu"`など。 hidden_size (`int`、*任意*、デフォルトは`1024`) : 隠れ表現の次元数。 dropout (`Union[float, int]`、*任意*、デフォルトは`0.0`) : すべての dropout レイヤーの比率。 attention_dropout (`Union[float, int]`、*任意*、デフォルトは`0.0`) : 注意確率のドロップアウト率。 activation_dropout (`Union[float, int]`、*任意*、デフォルトは`0.0`) : 全結合層内の活性化に対する dropout 率。 initializer_range (`float`、*任意*、デフォルトは`0.02`) : すべての重み行列を初期化するためのtruncated_normal_initializerの標準偏差です。 max_source_positions (`int`、*任意*、デフォルトは 1500) : このモデルが使用される可能性がある log-mel フィルターバンク特徴量の最大シーケンス長です。 これは、MossTranscribeDiarizeModel の設定を保存するための設定クラスです。指定された引数に基づいて Moss Transcribe Diarize モデルをインスタンス化し、モデルのアーキテクチャを定義するために使用されます。デフォルト値で設定をインスタンス化すると、[hf-audio/MOSS-Transcribe-Diarize-HF](https://huggingface.co/hf-audio/MOSS-Transcribe-Diarize-HF) と同様の設定が得られます。 設定オブジェクトは [PreTrainedConfig](/docs/transformers/main/ja/main_classes/configuration#transformers.PreTrainedConfig) を継承し、モデルの出力を制御するために使用できます。詳細については、[PreTrainedConfig](/docs/transformers/main/ja/main_classes/configuration#transformers.PreTrainedConfig) のドキュメントを参照してください。 例: ```python >>> from transformers import MossTranscribeDiarizeAudioConfig, MossTranscribeDiarizeAudioModel >>> # Initializing a MossTranscribeDiarizeAudioConfig >>> configuration = MossTranscribeDiarizeAudioConfig() >>> # Initializing a MossTranscribeDiarizeAudioModel (with random weights) >>> model = MossTranscribeDiarizeAudioModel(configuration) >>> # Accessing the model configuration >>> configuration = model.config ``` ## MossTranscribeDiarizeAudioModel[[transformers.MossTranscribeDiarizeAudioModel]] #### transformers.MossTranscribeDiarizeAudioModel[[transformers.MossTranscribeDiarizeAudioModel]] ```python transformers.MossTranscribeDiarizeAudioModel(config: MossTranscribeDiarizeAudioConfig) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/moss_transcribe_diarize/modeling_moss_transcribe_diarize.py#L256) **パラメータ:** config ([MossTranscribeDiarizeAudioConfig](/docs/transformers/main/ja/model_doc/moss_transcribe_diarize#transformers.MossTranscribeDiarizeAudioConfig)) : モデルのパラメータをすべて含むモデル設定クラスです。設定ファイルで初期化しても、モデルに関連する重みは読み込まれず、設定のみが読み込まれます。モデルの重みをロードするには、[from_pretrained()](/docs/transformers/main/ja/main_classes/model#transformers.PreTrainedModel.from_pretrained) メソッドを確認してください。 WhisperエンコーダーであるMOSS-Transcribe-Diarize音声モデル。 このモデルは [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.MossTranscribeDiarizeAudioModel.forward]] ```python forward(input_features, attention_mask = None, **kwargs: *) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/moss_transcribe_diarize/modeling_moss_transcribe_diarize.py#L295) **パラメータ:** input_features (`torch.FloatTensor`、shape `(batch_size, feature_size, sequence_length)`) : 生の音声波形から抽出されたLog-mel特徴量。30秒のWhisperウィンドウごとに1行です。[__call__()](/docs/transformers/main/ja/model_doc/moss_transcribe_diarize#transformers.MossTranscribeDiarizeFeatureExtractor.__call__)を参照してください。 attention_mask (`torch.Tensor`, *任意*) : MossTranscribeDiarize は `input_features` のマスキングをサポートしていません。この引数は互換性のために保持されていますが、使用されません。 **戻り値:** [BaseModelOutputWithPooling](/docs/transformers/main/ja/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) または `tuple(torch.FloatTensor)` 設定（[MossTranscribeDiarizeConfig](/docs/transformers/main/ja/model_doc/moss_transcribe_diarize#transformers.MossTranscribeDiarizeConfig)）と入力に応じて、さまざまな要素で構成される、[BaseModelOutputWithPooling](/docs/transformers/main/ja/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) または `torch.FloatTensor` のタプル（`return_dict=False` が渡された場合、または `config.return_dict=False` の場合）。 [MossTranscribeDiarizeAudioModel](/docs/transformers/main/ja/model_doc/moss_transcribe_diarize#transformers.MossTranscribeDiarizeAudioModel)のforwardメソッドは、`__call__`特殊メソッドをオーバーライドします。 この関数内でフォワードパスの手順を定義する必要がありますが、その後、この関数ではなく`Module`インスタンスを呼び出すべきです。前者は前処理と後処理の実行を適切に処理するのに対し、後者はそれらを無視してしまいます。 - **last_hidden_state** (`torch.FloatTensor`、shape `(batch_size, sequence_length, hidden_size)`) -- モデルの最終層の出力における隠れ状態のシーケンス。 - **pooler_output** (`torch.FloatTensor`、shape `(batch_size, hidden_size)`) -- 補助事前学習タスクに使用される層をさらに通して処理された後、シーケンスの最初のトークン（分類トークン）の最終層の隠れ状態です。例えば、BERT 系のモデルでは、線形層と tanh 活性化関数を経て処理された後の分類トークンを返します。この線形層の重みは、事前学習中の次文予測（分類）目的から学習されます。 - **hidden_states** (`tuple(torch.FloatTensor)`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) -- `torch.FloatTensor` のタプル（埋め込み層を持つモデルの場合、埋め込みの出力用が 1 つ、各層の出力用が 1 つずつ）で、形状は `(batch_size, sequence_length, hidden_size)` です。 各層の出力におけるモデルのHidden-states、および任意の初期埋め込み出力。 - **attentions** (`tuple(torch.FloatTensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) -- `torch.FloatTensor` のタプル（各レイヤーごとに1つ）で、形状は `(batch_size, num_heads, sequence_length, sequence_length)` です。 アテンションのsoftmax後のアテンション重み。自己アテンションヘッド内で加重平均を計算するために使用されます。 ## MossTranscribeDiarizeFeatureExtractor[[transformers.MossTranscribeDiarizeFeatureExtractor]] #### transformers.MossTranscribeDiarizeFeatureExtractor[[transformers.MossTranscribeDiarizeFeatureExtractor]] ```python transformers.MossTranscribeDiarizeFeatureExtractor(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/main/src/transformers/models/moss_transcribe_diarize/feature_extraction_moss_transcribe_diarize.py#L35) MOSS-Transcribe-Diarize の特徴量抽出器を構築します。 これは、[WhisperFeatureExtractor](/docs/transformers/main/ja/model_doc/whisper#transformers.WhisperFeatureExtractor) の派生クラスであり、log-mel 特徴量を抽出する前に、`chunk_length` 秒を超えるオーディオを連続する Whisper ウィンドウのチャンクに分割し、各サンプルの元の生オーディオの長さを `padding_mask` 経由で報告します（チャンクごとの有効フレームを示す `input_features_mask` とは異なります）。 #### __call__[[transformers.MossTranscribeDiarizeFeatureExtractor.__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, sampling_rate: int | None = None, device: str | None = 'cpu', **kwargs) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/moss_transcribe_diarize/feature_extraction_moss_transcribe_diarize.py#L170) **パラメータ:** raw_speech (`np.ndarray`、`list[float]`、`list[np.ndarray]`、`list[list[float]]`) : 処理対象のシーケンスまたはシーケンスのバッチです。モノラル音声のみ対応しています。 truncation (`bool`、*任意*、デフォルトは`True`) : 切り詰めを有効にし、各`n_samples`長のチャンクを`n_samples`に切り詰めます。 pad_to_multiple_of (`int`, *optional*) : 設定されている場合、各チャンクの生オーディオをこの値の倍数にパディングします。 device (`str`、*任意*、デフォルトは`"cpu"`) : log-mel スペクトログラムの計算に使用されるデバイス。 **戻り値:** [BatchFeature](/docs/transformers/main/ja/main_classes/feature_extractor#transformers.BatchFeature) `input_features`（log-mel 特徴、チャンクごとに1行）、`input_features_mask`（チャンクごとの有効フレームマスク）、`padding_mask`（有効な生サンプルマスク、入力サンプルごとに1行）を伴います。 各オーディオサンプルを連続する`n_samples`長のチャンクに分割し、チャンクごとにlog-mel特徴量を抽出し、`padding_mask`を介して各サンプルの元の生オーディオの長さを報告します。 ## MossTranscribeDiarizeProcessor[[transformers.MossTranscribeDiarizeProcessor]] #### transformers.MossTranscribeDiarizeProcessor[[transformers.MossTranscribeDiarizeProcessor]] ```python transformers.MossTranscribeDiarizeProcessor(feature_extractor = None, tokenizer = None, chat_template: str | None = None, audio_token: str = '<|audio_pad|>', audio_bos_token: str = '<|audio_start|>', audio_eos_token: str = '<|audio_end|>', audio_tokens_per_second: float = 12.5, audio_merge_size: int = 4, time_marker_every_seconds: int = 2) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/moss_transcribe_diarize/processing_moss_transcribe_diarize.py#L43) **パラメータ:** feature_extractor (`MossTranscribeDiarizeFeatureExtractor`) : 特徴抽出器は必須の入力です。 tokenizer (`Qwen2Tokenizer`) : トークナイザーは必須の入力です。 chat_template (`str`, *任意*) : チャット内のメッセージのリストをトークン化可能な文字列に変換するための Jinja テンプレート。 audio_token (`str`、*任意*、デフォルトは`"<|audio_pad|>"`) : チャットテンプレート内で音声入力を表すために使用される特殊トークン。 audio_bos_token (`str`、*任意*、デフォルトは`"<|audio_start|>"`) : チャットテンプレート内で音声スパンの開始を示す特殊トークン。 audio_eos_token (`str`、*任意*、デフォルトは`"<|audio_end|>"`) : チャットテンプレート内で、音声スパンの終わりを示す特殊トークン。 audio_tokens_per_second (`float`、*optional*、デフォルトは 12.5) : 入力音声 1 秒あたりの音声プレースホルダトークンの想定数。 audio_merge_size (`int`、*optional*、デフォルトは 4) : 音声トークンを数える際に使用される Whisper のフレームマージ係数。 time_marker_every_seconds (`int`、*optional*、デフォルトは 2) : 音声スパン内に、N 秒ごとに数値の時間マーカートークンを挿入します。`0` に設定すると、時間マーカーを無効にし、代わりにプレーンな音声プレースホルダスパンを出力します。 MossTranscribeDiarizeProcessor を構築します。このクラスは、feature extractor と tokenizer を単一の processor にラップします。 [MossTranscribeDiarizeProcessor](/docs/transformers/main/ja/model_doc/moss_transcribe_diarize#transformers.MossTranscribeDiarizeProcessor) は、[MossTranscribeDiarizeFeatureExtractor](/docs/transformers/main/ja/model_doc/moss_transcribe_diarize#transformers.MossTranscribeDiarizeFeatureExtractor) と [Qwen2Tokenizer](/docs/transformers/main/ja/model_doc/qwen2#transformers.Qwen2Tokenizer) のすべての機能を提供します。詳細については、[~MossTranscribeDiarizeFeatureExtractor](/docs/transformers/main/ja/model_doc/moss_transcribe_diarize#transformers.MossTranscribeDiarizeFeatureExtractor) および [~Qwen2Tokenizer](/docs/transformers/main/ja/model_doc/qwen2#transformers.Qwen2Tokenizer) を参照してください。 #### __call__[[transformers.MossTranscribeDiarizeProcessor.__call__]] ```python __call__(text: str | list[str], audio: typing.Union[numpy.ndarray, ForwardRef('torch.Tensor'), collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence['torch.Tensor'], NoneType] = None, output_labels: bool | None = False, **kwargs: *) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/moss_transcribe_diarize/processing_moss_transcribe_diarize.py#L104) **パラメータ:** 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_values`、`padding_mask`）を含む辞書です。 #### apply_chat_template[[transformers.MossTranscribeDiarizeProcessor.apply_chat_template]] ```python apply_chat_template(conversation: list[dict[str, str]] | list[list[dict[str, str]]], chat_template: str | None = None, tools: list[dict] | None = None, documents: list[dict[str, str]] | None = None, add_generation_prompt: bool = False, continue_final_message: bool | str = False, return_assistant_tokens_mask: bool = False, tokenize: bool = False, return_tensors: str | transformers.utils.generic.TensorType | None = 'auto', return_dict: bool = False, load_audio_from_video: bool = False, processor_kwargs: dict | None = None, **kwargs) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/processing_utils.py#L2197) **パラメータ:** conversation (`Union[list[Dict, [str, str]], list[list[dict[str, str]]]]`) : フォーマットする会話。 chat_template (`Optional[str]`, *任意*) : 会話のフォーマットに使用する Jinja テンプレートです。指定しない場合、トークナイザーのチャットテンプレートが使用されます。 トークナイザーの`apply_chat_template`メソッドと同様に、このメソッドは入力された会話にJinjaテンプレートを適用し、それを単一のトークナイズ可能な文字列に変換します。 入力には、各メッセージのコンテンツがテキストと、任意の画像または動画の入力からなるリストである、以下の形式が期待されます。`return_dict=True` の場合、画像、動画、URL、ローカルパスを指定することもでき、それらは `pixel_values` を形成するために使用されます。指定しない場合、フォーマットされたテキストのみ、または任意でトークン化されたテキストのみが返されます。 conversation = [ { "role": "user", "content": [ {"type": "image", "url": "https://www.ilankelman.org/stopsigns/australia.jpg"}, {"type": "text", "text": "Please describe this image in detail."}, ], }, ] #### apply_transcription_request[[transformers.MossTranscribeDiarizeProcessor.apply_transcription_request]] ```python apply_transcription_request(audio: typing.Union[str, list[str], numpy.ndarray, ForwardRef('torch.Tensor'), collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence['torch.Tensor']], prompt: str | list[str] | None = None, keywords: str | list[str] | list[list[str]] | None = None, tokenize: bool = True, **kwargs: *) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/moss_transcribe_diarize/processing_moss_transcribe_diarize.py#L213) **パラメータ:** audio (`str`、`list[str]`、`np.ndarray`、`torch.Tensor`、`list[np.ndarray]`、`list[torch.Tensor]`) : 文字起こし対象の音声。文字列はローカルパスまたは URL として解釈され、チャットテンプレートローダーによって自動的に読み込まれます。NumPy 配列および PyTorch テンソルはそのまま転送されます。 prompt (`str` または `list[str]`、*省略可能*) : ユーザーターンに含めるカスタムプロンプトです。リストの場合、バッチの長さと一致する必要があります。`None` の場合、チャットテンプレートがデフォルトのタイムスタンプ付き話者分離プロンプトを供給します。 keywords (`str`、`list[str]`、または `list[list[str]]`、*任意*) : 文字列の転写を正しい綴りに偏向させるためのホットワード/ドメイン用語（固有名詞など）。文字列またはフラットな文字列リストはバッチ全体で共有されます。ネストされたリストを使用すると、各オーディオサンプルごとに個別のキーワードを指定できます。 tokenize (`bool`、*任意*、デフォルトは `True`) : プロンプトのトークナイズとオーディオの処理を行うかどうかを指定します。`False` の場合、オーディオは読み込まれず、プロンプトは展開されていないオーディオプレースホルダーを含む文字列として返されます。これらをオーディオとともにプロセッサーに渡す `processor(text=prompts, audio=audio)` 場合、`tokenize=True` と同じ出力が得られます。 - ****kwargs** : [apply_chat_template()](/docs/transformers/main/ja/main_classes/processors#transformers.ProcessorMixin.apply_chat_template) に転送される追加のキーワード引数。 手動でチャットテンプレートを書かずに、文字起こし/話者分離用の入力を準備します。 ## MossTranscribeDiarizeModel[[transformers.MossTranscribeDiarizeModel]] #### transformers.MossTranscribeDiarizeModel[[transformers.MossTranscribeDiarizeModel]] ```python transformers.MossTranscribeDiarizeModel(config: MossTranscribeDiarizeConfig) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/moss_transcribe_diarize/modeling_moss_transcribe_diarize.py#L382) **パラメータ:** config ([MossTranscribeDiarizeConfig](/docs/transformers/main/ja/model_doc/moss_transcribe_diarize#transformers.MossTranscribeDiarizeConfig)) : モデルのパラメータをすべて含むモデル設定クラスです。設定ファイルで初期化しても、モデルに関連する重みは読み込まれず、設定のみが読み込まれます。モデルの重みをロードするには、[from_pretrained()](/docs/transformers/main/ja/main_classes/model#transformers.PreTrainedModel.from_pretrained) メソッドを確認してください。 MOSS-Transcribe-Diarizeモデル: Whisperエンコーダー、4倍時間マージ、マルチモーダルプロジェクター、およびQwen3言語モデル。 このモデルは [PreTrainedModel](/docs/transformers/main/ja/main_classes/model#transformers.PreTrainedModel) を継承しています。ライブラリがすべてのモデルに対して実装している汎用的なメソッド（ダウンロードや保存、入力埋め込みのリサイズ、ヘッドのプルーニングなど）については、スーパークラスのドキュメントを参照してください。 このモデルは、PyTorchの[torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module)のサブクラスでもあります。通常のPyTorch Moduleとして使用し、一般的な使用方法や動作に関する詳細については、PyTorchのドキュメントを参照してください。 #### forward[[transformers.MossTranscribeDiarizeModel.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, input_features: typing.Optional[torch.FloatTensor] = None, input_features_mask: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.FloatTensor] = None, padding_mask: typing.Optional[torch.Tensor] = None, **kwargs: *) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/moss_transcribe_diarize/modeling_moss_transcribe_diarize.py#L459) **パラメータ:** input_ids (`torch.LongTensor`、shape `(batch_size, sequence_length)`、*任意*) : 語彙における入力シーケンスのトークンインデックスです。デフォルトでは、パディングは無視されます。インデックスは [AutoTokenizer](/docs/transformers/main/ja/model_doc/auto#transformers.AutoTokenizer) を使用して取得できます。詳細については、[PreTrainedTokenizer.encode()](/docs/transformers/main/ja/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) および [PreTrainedTokenizer.__call__()](/docs/transformers/main/ja/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) を参照してください。 [入力IDとは何ですか？](../glossary#input-ids) input_features (`torch.FloatTensor`、形状 `(batch_size, sequence_length, feature_dim)`、*任意*) : 入力音声特徴に対応するテンソルです。音声特徴は [MossTranscribeDiarizeFeatureExtractor](/docs/transformers/main/ja/model_doc/moss_transcribe_diarize#transformers.MossTranscribeDiarizeFeatureExtractor) を使用して取得できます。詳細は [MossTranscribeDiarizeProcessor.__call__()](/docs/transformers/main/ja/model_doc/moss_transcribe_diarize#transformers.MossTranscribeDiarizeFeatureExtractor.__call__) を参照してください（[MossTranscribeDiarizeProcessor](/docs/transformers/main/ja/model_doc/moss_transcribe_diarize#transformers.MossTranscribeDiarizeProcessor) は音声の処理に [MossTranscribeDiarizeFeatureExtractor](/docs/transformers/main/ja/model_doc/moss_transcribe_diarize#transformers.MossTranscribeDiarizeFeatureExtractor) を使用します）。 input_features_mask (`torch.Tensor`、形状 `(num_chunks, feature_sequence_length)`、*任意*) : `input_features` 内のチャンク化された log-mel 特徴量行ごとに1行ずつ、有効（パディングされていない）特徴量インデックスを示すマスク。各チャンクの有効なエンコーダー出力長を計算するために使用されます。 attention_mask (`torch.Tensor`、形状 `(batch_size, sequence_length)`、*任意*) : パディングトークンのインデックスに対するアテンションの計算を回避するためのマスク。そのまま言語モデルに転送されます。 inputs_embeds (`torch.FloatTensor`、形状 `(batch_size, sequence_length, hidden_size)`、*任意*) : `input_ids` を渡す代わりに、事前計算された埋め込みを指定します。`input_features` も指定されている場合、`inputs_embeds` 内の音声プレースホルダーの位置を特定して音声埋め込みで埋めるために、`input_ids` は引き続き必要です。 padding_mask (`torch.Tensor`、形状 `(batch_size, max_audio_length)`、*任意*) : 各オーディオサンプルの有効な生オーディオ長を示すマスク。`config.audio_chunk_size` と組み合わせて `audio_chunk_mapping` を復元するために使用されます。 **戻り値:** `MossTranscribeDiarizeModelOutputWithPast` または `tuple(torch.FloatTensor)` `MossTranscribeDiarizeModelOutputWithPast`、または`torch.FloatTensor`のタプル（`return_dict=False`が渡された場合、または`config.return_dict=False`の場合）。設定（[MossTranscribeDiarizeConfig](/docs/transformers/main/ja/model_doc/moss_transcribe_diarize#transformers.MossTranscribeDiarizeConfig)）や入力に応じて、さまざまな要素で構成されます。 [MossTranscribeDiarizeModel](/docs/transformers/main/ja/model_doc/moss_transcribe_diarize#transformers.MossTranscribeDiarizeModel) の forward メソッドは、`__call__` という特殊メソッドをオーバーライドします。 この関数内でフォワードパスの手順を定義する必要がありますが、その後、この関数ではなく`Module`インスタンスを呼び出すべきです。前者は前処理と後処理の実行を適切に処理するのに対し、後者はそれらを無視してしまいます。 - **last_hidden_state** (`torch.FloatTensor`、shape `(batch_size, sequence_length, hidden_size)`) -- モデルの最終層の出力における隠れ状態のシーケンス。 `past_key_values`が使用されている場合、出力されるのは、形状`(batch_size, 1, hidden_size)`のシーケンスの最後の隠れ状態のみです。 - **past_key_values** (`Cache`、*任意*、`use_cache=True` が渡された場合または `config.use_cache=True` の場合に返されます) -- [Cache](/docs/transformers/main/ja/internal/generation_utils#transformers.Cache) のインスタンスです。詳細については、[kv cache ガイド](https://huggingface.co/docs/transformers/en/kv_cache)を参照してください。 自己アテンションブロック（および `config.is_encoder_decoder=True` の場合、クロスカレンションブロック）の事前計算済みヒドゥンステート（キーとバリュー）を保持します。これらは逐次デコーディングを高速化するために使用できます（`past_key_values` 入力参照）。 - **hidden_states** (`tuple(torch.FloatTensor)`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) -- `torch.FloatTensor` のタプル（埋め込み層を持つモデルの場合、埋め込みの出力用が 1 つ、各層の出力用が 1 つずつ）で、形状は `(batch_size, sequence_length, hidden_size)` です。 各層の出力におけるモデルのHidden-states、および任意の初期埋め込み出力。 - **attentions** (`tuple(torch.FloatTensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) -- `torch.FloatTensor` のタプル（各レイヤーごとに1つ）で、形状は `(batch_size, num_heads, sequence_length, sequence_length)` です。 アテンションのsoftmax後のアテンション重み。自己アテンションヘッド内で加重平均を計算するために使用されます。 - **audio_hidden_states** (`torch.FloatTensor`、*任意*) -- 投影されたオーディオの隠れ状態。 #### get_audio_features[[transformers.MossTranscribeDiarizeModel.get_audio_features]] ```python get_audio_features(input_features: Tensor, input_features_mask: Tensor, padding_mask: Tensor, **kwargs: *) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/moss_transcribe_diarize/modeling_moss_transcribe_diarize.py#L394) **パラメータ:** input_features (`torch.Tensor`、形状 `(batch_size, sequence_length, feature_dim)`) : 入力音声特徴に対応するテンソルです。音声特徴は [MossTranscribeDiarizeFeatureExtractor](/docs/transformers/main/ja/model_doc/moss_transcribe_diarize#transformers.MossTranscribeDiarizeFeatureExtractor) を使用して取得できます。詳細は [MossTranscribeDiarizeFeatureExtractor.__call__()](/docs/transformers/main/ja/model_doc/moss_transcribe_diarize#transformers.MossTranscribeDiarizeFeatureExtractor.__call__) を参照してください（[MossTranscribeDiarizeProcessor](/docs/transformers/main/ja/model_doc/moss_transcribe_diarize#transformers.MossTranscribeDiarizeProcessor) は音声の処理に [MossTranscribeDiarizeFeatureExtractor](/docs/transformers/main/ja/model_doc/moss_transcribe_diarize#transformers.MossTranscribeDiarizeFeatureExtractor) を使用します）。 input_features_mask (`torch.Tensor`、形状 `(num_chunks, feature_sequence_length)`) : `input_features` 内のチャンク化された log-mel 特徴量行ごとに1行ずつ、有効（パディングされていない）特徴量インデックスを示すマスク。各チャンクの有効なエンコーダー出力長を計算するために使用されます。 padding_mask (`torch.Tensor`、形状 `(batch_size, max_audio_length)`) : 各オーディオサンプルの有効な生オーディオ長を示すマスク。サンプルごとに1行ずつあります。`config.audio_chunk_size` と組み合わせて `audio_chunk_mapping` を復元するために使用されます。 **戻り値:** [BaseModelOutputWithPooling](/docs/transformers/main/ja/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) または `tuple(torch.FloatTensor)` 設定（[MossTranscribeDiarizeConfig](/docs/transformers/main/ja/model_doc/moss_transcribe_diarize#transformers.MossTranscribeDiarizeConfig)）と入力に応じて、さまざまな要素で構成される、[BaseModelOutputWithPooling](/docs/transformers/main/ja/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) または `torch.FloatTensor` のタプル（`return_dict=False` が渡された場合、または `config.return_dict=False` の場合）。 log-mel特徴量からMOSSの音声埋め込みを抽出し、サンプルごとにマルチチャンクの音声を再構成します。 - **last_hidden_state** (`torch.FloatTensor`、shape `(batch_size, sequence_length, hidden_size)`) -- モデルの最終層の出力における隠れ状態のシーケンス。 - **pooler_output** (`torch.FloatTensor`、shape `(batch_size, hidden_size)`) -- 補助事前学習タスクに使用される層をさらに通して処理された後、シーケンスの最初のトークン（分類トークン）の最終層の隠れ状態です。例えば、BERT 系のモデルでは、線形層と tanh 活性化関数を経て処理された後の分類トークンを返します。この線形層の重みは、事前学習中の次文予測（分類）目的から学習されます。 - **hidden_states** (`tuple(torch.FloatTensor)`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) -- `torch.FloatTensor` のタプル（埋め込み層を持つモデルの場合、埋め込みの出力用が 1 つ、各層の出力用が 1 つずつ）で、形状は `(batch_size, sequence_length, hidden_size)` です。 各層の出力におけるモデルのHidden-states、および任意の初期埋め込み出力。 - **attentions** (`tuple(torch.FloatTensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) -- `torch.FloatTensor` のタプル（各レイヤーごとに1つ）で、形状は `(batch_size, num_heads, sequence_length, sequence_length)` です。 アテンションのsoftmax後のアテンション重み。自己アテンションヘッド内で加重平均を計算するために使用されます。 ## MossTranscribeDiarizeForConditionalGeneration[[transformers.MossTranscribeDiarizeForConditionalGeneration]] #### transformers.MossTranscribeDiarizeForConditionalGeneration[[transformers.MossTranscribeDiarizeForConditionalGeneration]] ```python transformers.MossTranscribeDiarizeForConditionalGeneration(config: MossTranscribeDiarizeConfig) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/moss_transcribe_diarize/modeling_moss_transcribe_diarize.py#L522) **パラメータ:** config ([MossTranscribeDiarizeConfig](/docs/transformers/main/ja/model_doc/moss_transcribe_diarize#transformers.MossTranscribeDiarizeConfig)) : モデルのパラメータをすべて含むモデル設定クラスです。設定ファイルで初期化しても、モデルに関連する重みは読み込まれず、設定のみが読み込まれます。モデルの重みをロードするには、[from_pretrained()](/docs/transformers/main/ja/main_classes/model#transformers.PreTrainedModel.from_pretrained) メソッドを確認してください。 転写と話者分離を伴う条件付き生成用のMOSS-Transcribe-Diarizeモデル。 このモデルは [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.MossTranscribeDiarizeForConditionalGeneration.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, input_features: typing.Optional[torch.FloatTensor] = None, input_features_mask: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.FloatTensor] = None, labels: typing.Optional[torch.LongTensor] = None, logits_to_keep: typing.Union[int, torch.Tensor] = 0, padding_mask: typing.Optional[torch.Tensor] = None, **kwargs: *) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/moss_transcribe_diarize/modeling_moss_transcribe_diarize.py#L535) **パラメータ:** input_ids (`torch.LongTensor`、shape `(batch_size, sequence_length)`、*任意*) : 語彙における入力シーケンスのトークンインデックスです。デフォルトでは、パディングは無視されます。インデックスは [AutoTokenizer](/docs/transformers/main/ja/model_doc/auto#transformers.AutoTokenizer) を使用して取得できます。詳細については、[PreTrainedTokenizer.encode()](/docs/transformers/main/ja/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) および [PreTrainedTokenizer.__call__()](/docs/transformers/main/ja/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) を参照してください。 [入力IDとは何ですか？](../glossary#input-ids) input_features (`torch.FloatTensor`、形状 `(batch_size, sequence_length, feature_dim)`、*任意*) : 入力音声特徴に対応するテンソルです。音声特徴は [MossTranscribeDiarizeFeatureExtractor](/docs/transformers/main/ja/model_doc/moss_transcribe_diarize#transformers.MossTranscribeDiarizeFeatureExtractor) を使用して取得できます。詳細は [MossTranscribeDiarizeProcessor.__call__()](/docs/transformers/main/ja/model_doc/moss_transcribe_diarize#transformers.MossTranscribeDiarizeFeatureExtractor.__call__) を参照してください（[MossTranscribeDiarizeProcessor](/docs/transformers/main/ja/model_doc/moss_transcribe_diarize#transformers.MossTranscribeDiarizeProcessor) は音声の処理に [MossTranscribeDiarizeFeatureExtractor](/docs/transformers/main/ja/model_doc/moss_transcribe_diarize#transformers.MossTranscribeDiarizeFeatureExtractor) を使用します）。 input_features_mask (`torch.Tensor`、形状 `(num_chunks, feature_sequence_length)`、*任意*) : `input_features` 内のチャンク化された log-mel 特徴量行ごとに1行ずつ、有効（パディングされていない）特徴量インデックスを示すマスク。各チャンクの有効なエンコーダー出力長を計算するために使用されます。 attention_mask (`torch.Tensor`、形状 `(batch_size, sequence_length)`、*任意*) : パディングトークンのインデックスに対するアテンションの計算を回避するためのマスク。そのまま言語モデルに転送されます。 past_key_values (`~cache_utils.Cache`, *任意*) : 逐次デコードを高速化するために使用できる、事前計算された hidden-states（self-attention ブロックおよび cross-attention ブロック内の key と value）です。通常、`use_cache=True` または `config.use_cache=True` の場合、モデルがデコードの以前の段階で返した `past_key_values` で構成されます。入力として許可されるのは [Cache](/docs/transformers/main/ja/internal/generation_utils#transformers.Cache) インスタンスのみです。[kv cache ガイド](https://huggingface.co/docs/transformers/en/kv_cache)を参照してください。`past_key_values` が渡されない場合、デフォルトで [DynamicCache](/docs/transformers/main/ja/internal/generation_utils#transformers.DynamicCache) が初期化されます。モデルは、入力として与えられたのと同じキャッシュ形式を出力します。`past_key_values` を使用する場合は、すべての `input_ids`（形状 `(batch_size, sequence_length)`）の代わりに、このモデルに過去の key value 状態が与えられていない未処理の `input_ids`（形状 `(batch_size, unprocessed_length)`）のみを入力する必要があります。 inputs_embeds (`torch.FloatTensor`、形状 `(batch_size, sequence_length, hidden_size)`、*任意*) : `input_ids` を渡す代わりに、事前計算された埋め込みを指定します。`input_features` も指定されている場合、`inputs_embeds` 内の音声プレースホルダーの位置を特定して音声埋め込みで埋めるために、`input_ids` は引き続き必要です。 labels (`torch.LongTensor`、形状 `(batch_size, sequence_length)`、*任意*) : マスク言語モデリング損失を計算するためのラベル。 logits_to_keep (`Union[int, torch.Tensor]`、*任意*、デフォルトは `0`) : `int` の場合、最後の `logits_to_keep` トークンについて logits を計算します。`0` の場合、すべての `input_ids` について logits を計算します（特殊ケース）。生成には最後のトークンの logits だけで十分であり、そのトークンのみについて計算することでメモリを節約できます。これは、長いシーケンスや大規模な語彙サイズの場合に特に顕著な効果があります。`torch.Tensor` の場合、シーケンス長次元で保持するインデックスに対応する 1 次元である必要があります。これは、パックされたテンソル形式（バッチとシーケンス長を単一の次元にまとめる形式）を使用する場合に有用です。 padding_mask (`torch.Tensor`、形状 `(batch_size, max_audio_length)`、*任意*) : 各オーディオサンプルの有効な生オーディオ長を示すマスク。`config.audio_chunk_size` と組み合わせて `audio_chunk_mapping` を復元するために使用されます。 **戻り値:** `MossTranscribeDiarizeCausalLMOutputWithPast` または `tuple(torch.FloatTensor)` `MossTranscribeDiarizeCausalLMOutputWithPast`、または `torch.FloatTensor` のタプル（`return_dict=False` が渡された場合、または `config.return_dict=False` の場合）。設定（[MossTranscribeDiarizeConfig](/docs/transformers/main/ja/model_doc/moss_transcribe_diarize#transformers.MossTranscribeDiarizeConfig)）や入力に応じて、さまざまな要素で構成されます。 [MossTranscribeDiarizeForConditionalGeneration](/docs/transformers/main/ja/model_doc/moss_transcribe_diarize#transformers.MossTranscribeDiarizeForConditionalGeneration) の forward メソッドは、`__call__` という特殊メソッドをオーバーライドします。 この関数内でフォワードパスの手順を定義する必要がありますが、その後、この関数ではなく`Module`インスタンスを呼び出すべきです。前者は前処理と後処理の実行を適切に処理するのに対し、後者はそれらを無視してしまいます。 - **loss** (`torch.FloatTensor`、shape `(1,)`、*optional*、`labels` が指定された場合に返されます) -- 言語モデリングの損失(次のトークンの予測用)。 - **logits** (`torch.FloatTensor`、形状 `(batch_size, sequence_length, config.vocab_size)`) -- 言語モデリングヘッドの予測スコア。 - **past_key_values** (`Cache`、*任意*、`use_cache=True` が渡された場合または `config.use_cache=True` の場合に返されます) -- [Cache](/docs/transformers/main/ja/internal/generation_utils#transformers.Cache) のインスタンスです。 - **hidden_states** (`tuple[torch.FloatTensor]`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) -- `torch.FloatTensor` のタプル（モデルに埋め込み層がある場合はその出力用 + 各層の出力用）で、形状は `(batch_size, sequence_length, hidden_size)` です。 各層の出力におけるモデルのHidden-states、および任意の初期埋め込み出力。 - **attentions** (`tuple[torch.FloatTensor]`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) -- `torch.FloatTensor` のタプル（各レイヤーごとに1つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)`。 アテンションのsoftmax後のアテンション重み。自己アテンションヘッド内で加重平均を計算するために使用されます。 - **audio_hidden_states** (`torch.FloatTensor`、*任意*) -- 投影後のオーディオエンコーダーの隠れ状態。 例: ```python >>> from transformers import MossTranscribeDiarizeForConditionalGeneration, AutoProcessor >>> model_id = "hf-audio/MOSS-Transcribe-Diarize-HF" >>> processor = AutoProcessor.from_pretrained(model_id) >>> model = MossTranscribeDiarizeForConditionalGeneration.from_pretrained(model_id, device_map="auto") >>> inputs = processor.apply_transcription_request("https://huggingface.co/datasets/hf-internal-testing/dummy-audio-samples/resolve/main/bcn_weather.mp3") >>> inputs = inputs.to(model.device, dtype=model.dtype) >>> outputs = model.generate(**inputs, do_sample=False, max_new_tokens=500) >>> processor.batch_decode(outputs[:, inputs.input_ids.shape[1] :], skip_special_tokens=True) ``` #### get_audio_features[[transformers.MossTranscribeDiarizeForConditionalGeneration.get_audio_features]] ```python get_audio_features(input_features, input_features_mask, **kwargs) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/moss_transcribe_diarize/modeling_moss_transcribe_diarize.py#L532)