Migrating from self-hosted Whisper to Speech Revolutions

from faster_whisper import WhisperModel

# loads weights into GPU memory; you own the box, drivers, and VRAM
model = WhisperModel("large-v3", device="cuda", compute_type="float16")

segments, info = model.transcribe("meeting.mp3", word_timestamps=True)

# 'segments' is a lazy generator — transcription runs as you iterate
text = []
for segment in segments:
    text.append(segment.text)
    for w in segment.words:
        print(w.start, w.end, w.word)
print("".join(text))
print("language:", info.language)
# diarization? bring your own pyannote pipeline and align it yourself.

from speechrevolutions import SpeechRevolutions

client = SpeechRevolutions()  # SPEECHREVOLUTIONS_API_KEY — no GPU, no model files
result = client.transcribe("meeting.mp3", speaker_labels=True)

print(result.text)                  # already assembled
for w in result.words:              # word timestamps, in seconds
    print(w.start, w.end, w.text)
for u in result.utterances:         # diarization built in
    print(f"{u.speaker}: {u.text}")
print("languages:", result.languages)  # [{start, end, language}, ...]

import { readFileSync } from "node:fs";

// your whisper.cpp server: ./build/bin/whisper-server -m models/ggml-large-v3.bin
const form = new FormData();
form.append("file", new Blob([readFileSync("meeting.wav")]), "meeting.wav"); // 16 kHz mono WAV
form.append("response_format", "json");

const res = await fetch("http://localhost:8080/inference", { method: "POST", body: form });
const { text } = await res.json();
console.log(text);
// no word timestamps in this format, no diarization: bring your own and align it yourself.

import { SpeechRevolutions } from "speechrevolutions";

// no GPU, no model files, no server to keep up
const client = new SpeechRevolutions(); // SPEECHREVOLUTIONS_API_KEY
const result = await client.transcribe("meeting.mp3", { speakerLabels: true }); // MP3 as-is

console.log(result.text);                     // already assembled
for (const w of result.words) {               // word timestamps, in seconds
  console.log(w.start, w.end, w.text);
}
for (const u of result.utterances) {          // diarization built in
  console.log(`${u.speaker}: ${u.text}`);
}
console.log("languages:", result.languages);  // [{ start, end, language }, ...]

// Calls your own whisper.cpp server (whisper-server -m models/ggml-large-v3.bin).
package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"log"
	"mime/multipart"
	"net/http"
	"os"
)

func main() {
	audio, err := os.ReadFile("meeting.wav") // 16 kHz mono WAV
	if err != nil {
		log.Fatal(err)
	}

	var body bytes.Buffer
	form := multipart.NewWriter(&body)
	form.WriteField("response_format", "json")
	part, _ := form.CreateFormFile("file", "meeting.wav")
	part.Write(audio)
	form.Close()

	// you run this box: the GPU, the drivers, the model files, the restarts
	res, err := http.Post("http://localhost:8080/inference", form.FormDataContentType(), &body)
	if err != nil {
		log.Fatal(err)
	}
	defer res.Body.Close()

	var resp struct {
		Text string `json:"text"`
	}
	if err := json.NewDecoder(res.Body).Decode(&resp); err != nil {
		log.Fatal(err)
	}
	fmt.Println(resp.Text)
	// no word timestamps in this format, no diarization: bring your own and align it yourself.
}

package main

import (
	"context"
	"fmt"
	"log"

	stt "github.com/speechrevolutions/speechrevolutions-go"
)

func main() {
	ctx := context.Background()
	// no GPU, no model files, no server to keep up
	client, err := stt.NewClient("") // SPEECHREVOLUTIONS_API_KEY
	if err != nil {
		log.Fatal(err)
	}

	result, err := client.Transcribe(ctx, "meeting.mp3", stt.TranscribeOptions{ // MP3 as-is
		SpeakerLabels: stt.Bool(true),
	}, nil)
	if err != nil {
		log.Fatal(err)
	}

	fmt.Println(result.Text())       // already assembled
	for _, w := range result.Words { // word timestamps, in seconds
		if w.Start != nil && w.End != nil {
			fmt.Println(*w.Start, *w.End, w.Word)
		}
	}
	for _, u := range result.Utterances { // diarization built in
		fmt.Printf("%s: %s\n", u.Speaker, u.Text)
	}
	for _, l := range result.Languages { // language spans
		fmt.Println(l.Start, l.End, l.Language)
	}
}

using Whisper.net;

// loads weights into memory; you own the box, the runtime package and the model file
using var factory = WhisperFactory.FromPath("ggml-large-v3.bin");
using var processor = factory.CreateBuilder()
    .WithLanguage("auto")
    .Build();

// Whisper.net reads 16 kHz WAV, so convert with ffmpeg first
using var wav = File.OpenRead("meeting.wav");
await foreach (var segment in processor.ProcessAsync(wav))
    Console.WriteLine($"{segment.Start}->{segment.End}: {segment.Text}");
// diarization? bring your own pipeline and align it yourself.

using SpeechRevolutions;

// no GPU, no model files, no runtime package
using var client = new SpeechRevolutionsClient(); // SPEECHREVOLUTIONS_API_KEY
var result = await client.TranscribeAsync(
    "meeting.mp3", // MP3 as-is, no WAV conversion
    new TranscribeOptions { SpeakerLabels = true });

Console.WriteLine(result.Text);          // already assembled
foreach (var w in result.Words)          // word timestamps, in seconds
    Console.WriteLine($"{w.Start} {w.End} {w.Text}");
foreach (var u in result.Utterances)     // diarization built in
    Console.WriteLine($"{u.Speaker}: {u.Text}");
foreach (var l in result.Languages)      // language spans
    Console.WriteLine($"{l.Start} {l.End} {l.Language}");