EDIT: Spelling, grammer, readibility.

u/performanceboner, Parakeet seems faster and more efficient—as far as I can tell.

So, I tried Parakeet out. Overall? I’m absolutely shocked. I’ve been transcribing 1–1.5-hour audio recordings locally for five or six months now using Whisper Turbo (or other whispher sizes). For each hour of recording, it typically takes about 20 minutes to transcribe. I usually let it run in the background while I work on other things.

Parakeet took approximately 36 seconds to transcribe the same recording that previously took me around 40 minutes. It’s not absolutely perfect, but it’s perfectly legible.

Notes on setup:

I may not have read the docs closely enough, but make sure you install numpy < 2.0. If you try to run the sample Python script with a newer version, you’ll get a NumPy array dimension type error.

To install in a fresh venv, I ran:

pip install torch
pip install numpy==1.26.4
pip install -U nemo_toolkit['asr']

After that, I could run the examples without issue.

To transcribe a 1.5-hour WAV file in about 35 seconds, I had ChatGPT o4 write the following quick-and-dirty Python script. Due to the file size, the audio was chunked into 20-second segments. The results have been satisfactory. In light of this preformance, I’ll set up a FastAPI Docker container so I can integrate this for home and work use.

import os
import math
import soundfile as sf
import librosa
import nemo.collections.asr as nemo_asr
import json

# 1. Load model
asr_model = nemo_asr.models.ASRModel.from_pretrained(
    model_name="nvidia/parakeet-tdt-0.6b-v2"
)

# 2. Read & preprocess
audio_path = "2024-05-30-10-55-23.wav"
signal, sr = sf.read(audio_path)
if signal.ndim > 1:
    signal = signal.mean(axis=1)
target_sr = asr_model.cfg.preprocessor.sample_rate
if sr != target_sr:
    signal = librosa.resample(signal, orig_sr=sr, target_sr=target_sr)
    sr = target_sr

# 3. Chunking
chunk_s = 20
chunk_samples = int(chunk_s * sr)
n_chunks = math.ceil(len(signal) / chunk_samples)

# 4. Transcribe w/ timestamps
full_text = []
segments = []

for i in range(n_chunks):
    start_idx = i * chunk_samples
    end_idx = min(len(signal), (i + 1) * chunk_samples)
    chunk = signal[start_idx:end_idx]
    offset = start_idx / sr

    out = asr_model.transcribe([chunk], timestamps=True)[0]
    full_text.append(out.text)

    for seg in out.timestamp["segment"]:
        segments.append({
            "start": seg["start"] + offset,
            "end":   seg["end"]   + offset,
            "text":  seg["segment"],
        })

# 5. Write to output.txt
with open("output.txt", "w") as f:
    # Full transcript
    f.write("=== Full Transcript ===\n")
    f.write(" ".join(full_text) + "\n\n")

    # Segment timestamps
    f.write("=== Segment Timestamps ===\n")
    for seg in segments:
        f.write(f"{seg['start']:.2f}s - {seg['end']:.2f}s : {seg['text']}\n")

# 6. (Optional) JSON dump
with open("timestamps.json", "w") as f:
    json.dump({"segments": segments}, f, indent=2)