Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Implementera realtidstranskribering i Python

Lektion 10 av 16 Uppdaterad 3 november 2026 Utvecklare
På denna sida
  1. Den kompletta asynkrona Python-strömmen
  2. Arkitektur för strömmande program
  3. Grundläggande implementering
  4. Strukturera bearbetning för produktion
  5. Överleva nätverksavbrott
  6. Förbereda en befintlig fil
  7. Viktiga punkter

Kursen uppdaterad den 3 november 2026 för Voxtral 3, baserat på Mistral:s guide Migrate from Voxtral 2: Voxtral 2-modeller (voxtral-mini-2602, voxtral-mini-transcribe-realtime-2602, voxtral-mini-tts-2603), avvecklade den 31 oktober 2026 och helt borttagna den 30 april 2027, ersätts i exemplen med voxtral-mini-transcribe-3, voxtral-mini-transcribe-realtime-3 och voxtral-mini-tts-3-0. Viktiga ändringar: tidsstämplar finns endast på segmentnivå (word returnerar ett 400-fel), talardifferentiering är möjlig i realtid, inställningar för realtidssession låses efter första ljudklumpen, och inmatningar för context_bias är fritext (fraser med mellanslag). Källor: Migrate from Voxtral 2 · Speech to Text.

Den kompletta asynkrona Python-strömmen

Nu ska du skriva en komplett pipeline för realtidstranskribering, från den första ljudbyten till den slutliga textfilen. Allt bygger på asyncio: programmet måste läsa ljud och ta emot händelser från modellen samtidigt, utan att någon av operationerna blockerar den andra. Vanlig synkron kod skulle helt enkelt vänta här, och den latens du noggrant konfigurerat skulle försvinna i ditt eget programs dödtid.

Arkitektur för strömmande program

Oavsett applikation är strukturen densamma och läses från vänster till höger. Uppströms finns en ljudkälla: en asynkron generator som producerar PCM-ljudklumpar. Idag kan det vara en fil, imorgon en mikrofon eller en nätverksström. I mitten finns Voxtral-klienten, det vill säga SDK:t, som skickar dessa klumpar till modellen och ger dig händelser. Nedströms finns händelsehantering: din affärslogik, som visar texten, ackumulerar den, sparar den eller vidarebefordrar den till en annan tjänst.

Audio Source → [PCM chunks] → Mistral SDK → [events] → Your Code

Denna uppdelning har en praktisk fördel: ljudkällan är utbytbar. Transkriberingskoden du skriver nedan fungerar exakt likadant med mikrofon-generatorn från nästa lektion, utan att du behöver ändra en enda rad.

Grundläggande implementering

Två detaljer i detta första program förtjänar din uppmärksamhet. Generatorn source_audio_fichier delar upp filen i block om 32 000 byte, vilket motsvarar exakt en sekund 16-bitars mono PCM-ljud vid 16 kHz: 16 000 sampel multiplicerat med 2 byte. await asyncio.sleep efter varje yield simulerar realtid; kommentera bort denna rad och kör programmet på ett utdrag på några minuter, så kommer du se att filen konsumeras på en bråkdels sekund, vilket inte lär dig något om strömbeteende. På mottagningssidan ackumulerar texte_complet fragment så att du har hela texten tillgänglig vid slutet, utöver visningen live.

import asyncio
import os
from mistralai.client import Mistral
from mistralai.client.models import (
    AudioFormat,
    TranscriptionStreamTextDelta,
    TranscriptionStreamDone
)

async def source_audio_fichier(chemin: str, taille_chunk: int = 32000):
    """Asynkron generator som läser en PCM-fil i klumpar.

    taille_chunk = 32000 byte = 1 sekund 16-bitars mono PCM-ljud vid 16kHz
    (16000 sampel × 2 byte = 32000 byte)
    """
    with open(chemin, "rb") as f:
        while True:
            chunk = f.read(taille_chunk)
            if not chunk:
                break
            yield chunk
            # Simulera realtid (1 klump = 1 sekund)
            await asyncio.sleep(len(chunk) / 32000)

async def transcrire_realtime(source_audio):
    """Transkriberar en ljudström i realtid med Voxtral."""
    client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])

    audio_format = AudioFormat(
        encoding="pcm_s16le",
        sample_rate=16000
    )

    texte_complet = []

    async for event in client.audio.realtime.transcribe_stream(
        audio_stream=source_audio,
        model="voxtral-mini-transcribe-realtime-3",
        audio_format=audio_format,
    ):
        if isinstance(event, TranscriptionStreamTextDelta):
            print(event.text, end="", flush=True)
            texte_complet.append(event.text)

        elif isinstance(event, TranscriptionStreamDone):
            print("\n\n--- Transkribering avslutad ---")

    return "".join(texte_complet)

async def main():
    source = source_audio_fichier("audio.pcm")
    texte = await transcrire_realtime(source)

    # Spara resultatet
    with open("transcription_realtime.txt", "w", encoding="utf-8") as f:
        f.write(texte)
    print(f"\nText sparad ({len(texte)} tecken)")

asyncio.run(main())

Live-visningen förlitar sig på print(event.text, end="", flush=True). Utan flush=True buffrar Python utdata och texten skulle visas i satser: din transkribering skulle vara tekniskt sett i realtid, men visuellt hackig.

Strukturera bearbetning för produktion

När din applikation går bortom en demo blir if/elif-loopen klumpig: du vill räkna fragment, mäta duration, koppla ihop en display eller mata en databas. Att kapsla in logiken i en klass löser problemet en gång för alla. Varje händelsetyp får sin egen dedikerade metod, och du kan lägga till beteenden – till exempel att skicka varje delta till ett webbgränssnitt – utan att röra mottagningsloopen.

class GestionnaireTranscription:
    """Hanterar händelser för realtidstranskribering."""

    def __init__(self):
        self.texte_complet = []
        self.nb_deltas = 0
        self.debut = None

    async def traiter(self, source_audio):
        """Startar transkribering och bearbetar händelser."""
        import time
        self.debut = time.time()

        client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
        audio_format = AudioFormat(encoding="pcm_s16le", sample_rate=16000)

        async for event in client.audio.realtime.transcribe_stream(
            audio_stream=source_audio,
            model="voxtral-mini-transcribe-realtime-3",
            audio_format=audio_format,
        ):
            if isinstance(event, TranscriptionStreamTextDelta):
                self._on_text_delta(event)
            elif isinstance(event, TranscriptionStreamDone):
                self._on_done(event)

        return self.obtenir_resultat()

    def _on_text_delta(self, event):
        """Anropas för varje nytt textfragment."""
        self.texte_complet.append(event.text)
        self.nb_deltas += 1
        # Live-visning
        print(event.text, end="", flush=True)

    def _on_done(self, event):
        """Anropas vid slutet av transkriberingen."""
        import time
        duree = time.time() - self.debut
        print(f"\n\nAvslutad på {duree:.1f}s")
        print(f"Mottagna fragment: {self.nb_deltas}")

    def obtenir_resultat(self) -> str:
        """Returnerar den fullständiga transkriberade texten."""
        return "".join(self.texte_complet)

async def main():
    gestionnaire = GestionnaireTranscription()
    source = source_audio_fichier("audio.pcm")
    texte = await gestionnaire.traiter(source)
    print(f"Resultat: {len(texte)} tecken")

asyncio.run(main())

Räknaren nb_deltas är ingen gimmick: i relation till ljudets duration indikerar den modellens utmatningshastighet och varnar dig om strömmen försämras.

Överleva nätverksavbrott

En strömmande anslutning hålls öppen under hela talets duration, vilket utsätter den mycket mer än en offline-begäran på några sekunder. Ett flimrande Wi-Fi, en nätverksväxling på en mobil enhet eller ett operatörsavbrott kan bryta strömmen. Mönstret nedan startar om transkriberingen upp till tre gånger, med en fördröjning som ökar för varje försök för att ge nätverket tid att återhämta sig. Därefter propageras undantaget: ett explicit misslyckande är bättre än en applikation som verkar lyssna på ingenting.

import asyncio
from mistralai.client import Mistral
from mistralai.client.models import (
    AudioFormat,
    TranscriptionStreamTextDelta,
    TranscriptionStreamDone
)

MAX_TENTATIVES = 3
DELAI_RECONNEXION = 2  # sekunder

async def transcrire_avec_retry(source_audio, tentative=1):
    """Transkribering med automatisk återanslutning."""
    client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
    audio_format = AudioFormat(encoding="pcm_s16le", sample_rate=16000)

    try:
        async for event in client.audio.realtime.transcribe_stream(
            audio_stream=source_audio,
            model="voxtral-mini-transcribe-realtime-3",
            audio_format=audio_format,
        ):
            if isinstance(event, TranscriptionStreamTextDelta):
                print(event.text, end="", flush=True)
            elif isinstance(event, TranscriptionStreamDone):
                print("\n[Avslutad]")

    except ConnectionError as e:
        if tentative < MAX_TENTATIVES:
            print(f"\nNätverksfel (försök {tentative}/{MAX_TENTATIVES})")
            await asyncio.sleep(DELAI_RECONNEXION * tentative)
            await transcrire_avec_retry(source_audio, tentative + 1)
        else:
            print(f"\nMisslyckades efter {MAX_TENTATIVES} försök: {e}")
            raise

Förbereda en befintlig fil

För att testa med en MP3- eller WAV-fil du redan har till hands kan du automatisera konverteringen till PCM från Python istället för att köra den manuellt. Funktionen nedan delegerar arbetet till FFmpeg, härleder utdatanamnet från inmatningsnamnet och returnerar den resulterande sökvägen, redo att skickas till source_audio_fichier.

import subprocess

def convertir_en_pcm(chemin_entree: str, chemin_sortie: str = None) -> str:
    """Konverterar en ljudfil till 16-bitars 16kHz mono PCM via FFmpeg."""
    if chemin_sortie is None:
        chemin_sortie = chemin_entree.rsplit(".", 1)[0] + ".pcm"

    subprocess.run([
        "ffmpeg", "-y",
        "-i", chemin_entree,
        "-f", "s16le",
        "-acodec", "pcm_s16le",
        "-ar", "16000",
        "-ac", "1",
        chemin_sortie
    ], check=True, capture_output=True)

    return chemin_sortie

# Användning
chemin_pcm = convertir_en_pcm("reunion.mp3")
# Använd sedan source_audio_fichier(chemin_pcm)

Två försiktighetsåtgärder med denna funktion. check=True kastar ett undantag om FFmpeg misslyckas, vilket är bättre än att senare i strömmen upptäcka en tom PCM-fil; och capture_output=True döljer verktygets utdata, så en lång konvertering får programmet att se fruset ut. För inspelningar på timmar bör du planera att skriva ut ett meddelande före och efter anropet.

Viktiga punkter

  • Strömning använder asynkrona generatorer (async for, yield)
  • En klump på 32 000 byte = 1 sekund 16-bitars mono PCM-ljud vid 16 kHz
  • Strukturera händelsebearbetning i en klass för produktion
  • Implementera en återförsöksmekanism för att hantera nätverksfel
  • Använd FFmpeg för att konvertera befintliga ljudfiler till PCM
  • Live-visning använder print(text, end="", flush=True)