# Parakeet

## 概要

Parakeetモデルは、[NVIDIA NeMoによって導入された](https://developer.nvidia.com/blog/pushing-the-boundaries-of-speech-recognition-with-nemo-parakeet-asr-models/)、[Fast Conformer](https://docs.nvidia.com/nemo-framework/user-guide/latest/nemotoolkit/asr/models.html#fast-conformer)エンコーダーと、自動音声認識用のconnectionist temporal classification (CTC)、recurrent neural network transducer (RNNT)、またはtoken and duration transducer (TDT)デコーダーを組み合わせたモデルです。

**モデルアーキテクチャ**

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

元の実装は[NVIDIA NeMo](https://github.com/NVIDIA/NeMo)にあります。モデルのチェックポイントは[NVIDIA組織](https://huggingface.co/nvidia/models?search=parakeet)の下にあります。

このモデルは、[Nithin Rao Koluguri](https://huggingface.co/nithinraok)、[Eustache Le Bihan](https://huggingface.co/eustlb)、[Eric Bezzam](https://huggingface.co/bezzam)、[Maksym Lypivskyi](https://huggingface.co/MaksL)、[Hainan Xu](https://huggingface.co/hainanx) によって提供されました。

## 使用方法

### ParakeetForCTCの使用方法

```python
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'}
```

```python
from datasets import Audio, load_dataset

from transformers import AutoModelForCTC, AutoProcessor

model_id = "nvidia/parakeet-ctc-1.1b"
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForCTC.from_pretrained(model_id, 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]]

inputs = processor(speech_samples, sampling_rate=processor.feature_extractor.sampling_rate)
inputs.to(model.device, dtype=model.dtype)
outputs = model.generate(**inputs)
print(processor.decode(outputs))
```

### ParakeetForRNNTの使用方法

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

```py
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'}
```

```py
from transformers import AutoModelForRNNT, AutoProcessor
from datasets import load_dataset, Audio

model_id = "nvidia/parakeet-rnnt-0.6b"
revision = "refs/pr/4"
processor = AutoProcessor.from_pretrained(model_id, revision=revision)
model = AutoModelForRNNT.from_pretrained(model_id, revision=revision, 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]]

inputs = processor(speech_samples, sampling_rate=processor.feature_extractor.sampling_rate)
inputs.to(model.device, dtype=model.dtype)
output = model.generate(**inputs, return_dict_in_generate=True)
print(processor.decode(output.sequences, skip_special_tokens=True))
```

TDT（トークンごとの持続時間を予測する）とは異なり、RNN-Tの各トークンは単一のエンコーダーフレームで出力されるため、その開始と終了はちょうど1フレーム分に相当します。

```py
from datasets import Audio, load_dataset
from transformers import AutoModelForRNNT, AutoProcessor

model_id = "nvidia/parakeet-rnnt-0.6b"
revision = "refs/pr/4"
processor = AutoProcessor.from_pretrained(model_id, revision=revision)
model = AutoModelForRNNT.from_pretrained(model_id, revision=revision, 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"][:1]]

inputs = processor(speech_samples, sampling_rate=processor.feature_extractor.sampling_rate)
inputs.to(model.device, dtype=model.dtype)
output = model.generate(**inputs, return_dict_in_generate=True)
decoded_output, decoded_timestamps = processor.decode(
    output.sequences,
    durations=output.durations,
    skip_special_tokens=True,
)
print("Transcription:", decoded_output)
print("\nTimestamped tokens:", decoded_timestamps)

"""
Transcription: ['mister quilter is the apostle of the middle classes and we are glad to welcome his gospel']

Timestamped tokens: [[{'token': 'm', 'start': 0.4, 'end': 0.48}, {'token': 'is', 'start': 0.56, 'end': 0.64}, {'token': 'ter', 'start': 0.56, 'end': 0.64}, {'token': ' qu', 'start': 0.72, 'end': 0.8}, {'token': 'il', 'start': 0.96, 'end': 1.04}, {'token': 'ter', 'start': 1.12, 'end': 1.2}, {'token': ' is', 'start': 1.36, 'end': 1.44}, {'token': ' the', 'start': 1.52, 'end': 1.6}, {'token': ' ap', 'start': 1.68, 'end': 1.76}, {'token': 'o', 'start': 1.76, 'end': 1.84}, {'token': 'st', 'start': 1.84, 'end': 1.92}, {'token': 'le', 'start': 2.0, 'end': 2.08}, {'token': ' of', 'start': 2.16, 'end': 2.24}, {'token': ' the', 'start': 2.24, 'end': 2.32}, {'token': ' m', 'start': 2.4, 'end': 2.48}, {'token': 'id', 'start': 2.48, 'end': 2.56}, {'token': 'd', 'start': 2.56, 'end': 2.64}, {'token': 'le', 'start': 2.56, 'end': 2.64}, {'token': ' cl', 'start': 2.8, 'end': 2.88}, {'token': 'ass', 'start': 2.88, 'end': 2.96}, {'token': 'es', 'start': 3.12, 'end': 3.2}, {'token': ' and', 'start': 3.28, 'end': 3.36}, {'token': ' we', 'start': 3.44, 'end': 3.52}, {'token': ' are', 'start': 3.6, 'end': 3.68}, {'token': ' gl', 'start': 3.84, 'end': 3.92}, {'token': 'ad', 'start': 3.92, 'end': 4.0}, {'token': ' to', 'start': 4.08, 'end': 4.16}, {'token': ' we', 'start': 4.24, 'end': 4.32}, {'token': 'l', 'start': 4.32, 'end': 4.4}, {'token': 'c', 'start': 4.4, 'end': 4.48}, {'token': 'ome', 'start': 4.48, 'end': 4.56}, {'token': ' his', 'start': 4.72, 'end': 4.8}, {'token': ' go', 'start': 4.96, 'end': 5.04}, {'token': 's', 'start': 5.04, 'end': 5.12}, {'token': 'pe', 'start': 5.2, 'end': 5.28}, {'token': 'l', 'start': 5.36, 'end': 5.44}]]
"""
```

### ParakeetForTDTの使用方法

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

```py
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.'}
```

```py
from transformers import AutoModelForTDT, AutoProcessor
from datasets import load_dataset, Audio

model_id = "nvidia/parakeet-tdt-0.6b-v3"
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForTDT.from_pretrained(model_id, 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]]

inputs = processor(speech_samples, sampling_rate=processor.feature_extractor.sampling_rate)
inputs.to(model.device, dtype=model.dtype)
output = model.generate(**inputs, return_dict_in_generate=True)
print(processor.decode(output.sequences, skip_special_tokens=True))
```

```py
from datasets import Audio, load_dataset
from transformers import AutoModelForTDT, AutoProcessor

model_id = "nvidia/parakeet-tdt-0.6b-v3"
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForTDT.from_pretrained(model_id, 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"][:1]]

inputs = processor(speech_samples, sampling_rate=processor.feature_extractor.sampling_rate)
inputs.to(model.device, dtype=model.dtype)
output = model.generate(**inputs, return_dict_in_generate=True)
decoded_output, decoded_timestamps = processor.decode(
    output.sequences,
    durations=output.durations,
    skip_special_tokens=True,
)
print("Transcription:", decoded_output)
print("\nTimestamped tokens:", decoded_timestamps)

"""
Transcription: ['mister Quilter is the apostle of the middle classes, and we are glad to welcome his gospel.']

Timestamped tokens: [[{'token': 'm', 'start': 0.24, 'end': 0.48}, {'token': 'ister', 'start': 0.48, 'end': 0.64}, {'token': 'Qu', 'start': 0.64, 'end': 0.88}, {'token': 'il', 'start': 0.88, 'end': 1.12}, {'token': 'ter', 'start': 1.12, 'end': 1.36}, {'token': 'is', 'start': 1.36, 'end': 1.44}, {'token': 'the', 'start': 1.44, 'end': 1.6}, {'token': 'ap', 'start': 1.6, 'end': 1.76}, {'token': 'ost', 'start': 1.76, 'end': 1.92}, {'token': 'le', 'start': 2.0, 'end': 2.16}, {'token': 'of', 'start': 2.16, 'end': 2.24}, {'token': 'the', 'start': 2.24, 'end': 2.4}, {'token': 'mid', 'start': 2.4, 'end': 2.48}, {'token': 'd', 'start': 2.48, 'end': 2.56}, {'token': 'le', 'start': 2.56, 'end': 2.64}, {'token': 'clas', 'start': 2.72, 'end': 2.88}, {'token': 's', 'start': 2.88, 'end': 3.04}, {'token': 'es', 'start': 3.04, 'end': 3.12}, {'token': ',', 'start': 3.12, 'end': 3.12}, {'token': 'and', 'start': 3.2800000000000002, 'end': 3.44}, {'token': 'we', 'start': 3.44, 'end': 3.6}, {'token': 'are', 'start': 3.6, 'end': 3.7600000000000002}, {'token': 'gl', 'start': 3.7600000000000002, 'end': 3.92}, {'token': 'ad', 'start': 3.92, 'end': 4.08}, {'token': 'to', 'start': 4.08, 'end': 4.24}, {'token': 'wel', 'start': 4.24, 'end': 4.4}, {'token': 'c', 'start': 4.4, 'end': 4.48}, {'token': 'ome', 'start': 4.48, 'end': 4.72}, {'token': 'his', 'start': 4.72, 'end': 4.96}, {'token': 'gos', 'start': 4.96, 'end': 5.12}, {'token': 'pel', 'start': 5.36, 'end': 5.6000000000000005}, {'token': '.', 'start': 5.6000000000000005, 'end': 5.6000000000000005}]]
"""
```

### モデルを高速に動かす

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

```python
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 学習

```python
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の学習

> [!NOTE]
> RNN-Tの損失を計算するには、[torchaudio](https://pytorch.org/audio)（`pip install torchaudio`）が必要です。

```py
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 学習

```py
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[[transformers.ParakeetTokenizer]]

#### transformers.ParakeetTokenizer[[transformers.ParakeetTokenizer]]

```python
transformers.ParakeetTokenizer(*args, **kwargs)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/parakeet/tokenization_parakeet.py#L20)

[PreTrainedTokenizerFast](/docs/transformers/main/ja/main_classes/tokenizer#transformers.TokenizersBackend) のすべてのメソッドを継承します。これらのメソッドに関する詳細は、`_decode` についてはCTCデコードに合わせてオーバーライドされているため、このスーパークラスを参照してください。
1. 連続するトークンをグループ化
2. 空白トークンを除外します

## ParakeetFeatureExtractor[[transformers.ParakeetFeatureExtractor]]

#### transformers.ParakeetFeatureExtractor[[transformers.ParakeetFeatureExtractor]]

```python
transformers.ParakeetFeatureExtractor(feature_size = 80, sampling_rate = 16000, hop_length = 160, n_fft = 512, win_length = 400, preemphasis = 0.97, padding_value = 0.0, **kwargs)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/parakeet/feature_extraction_parakeet.py#L38)

**パラメータ:**

feature_size (`int`、*任意*、デフォルトは 80) : 抽出された特徴量の次元数。

sampling_rate (`int`、*optional*、デフォルトは 16000) : 音声ファイルをデジタル化するためのサンプリングレート（ヘルツ (Hz) 単位）。

hop_length (`int`, *optional*, デフォルトは 160) : Mel 周波数係数を取得するために使用される STFT の、重複ウィンドウの長さ。

n_fft (`int`, *任意*, デフォルトは 512) : フーリエ変換のサイズ。

win_length (`int`、*任意*、デフォルトは 400) : STFT 計算のウィンドウ長です。

preemphasis (`float`、*optional*、デフォルトは 0.97) : 事前強調フィルターの係数です。0.0 は事前強調フィルターを適用しないことを意味します。

padding_value (`float`、*optional*、デフォルト値は 0.0) : 音声のパディングに使用される値です。無音に対応する値である必要があります。

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

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

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

#### __call__[[transformers.ParakeetFeatureExtractor.__call__]]

```python
__call__(raw_speech: numpy.ndarray | list[float] | list[numpy.ndarray] | list[list[float]], truncation: bool = False, pad_to_multiple_of: int | None = None, return_tensors: str | transformers.utils.generic.TensorType | None = None, return_attention_mask: bool | None = None, padding: str | None = 'longest', max_length: int | None = None, sampling_rate: int | None = None, do_normalize: bool | None = None, device: str | None = 'cpu', return_token_timestamps: bool | None = None, **kwargs)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/parakeet/feature_extraction_parakeet.py#L129)

**パラメータ:**

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_attention_mask (`bool`, *任意*) : attention mask を返すかどうか。デフォルトのままにすると、特定の feature_extractor のデフォルトに従って attention mask を返します。 [attention mask とは?](../glossary#attention-mask)    Parakeet モデルでは、微妙なバグを避けるために、バッチ推論では常に `attention_mask` を渡す必要があります。

return_tensors (`str` または [TensorType](/docs/transformers/main/ja/internal/file_utils#transformers.TensorType)、*optional*) : 設定されている場合、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は、モデルが単語レベルのタイムスタンプを計算するために使用できます。

1つ以上のシーケンスを特徴量化し、モデル用に準備するための主要なメソッドです。実装では、利用可能な場合はSTFTの計算にPyTorchを使用し、利用できない場合はより低速なNumPyベースの処理を使用します。

## ParakeetProcessor[[transformers.ParakeetProcessor]]

#### transformers.ParakeetProcessor[[transformers.ParakeetProcessor]]

```python
transformers.ParakeetProcessor(feature_extractor, tokenizer, blank_token = '<blank>', decoder_type = None)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/parakeet/processing_parakeet.py#L45)

**パラメータ:**

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

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

blank_token (`str`、*任意*、デフォルトは`"<blank>"`) : transducerデコーディング用の空白トークン。

decoder_type (`str`, *任意*) : デコード/タイムスタンプ出力モード。使用可能な値: - `"ctc"`: 連続する同一トークンは1つの出力にマージされます。 - `"rnnt"`: 繰り返しトークンは保持されます。各トークンは1フレームのタイムスタンプ範囲を取得します。 - `"tdt"`: 繰り返しトークンは保持されます。各トークンスパンは予測された持続時間に基づきます。句読点は直前のトークンに付与されます。 `None` の場合（古いチェックポイント）、後方互換性のためにデコーダータイプが自動的に推論されます。

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

[ParakeetProcessor](/docs/transformers/main/ja/model_doc/parakeet#transformers.ParakeetProcessor) は、`feature_extractor_class` と `tokenizer_class` のすべての機能を提供します。詳細については、`~feature_extractor_class` および `~tokenizer_class` を参照してください。

#### __call__[[transformers.ParakeetProcessor.__call__]]

```python
__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 = None, sampling_rate: int | None = None, **kwargs: *<class 'transformers.models.parakeet.processing_parakeet.ParakeetProcessorKwargs'>)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/parakeet/processing_parakeet.py#L73)

**パラメータ:**

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`, *optional*) : 入力オーディオのサンプリングレート（Hz）。これは、フィーチャーエクストラクターが想定するサンプリングレートと一致する必要があります（デフォルトは 16000 Hz）。指定された場合、プロセッサが想定するサンプリングレートと照合され、一致しない場合はエラーが発生します。指定されなかった場合、警告が発行され、デフォルトのサンプリングレートが使用されます。

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 クラスを参照してください。

#### decode[[transformers.ParakeetProcessor.decode]]

```python
decode(*args, durations = None, **kwargs)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/parakeet/processing_parakeet.py#L132)

[decode()](/docs/transformers/main/ja/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.decode) に引数を渡し、NeMo ライブラリと同様にタイムスタンプ（TDT の場合に指定されている場合）を後処理します。

## ParakeetEncoderConfig[[transformers.ParakeetEncoderConfig]]

#### transformers.ParakeetEncoderConfig[[transformers.ParakeetEncoderConfig]]

```python
transformers.ParakeetEncoderConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, hidden_size: int = 1024, num_hidden_layers: int = 24, num_attention_heads: int = 8, intermediate_size: int = 4096, hidden_act: str = 'silu', attention_bias: bool = True, convolution_bias: bool = True, conv_kernel_size: int = 9, subsampling_factor: int = 8, subsampling_conv_channels: int = 256, num_mel_bins: int = 80, subsampling_conv_kernel_size: int = 3, subsampling_conv_stride: int = 2, dropout: float | int = 0.1, dropout_positions: float | int = 0.0, layerdrop: float | int = 0.1, activation_dropout: float | int = 0.1, attention_dropout: float | int = 0.1, max_position_embeddings: int = 5000, scale_input: bool = True, initializer_range: float = 0.02)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/parakeet/configuration_parakeet.py#L23)

**パラメータ:**

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

num_hidden_layers (`int`、*optional*、デフォルトは `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`, *optional*, デフォルトは 9) : Conformer ブロック内の畳み込み層のカーネルサイズ。

subsampling_factor (`int`, *optional*, デフォルトは 8) : 入力シーケンスをサブサンプリングする倍率です。

subsampling_conv_channels (`int`、*任意*、デフォルトは 256) : サブサンプリング畳み込み層のチャネル数。

num_mel_bins (`int`、*optional*、デフォルトは 80) : mel 特徴の数量。

subsampling_conv_kernel_size (`int`、*optional*、デフォルトは 3) : サブサンプリング畳み込み層のカーネルサイズ。

subsampling_conv_stride (`int`、*optional*、デフォルトは 2) : サブサンプリング畳み込み層のストライドです。

dropout (`Union[float, int]`、*任意*、デフォルトは`0.1`) : すべての dropout 層の比率。

dropout_positions (`float`、*任意*、デフォルトは 0.0) : 入力シーケンスの位置に対する dropout 率です。

layerdrop (`Union[float, int]`、*任意*、デフォルトは`0.1`) : LayerDrop の確率です。詳細については、[LayerDrop の論文](see 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`、*optional*、デフォルトは`5000`) : このモデルが使用される可能性のある最大シーケンス長。

scale_input (`bool`、*任意*、デフォルトは`True`) : 入力埋め込みをスケーリングするかどうか。

initializer_range (`float`、*任意*、デフォルトは`0.02`) : すべての重み行列を初期化するためのtruncated_normal_initializerの標準偏差です。

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

設定オブジェクトは [PreTrainedConfig](/docs/transformers/main/ja/main_classes/configuration#transformers.PreTrainedConfig) を継承し、モデルの出力を制御するために使用できます。詳細については、[PreTrainedConfig](/docs/transformers/main/ja/main_classes/configuration#transformers.PreTrainedConfig) のドキュメントを参照してください。

例:
```python
>>> 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[[transformers.ParakeetCTCConfig]]

#### transformers.ParakeetCTCConfig[[transformers.ParakeetCTCConfig]]

```python
transformers.ParakeetCTCConfig(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, vocab_size: int = 1025, ctc_loss_reduction: str = 'mean', ctc_zero_infinity: bool = True, encoder_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, pad_token_id: int | None = 1024)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/parakeet/configuration_parakeet.py#L91)

**パラメータ:**

vocab_size (`int`、*任意*、デフォルトは`1025`) : モデルの語彙サイズ。`input_ids`で表現できるトークンの種類数を定義します。

ctc_loss_reduction (`str`、*任意*、デフォルトは`"mean"`) : `torch.nn.CTCLoss`の出力に適用する集約方法を指定します。[ParakeetForCTC](/docs/transformers/main/ja/model_doc/parakeet#transformers.ParakeetForCTC)のインスタンスを学習する場合にのみ関連します。

ctc_zero_infinity (`bool`、*任意*、デフォルトは`True`) : `torch.nn.CTCLoss`の無限損失および関連する勾配をゼロにするかどうか。無限損失は、入力がターゲットにアラインされるほど短すぎる場合に主に発生します。[ParakeetForCTC](/docs/transformers/main/ja/model_doc/parakeet#transformers.ParakeetForCTC)のインスタンスをトレーニングする場合にのみ関連します。

encoder_config (`Union[dict, ParakeetEncoderConfig]`, *任意*) : エンコーダーの設定オブジェクトまたは辞書。

pad_token_id (`int`, *任意*, デフォルトは `1024`) : 語彙内でパディングに使用されるトークンID。

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

設定オブジェクトは [PreTrainedConfig](/docs/transformers/main/ja/main_classes/configuration#transformers.PreTrainedConfig) を継承し、モデルの出力を制御するために使用できます。詳細については、[PreTrainedConfig](/docs/transformers/main/ja/main_classes/configuration#transformers.PreTrainedConfig) のドキュメントを参照してください。

例:

```python
>>> 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[[transformers.ParakeetRNNTConfig]]

#### transformers.ParakeetRNNTConfig[[transformers.ParakeetRNNTConfig]]

```python
transformers.ParakeetRNNTConfig(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 = 8193, decoder_hidden_size: int = 640, num_decoder_layers: int = 2, hidden_act: str = 'relu', max_symbols_per_step: int = 10, encoder_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, pad_token_id: int = 2, blank_token_id: int = 8192)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/parakeet/configuration_parakeet.py#L134)

**パラメータ:**

is_encoder_decoder (`bool`、*任意*、デフォルトは`True`) : モデルがエンコーダー/デコーダーとして使用されるかどうかを示します。

vocab_size (`int`、*任意*、デフォルトは`8193`) : モデルの語彙サイズ。`input_ids`で表現できるトークンの種類数を定義します。

decoder_hidden_size (`int`、*optional*、デフォルトは 640) : LSTM 予測ネットワークおよびジョイントネットワークの隠れ層サイズ。

num_decoder_layers (`int`、*optional*、デフォルトは 2) : 予測ネットワークにおける LSTM レイヤーの数。

hidden_act (`str`、*任意*、デフォルトは `relu`) : デコーダーで使用する非線形活性化関数（関数または文字列）。例えば、`"gelu"`、`"relu"`、`"silu"` など。

max_symbols_per_step (`int`、*optional*、デフォルトは 10) : グリーディーデコーディング中に、エンコーダの各タイムステップで出力するシンボルの最大数。

encoder_config (`Union[dict, ParakeetEncoderConfig]`, *任意*) : エンコーダーの設定オブジェクトまたは辞書。

pad_token_id (`int`、*任意*、デフォルトは `2`) : 語彙内でパディングに使用されるトークン ID。

blank_token_id (`int`、*optional*、デフォルトは 8192) : 空白トークン ID。RNN-T では `pad_token_id` と異なります。

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

設定オブジェクトは [PreTrainedConfig](/docs/transformers/main/ja/main_classes/configuration#transformers.PreTrainedConfig) を継承し、モデルの出力を制御するために使用できます。詳細については、[PreTrainedConfig](/docs/transformers/main/ja/main_classes/configuration#transformers.PreTrainedConfig) のドキュメントを参照してください。

例:
```python
>>> 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[[transformers.ParakeetTDTConfig]]

#### transformers.ParakeetTDTConfig[[transformers.ParakeetTDTConfig]]

```python
transformers.ParakeetTDTConfig(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 = 8193, decoder_hidden_size: int = 640, num_decoder_layers: int = 2, hidden_act: str = 'relu', max_symbols_per_step: int = 10, encoder_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, pad_token_id: int = 2, blank_token_id: int = 8192, durations: list[int] | tuple[int, ...] = (0, 1, 2, 3, 4))
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/parakeet/configuration_parakeet.py#L182)

**パラメータ:**

is_encoder_decoder (`bool`、*任意*、デフォルトは`True`) : モデルがエンコーダー/デコーダーとして使用されるかどうかを示します。

vocab_size (`int`、*任意*、デフォルトは`8193`) : モデルの語彙サイズ。`input_ids`で表現できるトークンの種類数を定義します。

decoder_hidden_size (`int`、*optional*、デフォルトは 640) : LSTM 予測ネットワークおよびジョイントネットワークの隠れ層サイズ。

num_decoder_layers (`int`、*optional*、デフォルトは 2) : 予測ネットワークにおける LSTM レイヤーの数。

hidden_act (`str`、*任意*、デフォルトは `relu`) : デコーダーで使用する非線形活性化関数（関数または文字列）。例えば、`"gelu"`、`"relu"`、`"silu"` など。

max_symbols_per_step (`int`、*optional*、デフォルトは 10) : グリーディーデコーディング中に、エンコーダの各タイムステップで出力するシンボルの最大数。

encoder_config (`Union[dict, ParakeetEncoderConfig]`, *任意*) : エンコーダーの設定オブジェクトまたは辞書。

pad_token_id (`int`、*任意*、デフォルトは `2`) : 語彙内でパディングに使用されるトークン ID。

blank_token_id (`int`、*optional*、デフォルトは 8192) : 空白トークン ID。TDT においては `pad_token_id` と異なります。

durations (`list[int]`、*optional*、デフォルトは`[0, 1, 2, 3, 4]`) : 予測可能なトークンの持続時間値です。各値は、トークンまたは空白の出力が何フレームにわたるかを表します。

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

設定オブジェクトは [PreTrainedConfig](/docs/transformers/main/ja/main_classes/configuration#transformers.PreTrainedConfig) を継承し、モデルの出力を制御するために使用できます。詳細については、[PreTrainedConfig](/docs/transformers/main/ja/main_classes/configuration#transformers.PreTrainedConfig) のドキュメントを参照してください。

例:
```python
>>> 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[[transformers.ParakeetEncoder]]

#### transformers.ParakeetEncoder[[transformers.ParakeetEncoder]]

```python
transformers.ParakeetEncoder(config: ParakeetEncoderConfig)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/parakeet/modeling_parakeet.py#L534)

**パラメータ:**

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

[Fast Conformerアーキテクチャ](https://huggingface.co/papers/2305.05084)をベースとしたParakeet Encoderモデル。

このモデルは [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.ParakeetEncoder.forward]]

```python
forward(input_features: Tensor, attention_mask: typing.Optional[torch.Tensor] = None, output_attention_mask: bool = True, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/parakeet/modeling_parakeet.py#L557)

**パラメータ:**

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`、shape `(batch_size, sequence_length)`、*任意*) : padding トークンのインデックスに対する attention を回避するためのマスクです。マスクの値は `[0, 1]` から選択されます:  - **マスクされない**トークンは 1、- **マスクされる**トークンは 0。  [attention マスクとは?](../glossary#attention-mask)

output_attention_mask (`bool`、*任意*、デフォルトは`True`) : 出力のattention maskを返すかどうか。`attention_mask`が提供されている場合のみ有効です。

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

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

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

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

- **last_hidden_state** (`torch.Tensor`、形状 `(batch_size, sequence_length, hidden_size)`) -- モデルの最終層の出力における隠れ状態のシーケンス。
- **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
>>> 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[[transformers.ParakeetForCTC]]

#### transformers.ParakeetForCTC[[transformers.ParakeetForCTC]]

```python
transformers.ParakeetForCTC(config: ParakeetCTCConfig)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/parakeet/modeling_parakeet.py#L679)

**パラメータ:**

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

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

このモデルは [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.ParakeetForCTC.forward]]

```python
forward(input_features: Tensor, attention_mask: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/parakeet/modeling_parakeet.py#L690)

**パラメータ:**

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`、shape `(batch_size, sequence_length)`、*任意*) : padding トークンのインデックスに対する attention を回避するためのマスクです。マスクの値は `[0, 1]` から選択されます:  - **マスクされない**トークンは 1、- **マスクされる**トークンは 0。  [attention マスクとは?](../glossary#attention-mask)

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

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

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

[ParakeetForCTC](/docs/transformers/main/ja/model_doc/parakeet#transformers.ParakeetForCTC)の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後のアテンション重み。自己アテンションヘッド内で加重平均を計算するために使用されます。

例:

```python
>>> 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[[transformers.ParakeetForCTC.generate]]

```python
generate(input_features: Tensor, attention_mask: typing.Optional[torch.Tensor] = None, return_dict_in_generate: bool = False, compile_config: transformers.generation.configuration_utils.CompileConfig | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/parakeet/modeling_parakeet.py#L750)

compile_config ([CompileConfig](/docs/transformers/main/ja/internal/generation_utils#transformers.CompileConfig)、*任意*): 指定された場合、デコーディングループ内の forward 呼び出しに `torch.compile` が適用されます。

例:

```python
>>> 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[[transformers.ParakeetForRNNT]]

#### transformers.ParakeetForRNNT[[transformers.ParakeetForRNNT]]

```python
transformers.ParakeetForRNNT(config: ParakeetRNNTConfig)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/parakeet/modeling_parakeet.py#L902)

**パラメータ:**

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

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

このモデルは [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.ParakeetForRNNT.forward]]

```python
forward(input_features: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, decoder_input_ids: typing.Optional[torch.LongTensor] = None, decoder_cache: transformers.models.parakeet.generation_parakeet.ParakeetRNNTDecoderCache | None = None, use_decoder_cache: bool | None = None, encoder_outputs: transformers.models.parakeet.modeling_parakeet.ParakeetEncoderModelOutput | tuple[torch.Tensor] | None = None, labels: typing.Optional[torch.Tensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/parakeet/modeling_parakeet.py#L932)

**パラメータ:**

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`、shape `(batch_size, sequence_length)`、*任意*) : padding トークンのインデックスに対する attention を回避するためのマスクです。マスクの値は `[0, 1]` から選択されます:  - **マスクされない**トークンは 1、- **マスクされる**トークンは 0。  [attention マスクとは?](../glossary#attention-mask)

decoder_input_ids (`torch.LongTensor`、形状 `(batch_size, 1)`、*任意*) : 単一ステップ推論用のデコーダー入力トークンID。

decoder_cache (`ParakeetRNNTDecoderCache`, *任意*) : デコーダーのLSTMキャッシュ。指定され初期化されている場合、デコーダーを実行する代わりに、キャッシュされた`decoder_output`が再利用されます（例：blankスキッピング中）。`input_ids`が指定されている場合、デコーダーが実行され、キャッシュがインプレースで更新されます。

use_decoder_cache (`bool`, *任意*) : デコーダキャッシュを使用するかどうか。`True` かつ `decoder_cache` が `None` の場合、フォワードパス中に新しいキャッシュが自動的に作成されます。

encoder_outputs (`tuple(torch.Tensor)`, *任意*) : 事前計算されたエンコーダーの出力 (last_hidden_state, pooler_output, hidden_states, attentions, attention_mask)。タプルまたは`ParakeetEncoderModelOutput`のいずれかです。

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

**戻り値:** `ParakeetRNNTOutput` または `tuple(torch.Tensor)`

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

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

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

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

例:

```python
>>> 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[[transformers.ParakeetForTDT]]

#### transformers.ParakeetForTDT[[transformers.ParakeetForTDT]]

```python
transformers.ParakeetForTDT(config: ParakeetTDTConfig)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/parakeet/modeling_parakeet.py#L1032)

**パラメータ:**

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

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

このモデルは [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.ParakeetForTDT.forward]]

```python
forward(input_features: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, decoder_input_ids: typing.Optional[torch.LongTensor] = None, decoder_cache: transformers.models.parakeet.generation_parakeet.ParakeetRNNTDecoderCache | None = None, use_decoder_cache: bool | None = None, encoder_outputs: transformers.models.parakeet.modeling_parakeet.ParakeetEncoderModelOutput | tuple[torch.Tensor] | None = None, labels: typing.Optional[torch.Tensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/parakeet/modeling_parakeet.py#L1041)

**パラメータ:**

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`、shape `(batch_size, sequence_length)`、*任意*) : padding トークンのインデックスに対する attention を回避するためのマスクです。マスクの値は `[0, 1]` から選択されます:  - **マスクされない**トークンは 1、- **マスクされる**トークンは 0。  [attention マスクとは?](../glossary#attention-mask)

decoder_input_ids (`torch.LongTensor`、形状 `(batch_size, 1)`、*任意*) : 単一ステップ推論用のデコーダー入力トークンID。

decoder_cache (`ParakeetRNNTDecoderCache`, *任意*) : デコーダーのLSTMキャッシュ。指定され初期化されている場合、デコーダーを実行する代わりに、キャッシュされた`decoder_output`が再利用されます（例：blankスキッピング中）。`input_ids`が指定されている場合、デコーダーが実行され、キャッシュがインプレースで更新されます。

use_decoder_cache (`bool`, *任意*) : デコーダキャッシュを使用するかどうか。`True` かつ `decoder_cache` が `None` の場合、フォワードパス中に新しいキャッシュが自動的に作成されます。

encoder_outputs (`tuple(torch.Tensor)`, *任意*) : 事前計算されたエンコーダーの出力 (last_hidden_state, pooler_output, hidden_states, attentions, attention_mask)。タプルまたは`ParakeetEncoderModelOutput`のいずれかです。

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

**戻り値:** `ParakeetRNNTOutput` または `tuple(torch.Tensor)`

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

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

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

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

例:

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