Hugging Face's logo

Transformers documentation

Parakeet

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v5.22.1).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

このモデルは2025年9月25日に Hugging Face Transformers に貢献されました。

SDPA

Parakeet

概要

Parakeetモデルは、NVIDIA NeMoによって導入された、Fast Conformerエンコーダーと、自動音声認識用のconnectionist temporal classification (CTC)、recurrent neural network transducer (RNNT)、またはtoken and duration transducer (TDT)デコーダーを組み合わせたモデルです。

モデルアーキテクチャ

  • Fast Conformer Encoder: メルスペクトログラム特徴を処理し、サブサンプリングによってシーケンス長を短縮する、線形にスケーラブルな Conformer アーキテクチャです。FastSpeech2Conformer に含まれる Conformer Encoder のより効率的なバージョンです（エンコーダーの実装と詳細については ParakeetEncoder を参照してください）。
  • ParakeetForCTC: Fast Conformer エンコーダー + CTC デコーダー
    • CTC Decoder: 以下で構成される、シンプルかつ効果的なデコーダーです:
      • 1D 畳み込み投影（エンコーダーの隠れ層サイズから語彙サイズへの変換、NeMo 互換性の最適化のため）。
      • 学習用のCTC損失の計算。
      • 推論用のグリーディCTCデコーディング。
  • ParakeetForRNNT: Fast Conformer エンコーダー + RNN-T (RNN Transducer) デコーダー
    • RNN-T Decoder: 標準的なニューラルトランスダューサー:
      • LSTM予測ネットワークは、トークン予測にわたって言語コンテキストを維持します。
      • Joint networkは、エンコーダーとデコーダーの出力を結合します。
      • 推論におけるGreedy transducer decoding: blankの出力はエンコーダフレームを1進め、非blankの出力は同じフレームにとどまります。
  • ParakeetForTDT: Fast Conformer エンコーダー + TDT（Token Duration Transducer）デコーダー
    • TDT Decoder: トークンとその持続時間を同時に予測し、効率的なデコーディングを可能にします:
      • LSTM予測ネットワークは、トークン予測にわたって言語コンテキストを維持します。
      • Joint networkは、エンコーダーとデコーダーの出力を結合します。
      • Duration head はスキップするフレーム数を予測し、高速な推論を可能にします。

元の実装はNVIDIA NeMoにあります。 モデルのチェックポイントはNVIDIA組織の下にあります。

このモデルは、Nithin Rao Koluguri、Eustache Le Bihan、Eric Bezzam、Maksym Lypivskyi、Hainan Xu によって提供されました。

使用方法

ParakeetForCTCの使用方法

パイプライン
AutoModel
from transformers import pipeline


pipe = pipeline("automatic-speech-recognition", model="nvidia/parakeet-ctc-1.1b")
out = pipe("https://huggingface.co/datasets/hf-internal-testing/dummy-audio-samples/resolve/main/bcn_weather.mp3")
print(out)
# {'text': 'yesterday it was thirty five degrees in barcelona but today the temperature will go down to minus twenty degrees'}

ParakeetForRNNTの使用方法

パイプライン
AutoModel
タイムスタンプの付与

Parakeet RNN-T は、CTC と同様に大文字・小文字や句読点なしで文字起こしを行い、トークンタイムスタンプの付与も可能です。

from transformers import pipeline

pipe = pipeline("automatic-speech-recognition", model="nvidia/parakeet-rnnt-0.6b", revision="refs/pr/4")
out = pipe("https://huggingface.co/datasets/hf-internal-testing/dummy-audio-samples/resolve/main/bcn_weather.mp3")
print(out)
# {'text': 'yesterday it was thirty five degrees in barcelona but today the temperature will go down to minus twenty degrees'}

ParakeetForTDTの使用方法

パイプライン
AutoModel
タイムスタンプの付与

Parakeet TDTの文字起こし結果には大文字・小文字が含まれており、モデルはトークン単位のタイムスタンプ付与も実行できます。

from transformers import pipeline

pipe = pipeline("automatic-speech-recognition", model="nvidia/parakeet-tdt-0.6b-v3")
out = pipe("https://huggingface.co/datasets/hf-internal-testing/dummy-audio-samples/resolve/main/bcn_weather.mp3")
print(out)
# {'text': 'Yesterday it was 35 degrees in Barcelona, but today the temperature will go down to minus 20 degrees.'}

モデルを高速に動かす

Parakeet は、グラフキャプチャ（NVIDIA GPU では CUDA graphs、その他のアクセラレーターでは同等のメカニズム）によるフルグラフコンパイルをサポートしています！この最適化は、転写したい音声の最大長が既知の場合に最も効果的です。その核心は、再コンパイルを回避するために静的な入力形状を利用することです。例えば、音声の長さが 30 秒未満であることが分かっている場合、プロセッサーを使用してすべての入力を 30 秒にパディングし、一貫性のある入力特徴量とアテンションマスクを準備できます。以下の例を参照してください！

import torch
from datasets import Audio, load_dataset

from transformers import AutoModelForCTC, AutoProcessor


processor = AutoProcessor.from_pretrained("nvidia/parakeet-ctc-1.1b")
model = AutoModelForCTC.from_pretrained("nvidia/parakeet-ctc-1.1b", device_map="auto")

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

# Compile the generate method with fullgraph and graph capture
model.generate = torch.compile(model.generate, fullgraph=True, mode="reduce-overhead")

# let's define processor kwargs to pad to 30 seconds
processor_kwargs = {
    "padding": "max_length",
    "max_length": 30 * processor.feature_extractor.sampling_rate,
}

# Define a timing context using accelerator events
class TimerContext:
    def __init__(self, name="Execution"):
        self.name = name
        self.start_event = None
        self.end_event = None

    def __enter__(self):
        # Use accelerator events for more accurate device timing
        self.start_event = torch.Event(enable_timing=True)
        self.end_event = torch.Event(enable_timing=True)
        self.start_event.record()
        return self

    def __exit__(self, *args):
        self.end_event.record()
        torch.accelerator.synchronize()
        elapsed_time = self.start_event.elapsed_time(self.end_event) / 1000.0
        print(f"{self.name} time: {elapsed_time:.4f} seconds")


inputs = processor(speech_samples[0], **processor_kwargs)
inputs.to(model.device, dtype=model.dtype)
print("\n" + "="*50)
print("First generation - compiling...")
# Generate with the compiled model
with TimerContext("First generation"):
    outputs = model.generate(**inputs)
print(processor.decode(outputs))

inputs = processor(speech_samples[1], **processor_kwargs)
inputs.to(model.device, dtype=model.dtype)
print("\n" + "="*50)
print("Second generation - recording graphs...")
with TimerContext("Second generation"):
    outputs = model.generate(**inputs)
print(processor.decode(outputs))

inputs = processor(speech_samples[2], **processor_kwargs)
inputs.to(model.device, dtype=model.dtype)
print("\n" + "="*50)
print("Third generation - fast !!!")
with TimerContext("Third generation"):
    outputs = model.generate(**inputs)
print(processor.decode(outputs))

inputs = processor(speech_samples[3], **processor_kwargs)
inputs.to(model.device, dtype=model.dtype)
print("\n" + "="*50)
print("Fourth generation - still fast !!!")
with TimerContext("Fourth generation"):
    outputs = model.generate(**inputs)
print(processor.decode(outputs))

CTC 学習

from datasets import Audio, load_dataset
from transformers import AutoModelForCTC, AutoProcessor

model_id = "nvidia/parakeet-ctc-1.1b"
NUM_SAMPLES = 5

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

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

# passing `text` to the processor will prepare inputs' `labels` key
inputs = processor(audio=speech_samples, text=text_samples, sampling_rate=processor.feature_extractor.sampling_rate)
inputs.to(model.device, dtype=model.dtype)

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

RNN-Tの学習

RNN-Tの損失を計算するには、torchaudio（pip install torchaudio）が必要です。

from datasets import Audio, load_dataset
import torch
from transformers import AutoModelForRNNT, AutoProcessor

model_id = "nvidia/parakeet-rnnt-0.6b"
revision = "refs/pr/4"
NUM_SAMPLES = 4

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

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

# passing `text` to the processor will prepare inputs' `labels` key
inputs = processor(audio=speech_samples, text=text_samples, sampling_rate=processor.feature_extractor.sampling_rate)
inputs.to(model.device, dtype=model.dtype)

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

TDT 学習

from datasets import Audio, load_dataset
import torch
from transformers import AutoModelForTDT, AutoProcessor

model_id = "nvidia/parakeet-tdt-0.6b-v3"
NUM_SAMPLES = 4

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

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

# passing `text` to the processor will prepare inputs' `labels` key
inputs = processor(audio=speech_samples, text=text_samples, sampling_rate=processor.feature_extractor.sampling_rate)
inputs.to(model.device, dtype=model.dtype)

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

ParakeetTokenizer

class transformers.ParakeetTokenizer

< >

( *args**kwargs )

PreTrainedTokenizerFast のすべてのメソッドを継承します。これらのメソッドに関する詳細については、このスーパークラスを参照してください。ただし、CTCデコードに合わせてオーバーライドされている _decode は除きます。

  1. 連続するトークンをグループ化
  2. 空白トークンを除外します

ParakeetFeatureExtractor

class transformers.ParakeetFeatureExtractor

< >

( feature_size = 80sampling_rate = 16000hop_length = 160n_fft = 512win_length = 400preemphasis = 0.97padding_value = 0.0**kwargs )

パラメータ

  • feature_size (int、任意、デフォルトは 80) — 抽出された特徴量の次元数。
  • sampling_rate (int、任意、デフォルトは 16000) — オーディオファイルをデジタル化するためのサンプリングレート（ヘルツ (Hz) 表記）。
  • hop_length (int, 任意、デフォルトは 160) — Mel 周波数係数を取得するために使用される STFT の、重複ウィンドウの長さ。
  • n_fft (int、任意、デフォルトは 512) — フーリエ変換のサイズ。
  • win_length (int, 任意、デフォルトは 400) — STFT 計算に使用するウィンドウ長です。
  • preemphasis (float、任意、デフォルトは 0.97) — プリエンファシスフィルターの係数です。0.0 はプリエンファシスフィルターを適用しないことを意味します。
  • padding_value (float、任意、デフォルトは 0.0) — オーディオをパディングするために使用される値です。無音に対応する値である必要があります。

Parakeetのフィーチャーエクストラクターを構築します。

このフィーチャーエクストラクターは、主要なメソッドの大部分を含む SequenceFeatureExtractor を継承しています。これらのメソッドに関する詳細については、このスーパークラスを参照してください。

このクラスは、Short Time Fourier Transformのカスタムなnumpy実装を使用して、生の音声からメルフィルタバンク特徴量を抽出します。この実装は、pytorchのtorch.stftと同等の結果を返すようになっています。

__call__

< >

( raw_speech: numpy.ndarray | list[float] | list[numpy.ndarray] | list[list[float]]truncation: bool = Falsepad_to_multiple_of: int | None = Nonereturn_tensors: str | transformers.utils.generic.TensorType | None = Nonereturn_attention_mask: bool | None = Nonepadding: str | None = 'longest'max_length: int | None = Nonesampling_rate: int | None = Nonedo_normalize: bool | None = Nonedevice: str | None = 'cpu'return_token_timestamps: bool | None = None**kwargs )

パラメータ

  • raw_speech (np.ndarray、list[float]、list[np.ndarray]、list[list[float]]) — パディング対象のシーケンスまたはシーケンスのバッチです。各シーケンスは、NumPy 配列、浮動小数点数の値のリスト、NumPy 配列のリスト、または浮動小数点数の値のリストのリストであることができます。モノラル音声（ステレオではなく、タイムステップごとに単一の浮動小数点数）である必要があります。
  • truncation (bool、任意、デフォルトは True) — 入力シーケンスが max_length を超える場合、max_length まで切り詰めるための切り詰め処理を有効にします。
  • pad_to_multiple_of (int, 省略可能, デフォルトは None) — 設定すると、シーケンスを指定された値の倍数にパディングします。

    これは、計算能力が>= 7.5（Volta）のNVIDIAハードウェアでTensor Coresの利用を有効にするために、また、シーケンス長が128の倍数であることで恩恵を受けるTPUにおいて、特に有用です。

  • return_attention_mask (bool, 省略可) — attention mask を返すかどうか。デフォルトのままにすると、特定の feature_extractor のデフォルトに従って attention mask を返します。

    アテンションマスクとは?

    Parakeetモデルでは、バッチ推論を行う際は、微妙なバグを避けるために、attention_maskを常に渡す必要があります。

  • return_tensors (str または TensorType, 省略可) — 設定すると、Python の整数のリストではなくテンソルを返します。指定可能な値は以下の通りです:
    • 'tf': TensorFlow の tf.constant オブジェクトを返します。
    • 'pt': PyTorchのtorch.Tensorオブジェクトを返します。
    • 'np': Numpy の np.ndarray オブジェクトを返します。
  • sampling_rate (int, 任意) — raw_speech 入力がサンプリングされたレートです。サイレントエラーを防ぎ、自動音声認識パイプラインを有効にするため、forward 呼び出し時に sampling_rate を渡すことを強く推奨します。
  • padding_value (float、任意、デフォルトは 0.0) — パディングの値やベクトルを埋めるために使用される値です。
  • do_normalize (bool、任意、デフォルトはFalse) — 入力を平均0・分散1に正規化するかどうかを指定します。正規化を行うことで、モデルの性能を大幅に向上させることができます。
  • device (str、任意、デフォルトは 'cpu') — _torch_extract_fbank_features メソッドにおいて、音声信号の log-mel スペクトログラムの計算に使用するデバイスを指定します。（例: “cpu”、“cuda”）
  • return_token_timestamps (bool, 省略可, デフォルトは None) — 非推奨です。代わりに return_attention_mask を使用してください。これによりフレーム数を推定できます。

    入力raw_speechのフレーム数を返すかどうかを指定します。 これらのnum_framesは、モデルが単語レベルのタイムスタンプを計算するために使用できます。

PyTorch が利用可能な場合は PyTorch を、利用できない場合はより低速な NumPy ベースの処理を用いて、1 つ以上のシーケンスを特徴量化し、モデルへの入力として準備するための主要なメソッドです。

ParakeetProcessor

class transformers.ParakeetProcessor

< >

( feature_extractortokenizerblank_token = '<blank>'decoder_type = None )

パラメータ

  • feature_extractor (feature_extractor_class) — フィーチャーエクストラクターは必須の入力です。
  • tokenizer (tokenizer_class) — トークナイザーは必須の入力です。
  • blank_token (str、任意、デフォルトは "<blank>") — Transducer 復号用の空白トークン。
  • decoder_type (str, 省略可) — デコーディング/タイムスタンプ出力モード。指定可能な値:
    • "ctc": 連続する同一トークンは1つのエミッションにマージされます。
    • "rnnt": 繰り返しトークンは保持されます。各トークンには1フレームのタイムスタンプ範囲が割り当てられます。
    • "tdt": 繰り返しトークンは保持されます。各トークンスパンは、予測された長さに基づいて決定されます。句読点は、直前のトークンに付与されます。

    None（古いチェックポイント）の場合、後方互換性のためにデコーダーの型が自動的に推論されます。

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

ParakeetProcessor は、feature_extractor_class と tokenizer_class のすべての機能を提供します。詳細については、~feature_extractor_class および ~tokenizer_class を参照してください。

__call__

< >

( audio: typing.Union[numpy.ndarray, ForwardRef('torch.Tensor'), collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence['torch.Tensor']]text: str | list[str] | list[list[str]] | None = Nonesampling_rate: int | None = None**kwargs: *<class 'transformers.models.parakeet.processing_parakeet.ParakeetProcessorKwargs'> )

パラメータ

  • audio (Union[numpy.ndarray, torch.Tensor, collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence[torch.Tensor]]) — 準備対象のオーディオまたはオーディオのバッチです。各オーディオは NumPy 配列または PyTorch テンソルである必要があります。 NumPy 配列/PyTorch テンソルの場合、各オーディオの形状は (C, T) である必要があります。ここで C はチャネル数、T はオーディオのサンプル長です。
  • text (Union[str, list[str], list[list[str]]]、省略可) — エンコード対象のシーケンスまたはシーケンスのバッチです。各シーケンスは文字列、または文字列のリスト（事前トークン化済み文字列）であることができます。事前トークン化済みの入力を渡す場合は、バッチ入力との曖昧さを避けるために is_split_into_words=True を設定してください。
  • sampling_rate (int, 任意) — 入力オーディオのサンプリングレート (Hz) です。これは、feature extractor が想定するサンプリングレート (デフォルトは 16000 Hz) と一致する必要があります。指定された場合、processor が想定するサンプリングレートと照合され、一致しない場合はエラーが発生します。指定されなかった場合、警告が表示され、デフォルトのサンプリングレートが使用されます。
  • return_tensors (str または TensorType, 省略可) — 設定すると、特定のフレームワークのテンソルを返します。使用可能な値は以下の通りです:
    • 'pt': PyTorchのtorch.Tensorオブジェクトを返します。
    • 'np': NumPyのnp.ndarrayオブジェクトを返します。
  • **kwargs (ProcessingKwargs、任意) — 各モダリティ（テキスト、画像、動画、音声）の追加処理オプション。モデル固有のパラメータは上記にリストされています。サポートされている引数の完全なリストについては、TypedDictクラスを参照してください。

decode

< >

( *argsdurations = None**kwargs )

decode() に引数を転送し、NeMo ライブラリと同様にタイムスタンプ（TDT の場合、指定されている場合）を後処理します。

ParakeetEncoderConfig

クラス transformers.ParakeetEncoderConfig

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonehidden_size: int = 1024num_hidden_layers: int = 24num_attention_heads: int = 8intermediate_size: int = 4096hidden_act: str = 'silu'attention_bias: bool = Trueconvolution_bias: bool = Trueconv_kernel_size: int = 9subsampling_factor: int = 8subsampling_conv_channels: int = 256num_mel_bins: int = 80subsampling_conv_kernel_size: int = 3subsampling_conv_stride: int = 2dropout: float | int = 0.1dropout_positions: float | int = 0.0layerdrop: float | int = 0.1activation_dropout: float | int = 0.1attention_dropout: float | int = 0.1max_position_embeddings: int = 5000scale_input: bool = Trueinitializer_range: float = 0.02 )

パラメータ

  • hidden_size (int、任意、デフォルトは 1024) — 隠れ表現の次元数。
  • num_hidden_layers (int、任意、デフォルトは24) — Transformer デコーダーの隠れ層の数。
  • num_attention_heads (int、任意、デフォルトは 8) — Transformer デコーダーの各アテンション層におけるアテンションヘッドの数。
  • intermediate_size (int、任意、デフォルトは4096) — MLP 表現の次元数。
  • hidden_act (str、任意、デフォルトは silu) — デコーダーで使用する非線形活性化関数（関数または文字列）。例えば、"gelu"、 "relu"、"silu" など。
  • attention_bias (bool、任意、デフォルトはTrue) — 自己注意機構において、クエリ、キー、バリュー、および出力の投影層にバイアスを使用するかどうかを指定します。
  • convolution_bias (bool、任意、デフォルトはTrue) — Conformer の畳み込みモジュールでバイアスを使用するかどうか。
  • conv_kernel_size (int、任意、デフォルトは 9) — Conformer ブロック内の畳み込み層のカーネルサイズ。
  • subsampling_factor (int、任意、デフォルトは 8) — 入力シーケンスをサブサンプリングする倍率です。
  • subsampling_conv_channels (int、任意、デフォルトは 256) — サブサンプリング畳み込み層のチャネル数です。
  • num_mel_bins (int、任意、デフォルトは 80) — Mel 特徴の数を指定します。
  • subsampling_conv_kernel_size (int、省略可、デフォルトは 3) — サブサンプリング用畳み込み層のカーネルサイズです。
  • subsampling_conv_stride (int, 任意、デフォルトは 2) — サブサンプリング畳み込み層のストライドです。
  • dropout (Union[float, int]、任意、デフォルト値は0.1) — すべての dropout レイヤーの比率です。
  • dropout_positions (float、任意、デフォルト値は 0.0) — 入力シーケンスの位置に対する dropout 率です。
  • layerdrop (Union[float, int]、任意、デフォルトは 0.1) — LayerDrop の確率です。詳細は [LayerDrop の論文](https://huggingface.co/papers/1909.11556 を参照)をご覧ください。
  • activation_dropout (Union[float, int]、任意、デフォルトは 0.1) — 全結合層内の活性化の dropout 率です。
  • attention_dropout (Union[float, int]、任意、デフォルトは 0.1) — アテンション確率のドロップアウト率です。
  • max_position_embeddings (int、任意、デフォルトは 5000) — このモデルが使用される可能性のある最大シーケンス長です。
  • scale_input (bool、任意、デフォルトは True) — 入力埋め込みをスケーリングするかどうかを指定します。
  • initializer_range (float、任意、デフォルトは 0.02) — すべての重み行列を初期化するための truncated_normal_initializer の標準偏差です。

これはParakeetModelの設定を保存するための設定クラスです。指定された引数に基づいてParakeetモデルをインスタンス化し、モデルのアーキテクチャを定義するために使用されます。デフォルト値で設定をインスタンス化すると、nvidia/parakeet-ctc-1.1bと類似した設定が得られます。

設定オブジェクトはPreTrainedConfigを継承し、モデルの出力を制御するために使用できます。詳細については、PreTrainedConfigのドキュメントを参照してください。

例:

>>> from transformers import ParakeetEncoderModel, ParakeetEncoderConfig

>>> # Initializing a `ParakeetEncoder` configuration
>>> configuration = ParakeetEncoderConfig()

>>> # Initializing a model from the configuration
>>> model = ParakeetEncoderModel(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config

ParakeetCTCConfig

class transformers.ParakeetCTCConfig

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonevocab_size: int = 1025ctc_loss_reduction: str = 'mean'ctc_zero_infinity: bool = Trueencoder_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonepad_token_id: int | None = 1024 )

パラメータ

  • vocab_size (int、任意、デフォルトは 1025) — モデルの語彙サイズ。input_ids で表現できるトークンの種類数を定義します。
  • ctc_loss_reduction (str、任意、デフォルトは"mean") — torch.nn.CTCLossの出力に適用する集約方法を指定します。ParakeetForCTCのインスタンスを学習する場合にのみ関連します。
  • ctc_zero_infinity (bool、任意、デフォルトは True) — torch.nn.CTCLoss の無限損失および関連する勾配をゼロにするかどうかを指定します。無限損失は、主にインプットがターゲットにアラインされるほど短すぎる場合に発生します。ParakeetForCTC のインスタンスをトレーニングする場合にのみ関連します。
  • encoder_config (Union[dict, ParakeetEncoderConfig]、省略可) — エンコーダーの設定オブジェクトまたは辞書。
  • pad_token_id (int、任意、デフォルトは 1024) — 語彙内でパディングに使用されるトークン ID です。

これはParakeetModelの設定を保存するための設定クラスです。指定された引数に基づいてParakeetモデルをインスタンス化し、モデルのアーキテクチャを定義するために使用されます。デフォルト値で設定をインスタンス化すると、nvidia/parakeet-ctc-1.1bと類似した設定が得られます。

設定オブジェクトはPreTrainedConfigを継承し、モデルの出力を制御するために使用できます。詳細については、PreTrainedConfigのドキュメントを参照してください。

例:

>>> from transformers import ParakeetForCTC, ParakeetCTCConfig
>>> # Initializing a Parakeet configuration
>>> configuration = ParakeetCTCConfig()
>>> # Initializing a model from the configuration
>>> model = ParakeetForCTC(configuration)
>>> # Accessing the model configuration
>>> configuration = model.config

ParakeetRNNTConfig

class transformers.ParakeetRNNTConfig

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0id2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Noneis_encoder_decoder: bool = Truevocab_size: int = 8193decoder_hidden_size: int = 640num_decoder_layers: int = 2hidden_act: str = 'relu'max_symbols_per_step: int = 10encoder_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonepad_token_id: int = 2blank_token_id: int = 8192 )

パラメータ

  • is_encoder_decoder (bool、任意、デフォルトはTrue) — モデルがエンコーダー/デコーダーとして使用されるかどうかを示します。
  • vocab_size (int、任意、デフォルトは 8193) — モデルの語彙サイズ。input_ids で表現できるトークンの種類数を定義します。
  • decoder_hidden_size (int、任意、デフォルト値は 640) — LSTM 予測ネットワークおよび結合ネットワークの隠れ層サイズです。
  • num_decoder_layers (int, 省略可能、デフォルト値は 2) — 予測ネットワークにおける LSTM レイヤーの数。
  • hidden_act (str、任意、デフォルトは relu) — デコーダーで使用する非線形活性化関数（関数または文字列）。例えば、"gelu"、 "relu"、"silu" など。
  • max_symbols_per_step (int、任意、デフォルト値は 10)— 貪欲デコーディング中に、エンコーダの各タイムステップで出力するシンボルの最大数。
  • encoder_config (Union[dict, ParakeetEncoderConfig]、省略可) — エンコーダーの設定オブジェクトまたは辞書。
  • pad_token_id (int、任意、デフォルトは 2) — 語彙内でパディングに使用されるトークン ID。
  • blank_token_id (int、任意、デフォルト値は 8192) — 空白トークンの ID。RNN-T では pad_token_id と異なります。

これはParakeetModelの設定を保存するための設定クラスです。指定された引数に基づいてParakeetモデルをインスタンス化し、モデルのアーキテクチャを定義するために使用されます。デフォルト値で設定をインスタンス化すると、nvidia/parakeet-rnnt-0.6bと類似した設定が得られます。

設定オブジェクトはPreTrainedConfigを継承し、モデルの出力を制御するために使用できます。詳細については、PreTrainedConfigのドキュメントを参照してください。

例:

>>> from transformers import ParakeetForRNNT, ParakeetRNNTConfig

>>> # Initializing a Parakeet RNN-T configuration
>>> configuration = ParakeetRNNTConfig()

>>> # Initializing a model from the configuration
>>> model = ParakeetForRNNT(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config

ParakeetTDTConfig

class transformers.ParakeetTDTConfig

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0id2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Noneis_encoder_decoder: bool = Truevocab_size: int = 8193decoder_hidden_size: int = 640num_decoder_layers: int = 2hidden_act: str = 'relu'max_symbols_per_step: int = 10encoder_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonepad_token_id: int = 2blank_token_id: int = 8192durations: list[int] | tuple[int, ...] = (0, 1, 2, 3, 4) )

パラメータ

  • is_encoder_decoder (bool、任意、デフォルトはTrue) — モデルがエンコーダー/デコーダーとして使用されるかどうかを示します。
  • vocab_size (int、任意、デフォルトは 8193) — モデルの語彙サイズ。input_ids で表現できるトークンの種類数を定義します。
  • decoder_hidden_size (int、任意、デフォルト値は 640) — LSTM 予測ネットワークおよび結合ネットワークの隠れ層サイズです。
  • num_decoder_layers (int, 省略可能、デフォルト値は 2) — 予測ネットワークにおける LSTM レイヤーの数。
  • hidden_act (str、任意、デフォルトは relu) — デコーダーで使用する非線形活性化関数（関数または文字列）。例えば、"gelu"、 "relu"、"silu" など。
  • max_symbols_per_step (int、任意、デフォルト値は 10)— 貪欲デコーディング中に、エンコーダの各タイムステップで出力するシンボルの最大数。
  • encoder_config (Union[dict, ParakeetEncoderConfig]、省略可) — エンコーダーの設定オブジェクトまたは辞書。
  • pad_token_id (int、任意、デフォルトは 2) — 語彙内でパディングに使用されるトークン ID。
  • blank_token_id (int、任意、デフォルトは 8192) — 空白トークンの ID です。TDT では pad_token_id と異なります。
  • durations (list[int]、任意、デフォルトは [0, 1, 2, 3, 4]) — 予測可能なトークンの持続時間値です。各値は、トークンまたは空白の出力が何フレームにわたるかを表します。

これはParakeetModelの設定を保存するための設定クラスです。指定された引数に基づいてParakeetモデルをインスタンス化し、モデルのアーキテクチャを定義するために使用されます。デフォルト値で設定をインスタンス化すると、nvidia/parakeet-tdt-0.6b-v3と類似した設定が得られます。

設定オブジェクトはPreTrainedConfigを継承し、モデルの出力を制御するために使用できます。詳細については、PreTrainedConfigのドキュメントを参照してください。

例:

>>> from transformers import ParakeetForTDT, ParakeetTDTConfig

>>> # Initializing a Parakeet TDT configuration
>>> configuration = ParakeetTDTConfig()

>>> # Initializing a model from the configuration
>>> model = ParakeetForTDT(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config

ParakeetEncoder

class transformers.ParakeetEncoder

< >

( config: ParakeetEncoderConfig )

パラメータ

  • config (ParakeetEncoderConfig) — モデルのパラメータをすべて含むモデル設定クラスです。設定ファイルで初期化しても、モデルに関連する重みは読み込まれず、設定のみが読み込まれます。モデルの重みをロードするには、from_pretrained() メソッドを参照してください。

Fast ConformerアーキテクチャをベースとしたParakeet Encoderモデル。

このモデルは PreTrainedModel を継承しています。すべてのモデルに実装されている汎用的なメソッド（ダウンロードや保存、入力埋め込みのリサイズ、ヘッドのプルーニングなど）については、スーパークラスのドキュメントを参照してください。

このモデルは、PyTorchのtorch.nn.Moduleのサブクラスでもあります。 通常のPyTorch Moduleとして使用し、一般的な使用方法や動作に関する詳細については、PyTorchのドキュメントを参照してください。

forward

< >

( input_features: Tensorattention_mask: typing.Optional[torch.Tensor] = Noneoutput_attention_mask: bool = True**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutput or tuple(torch.FloatTensor)

パラメータ

  • input_features (torch.Tensor、形状 (batch_size, sequence_length, feature_dim)) — 入力音声特徴に対応するテンソルです。音声特徴は feature_extractor_class を使用して取得できます。詳細は feature_extractor_class.__call__ を参照してください（processor_class は音声の処理に feature_extractor_class を使用します）。
  • attention_mask (torch.Tensor の形状 (batch_size, sequence_length), 、任意) — パディングトークンのインデックスに対するアテンションを回避するためのマスク。 [0, 1]:
    • マスクされていないトークンに対して1
    • マスクされたトークンに対しては 0 です。

    アテンションマスクとは?

  • output_attention_mask (bool、任意、デフォルトは True) — 出力アテンションマスクを返すかどうか。attention_mask が指定されている場合のみ有効です。

戻り値

BaseModelOutput または tuple(torch.FloatTensor)

None や入力に応じて、さまざまな要素で構成される BaseModelOutput または torch.FloatTensor のタプル（return_dict=False が渡された場合、または config.return_dict=False の場合）。

ParakeetEncoderのforwardメソッドは、__call__特殊メソッドをオーバーライドします。

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

  • last_hidden_state (torch.FloatTensor、shape (batch_size, sequence_length, hidden_size)) — モデルの最終層の出力における隠れ状態のシーケンス。

  • hidden_states (tuple(torch.FloatTensor)、optional、output_hidden_states=True が渡された場合または config.output_hidden_states=True の場合に返されます)— torch.FloatTensor のタプル（埋め込み層を持つモデルの場合、埋め込みの出力が 1 つ、各層の出力がそれぞれ 1 つずつ）で、形状は (batch_size, sequence_length, hidden_size) です。

    各層の出力におけるモデルのHidden-states、および任意の初期埋め込み出力。

  • attentions (tuple(torch.FloatTensor)、optional、output_attentions=True が渡された場合または config.output_attentions=True の場合に返されます)— torch.FloatTensor のタプル（各レイヤーごとに1つ）、形状は (batch_size, num_heads, sequence_length, sequence_length)。

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

例:

>>> from transformers import AutoProcessor, ParakeetEncoder
>>> from datasets import load_dataset, Audio

>>> model_id = "nvidia/parakeet-ctc-1.1b"
>>> processor = AutoProcessor.from_pretrained(model_id)
>>> encoder = ParakeetEncoder.from_pretrained(model_id)

>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> ds = ds.cast_column("audio", Audio(sampling_rate=processor.feature_extractor.sampling_rate))

>>> inputs = processor(ds[0]["audio"]["array"])
>>> encoder_outputs = encoder(**inputs)

>>> print(encoder_outputs.last_hidden_state.shape)

ParakeetForCTC

class transformers.ParakeetForCTC

< >

( config: ParakeetCTCConfig )

パラメータ

  • config (ParakeetCTCConfig) — モデルのパラメータをすべて含むモデル設定クラスです。設定ファイルで初期化しても、モデルに関連する重みは読み込まれず、設定のみが読み込まれます。モデルの重みをロードするには、from_pretrained() メソッドを参照してください。

Connectionist Temporal Classification (CTC) ヘッドを備えた Parakeet Encoder。

このモデルは PreTrainedModel を継承しています。すべてのモデルに実装されている汎用的なメソッド（ダウンロードや保存、入力埋め込みのリサイズ、ヘッドのプルーニングなど）については、スーパークラスのドキュメントを参照してください。

このモデルは、PyTorchのtorch.nn.Moduleのサブクラスでもあります。 通常のPyTorch Moduleとして使用し、一般的な使用方法や動作に関する詳細については、PyTorchのドキュメントを参照してください。

forward

< >

( input_features: Tensorattention_mask: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → CausalLMOutput or tuple(torch.FloatTensor)

パラメータ

  • input_features (torch.Tensor、形状 (batch_size, sequence_length, feature_dim)) — 入力音声特徴に対応するテンソルです。音声特徴は feature_extractor_class を使用して取得できます。詳細は feature_extractor_class.__call__ を参照してください（processor_class は音声の処理に feature_extractor_class を使用します）。
  • attention_mask (torch.Tensor の形状 (batch_size, sequence_length), 、任意) — パディングトークンのインデックスに対するアテンションを回避するためのマスク。 [0, 1]:
    • マスクされていないトークンに対して1
    • マスクされたトークンに対しては 0 です。

    アテンションマスクとは?

  • labels (torch.Tensor、shape (batch_size, sequence_length)、任意) — マスク言語モデリング損失を計算するためのラベルです。インデックスは [0, ..., config.vocab_size] の範囲内であるか、-100 である必要があります（input_ids のドキュメント文字列を参照）。インデックスが -100 に設定されたトークンは無視（マスク）され、損失は [0, ..., config.vocab_size] の範囲内のラベルを持つトークンに対してのみ計算されます。

戻り値

CausalLMOutput または tuple(torch.FloatTensor)

None や入力に応じて、さまざまな要素で構成される CausalLMOutput または torch.FloatTensor のタプル（return_dict=False が渡された場合、または config.return_dict=False の場合）。

ParakeetForCTCのforwardメソッドは、__call__特殊メソッドをオーバーライドします。

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

  • loss (torch.FloatTensor、shape (1,)、optional、labels が指定された場合に返されます) — 言語モデリングの損失（次のトークン予測用）。

  • logits (torch.FloatTensor、shape (batch_size, sequence_length, config.vocab_size)) — 言語モデリングヘッドの予測スコア（SoftMax 適用前の各語彙トークンのスコア）。

  • 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後のアテンション重み。自己アテンションヘッド内で加重平均を計算するために使用されます。

例:

>>> from transformers import AutoProcessor, ParakeetForCTC
>>> from datasets import load_dataset, Audio

>>> model_id = "nvidia/parakeet-ctc-1.1b"
>>> processor = AutoProcessor.from_pretrained(model_id)
>>> model = ParakeetForCTC.from_pretrained(model_id)

>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> ds = ds.cast_column("audio", Audio(sampling_rate=processor.feature_extractor.sampling_rate))

>>> inputs = processor(ds[0]["audio"]["array"], text=ds[0]["text"])
>>> outputs = model(**inputs)

>>> print(outputs.loss)

generate

< >

( input_features: Tensorattention_mask: typing.Optional[torch.Tensor] = Nonereturn_dict_in_generate: bool = Falsecompile_config: transformers.generation.configuration_utils.CompileConfig | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> )

compile_config (CompileConfig, 任意): 指定された場合、デコーディングループ内の forward 呼び出しに torch.compile が適用されます。

例:

>>> from transformers import AutoProcessor, ParakeetForCTC
>>> from datasets import load_dataset, Audio

>>> model_id = "nvidia/parakeet-ctc-1.1b"
>>> processor = AutoProcessor.from_pretrained(model_id)
>>> model = ParakeetForCTC.from_pretrained(model_id)

>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> ds = ds.cast_column("audio", Audio(sampling_rate=processor.feature_extractor.sampling_rate))

>>> inputs = processor(ds[0]["audio"]["array"], text=ds[0]["text"])
>>> predicted_ids = model.generate(**inputs)
>>> transcription = processor.batch_decode(predicted_ids, skip_special_tokens=True)

>>> print(transcription)

ParakeetForRNNT

class transformers.ParakeetForRNNT

< >

( config: ParakeetRNNTConfig )

パラメータ

  • config (ParakeetRNNTConfig) — モデルのすべてのパラメータを含むモデル設定クラスです。設定ファイルで初期化しても、モデルに関連する重みは読み込まれず、設定のみが読み込まれます。モデルの重みをロードするには、from_pretrained() メソッドを参照してください。

RNN-T (RNN Transducer) ヘッドを備えた Parakeet Encoder。

このモデルは PreTrainedModel を継承しています。すべてのモデルに実装されている汎用的なメソッド（ダウンロードや保存、入力埋め込みのリサイズ、ヘッドのプルーニングなど）については、スーパークラスのドキュメントを参照してください。

このモデルは、PyTorchのtorch.nn.Moduleのサブクラスでもあります。 通常のPyTorch Moduleとして使用し、一般的な使用方法や動作に関する詳細については、PyTorchのドキュメントを参照してください。

forward

< >

( input_features: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonedecoder_input_ids: typing.Optional[torch.LongTensor] = Nonedecoder_cache: transformers.models.parakeet.generation_parakeet.ParakeetRNNTDecoderCache | None = Noneuse_decoder_cache: bool | None = Noneencoder_outputs: transformers.models.parakeet.modeling_parakeet.ParakeetEncoderModelOutput | tuple[torch.FloatTensor] | None = Nonelabels: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → ParakeetRNNTOutput or tuple(torch.FloatTensor)

パラメータ

  • input_features (torch.Tensor、形状 (batch_size, sequence_length, feature_dim)、任意) — 入力音声特徴に対応するテンソルです。音声特徴は feature_extractor_class を使用して取得できます。詳細は feature_extractor_class.__call__ を参照してください（processor_class は音声の処理に feature_extractor_class を使用します）。
  • attention_mask (torch.Tensor の形状 (batch_size, sequence_length), 、任意) — パディングトークンのインデックスに対するアテンションを回避するためのマスク。 [0, 1]:
    • マスクされていないトークンに対して1
    • マスクされたトークンに対しては 0 です。

    アテンションマスクとは?

  • decoder_input_ids (torch.LongTensor、形状 (batch_size, 1)、任意) — 単一ステップ推論用のデコーダー入力トークンID。
  • decoder_cache (ParakeetRNNTDecoderCache, optional) — Decoder LSTM のキャッシュです。指定されて初期化されている場合、デコーダーを実行する代わりに、キャッシュされた decoder_output が再利用されます（例: blank-skipping 時）。input_ids が指定されている場合、デコーダーが実行され、キャッシュがインプレースで更新されます。
  • use_decoder_cache (bool, 省略可) — デコーダーキャッシュを使用するかどうか。True かつ decoder_cache が None の場合、フォワードパス中に新しいキャッシュが自動的に作成されます。
  • encoder_outputs (tuple(torch.FloatTensor), 任意) — 事前計算されたエンコーダーの出力 (last_hidden_state, pooler_output, hidden_states, attentions, attention_mask)。 タプルまたは ParakeetEncoderModelOutput のいずれかです。
  • labels (torch.Tensor、shape (batch_size, sequence_length)、任意) — マスク言語モデリング損失を計算するためのラベルです。インデックスは [0, ..., config.vocab_size] の範囲内であるか、-100 である必要があります（input_ids のドキュメント文字列を参照）。インデックスが -100 に設定されたトークンは無視（マスク）され、損失は [0, ..., config.vocab_size] の範囲内のラベルを持つトークンに対してのみ計算されます。

戻り値

ParakeetRNNTOutput または tuple(torch.FloatTensor)

ParakeetRNNTOutput、またはtorch.FloatTensorのタプル（return_dict=Falseが渡された場合、またはconfig.return_dict=Falseの場合）。設定（None）や入力に応じて、さまざまな要素で構成されます。

ParakeetForRNNTのforwardメソッドは、__call__特殊メソッドをオーバーライドします。

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

  • loss (torch.FloatTensor、任意) — labels が指定された場合に返される RNN-T の損失です。
  • logits (torch.FloatTensor) — 結合トークン logits。学習時の形状は (batch, T, U+1, vocab)、単一ステップ推論時の形状は (batch, 1, 1, vocab) です。
  • decoder_cache (ParakeetRNNTDecoderCache、任意) — 隠れ状態、セル状態、および最後の出力を含む、デコーダ LSTM のキャッシュ。

例:

>>> from transformers import AutoProcessor, ParakeetForRNNT
>>> from datasets import load_dataset, Audio

>>> model_id = "nvidia/parakeet-rnnt-0.6b"
>>> processor = AutoProcessor.from_pretrained(model_id)
>>> model = ParakeetForRNNT.from_pretrained(model_id)

>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> ds = ds.cast_column("audio", Audio(sampling_rate=processor.feature_extractor.sampling_rate))

>>> inputs = processor(ds[0]["audio"]["array"])
>>> outputs = model(**inputs)

ParakeetForTDT

class transformers.ParakeetForTDT

< >

( config: ParakeetTDTConfig )

パラメータ

  • config (ParakeetTDTConfig) — モデルのパラメータをすべて含むモデル設定クラスです。設定ファイルで初期化しても、モデルに関連する重みは読み込まれず、設定のみが読み込まれます。モデルの重みをロードするには、from_pretrained() メソッドを参照してください。

TDT（Token Duration Transducer）ヘッドを備えた Parakeet Encoder。

このモデルは PreTrainedModel を継承しています。すべてのモデルに実装されている汎用的なメソッド（ダウンロードや保存、入力埋め込みのリサイズ、ヘッドのプルーニングなど）については、スーパークラスのドキュメントを参照してください。

このモデルは、PyTorchのtorch.nn.Moduleのサブクラスでもあります。 通常のPyTorch Moduleとして使用し、一般的な使用方法や動作に関する詳細については、PyTorchのドキュメントを参照してください。

forward

< >

( input_features: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonedecoder_input_ids: typing.Optional[torch.LongTensor] = Nonedecoder_cache: transformers.models.parakeet.generation_parakeet.ParakeetRNNTDecoderCache | None = Noneuse_decoder_cache: bool | None = Noneencoder_outputs: transformers.models.parakeet.modeling_parakeet.ParakeetEncoderModelOutput | tuple[torch.FloatTensor] | None = Nonelabels: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → ParakeetRNNTOutput or tuple(torch.FloatTensor)

パラメータ

  • input_features (torch.Tensor、形状 (batch_size, sequence_length, feature_dim)、任意) — 入力音声特徴に対応するテンソルです。音声特徴は feature_extractor_class を使用して取得できます。詳細は feature_extractor_class.__call__ を参照してください（processor_class は音声の処理に feature_extractor_class を使用します）。
  • attention_mask (torch.Tensor の形状 (batch_size, sequence_length), 、任意) — パディングトークンのインデックスに対するアテンションを回避するためのマスク。 [0, 1]:
    • マスクされていないトークンに対して1
    • マスクされたトークンに対しては 0 です。

    アテンションマスクとは?

  • decoder_input_ids (torch.LongTensor、形状 (batch_size, 1)、任意) — 単一ステップ推論用のデコーダー入力トークンID。
  • decoder_cache (ParakeetRNNTDecoderCache, optional) — Decoder LSTM のキャッシュです。指定されて初期化されている場合、デコーダーを実行する代わりに、キャッシュされた decoder_output が再利用されます（例: blank-skipping 時）。input_ids が指定されている場合、デコーダーが実行され、キャッシュがインプレースで更新されます。
  • use_decoder_cache (bool, 省略可) — デコーダーキャッシュを使用するかどうか。True かつ decoder_cache が None の場合、フォワードパス中に新しいキャッシュが自動的に作成されます。
  • encoder_outputs (tuple(torch.FloatTensor), 任意) — 事前計算されたエンコーダーの出力 (last_hidden_state, pooler_output, hidden_states, attentions, attention_mask)。 タプルまたは ParakeetEncoderModelOutput のいずれかです。
  • labels (torch.Tensor、shape (batch_size, sequence_length)、任意) — マスク言語モデリング損失を計算するためのラベルです。インデックスは [0, ..., config.vocab_size] の範囲内であるか、-100 である必要があります（input_ids のドキュメント文字列を参照）。インデックスが -100 に設定されたトークンは無視（マスク）され、損失は [0, ..., config.vocab_size] の範囲内のラベルを持つトークンに対してのみ計算されます。

戻り値

ParakeetRNNTOutput または tuple(torch.FloatTensor)

ParakeetRNNTOutput、またはtorch.FloatTensorのタプル（return_dict=Falseが渡された場合、またはconfig.return_dict=Falseの場合）。設定（None）や入力に応じて、さまざまな要素で構成されます。

ParakeetForTDT の forward メソッドは、__call__ という特殊メソッドをオーバーライドします。

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

  • loss (torch.FloatTensor、任意) — labels が指定された場合に返される RNN-T の損失です。
  • logits (torch.FloatTensor) — 結合トークン logits。学習時の形状は (batch, T, U+1, vocab)、単一ステップ推論時の形状は (batch, 1, 1, vocab) です。
  • decoder_cache (ParakeetRNNTDecoderCache、任意) — 隠れ状態、セル状態、および最後の出力を含む、デコーダ LSTM のキャッシュ。

例:

>>> from transformers import AutoProcessor, ParakeetForTDT
>>> from datasets import load_dataset, Audio

>>> model_id = "nvidia/parakeet-tdt-0.6b-v3"
>>> processor = AutoProcessor.from_pretrained(model_id)
>>> model = ParakeetForTDT.from_pretrained(model_id)

>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> ds = ds.cast_column("audio", Audio(sampling_rate=processor.feature_extractor.sampling_rate))

>>> inputs = processor(ds[0]["audio"]["array"])
>>> outputs = model(**inputs)
Update on GitHub

←NeuCodec PE Audio→