Introduktion til realtids-transskription
På denne side
Kurset opdateret 3. november 2026 til Voxtral 3, baseret på Mistral-guiden Migrate from Voxtral 2: Voxtral 2-modellerne (
voxtral-mini-2602,voxtral-mini-transcribe-realtime-2602,voxtral-mini-tts-2603), der blev udfaset 31. oktober 2026 og helt trukket tilbage 30. april 2027, erstattes i eksemplerne afvoxtral-mini-transcribe-3,voxtral-mini-transcribe-realtime-3ogvoxtral-mini-tts-3-0. Vigtige ændringer: Tidsstempler findes kun på segmentniveau (wordgiver en 400-fejl), højttaleradskillelse (diarization) er tilgængelig i realtid, indstillinger for realtidssessioner låses efter det første lyd-chunk, ogcontext_bias-input er frit format (fraser med mellemrum). Kilder: Migrate from Voxtral 2 · Speech to Text.
Et nyt paradigme: Lyd-streaming
Indtil videre har du arbejdet i offline-tilstand: Du sender en komplet lydfil, venter på, at modellen behandler den, og bruger derefter resultatet. Denne arbejdsgang passer til eksisterende optagelser som arkiverede møder, podcasts eller interviews. Den bryder sammen, når lyden ankommer løbende: Ingen vil vente til slutningen af en to timers konference for at se de første undertekster, og en stemmeassistent, der først forstår et spørgsmål efter lang stilhed, virker defekt.
Voxtral Realtime imødekommer dette behov med en streaming-arkitektur. Lyden transskriberes løbende, ord for ord, og forsinkelsen mellem lyd og tekst bliver en indstilling, du selv styrer, helt ned til 200 millisekunder. Skiftet er lige så meget mentalt som teknisk: Du tænker ikke længere i isolerede anmodninger, men i streams, og dit program skal være klar til at modtage tekst når som helst.
Hvad realtidsmodellen tilbyder
Modellen kaldes under identifikatoren voxtral-mini-transcribe-realtime-3 og adskiller sig fundamentalt fra sin offline-modpart. Den modtager lyd-chunks og udsender løbende tekstfragmenter uden nogensinde at vente på, at optagelsen slutter. Dens latenstid styres af parameteren target_streaming_delay_ms, som du vil dykke ned i senere i dette kursus. Den dækker 45 sprog og dialekter, og sproget kan enten fastlåses eller registreres automatisk. Forgængeren fra Generation 2, voxtral-mini-transcribe-realtime-2602 (4 milliarder parametre), er udgivet som open weights under Apache 2.0-licensen på Hugging Face Hub til fuldt suveræn installation på dine egne servere.
Med Voxtral 3 har realtidsydelsen næsten indhentet offline-tilstanden. Højttaleradskillelse (diarization) er tilgængelig – dog ikke i samme session som detektering af talestop – ligesom kontekstbias og detektering af talestop. To forskelle består: Segmenter bærer højttalerlabelen, men ingen start- eller sluttidspunkter, og alle sessionsindstillinger (sprog, ordforråd, højttaleradskillelse, forsinkelse) skal sendes før det første lyd-chunk, hvorefter de låses. Hvis dit brugstilfælde kræver præcise tidsstempler, skal du bruge offline-tilstand, eventuelt som supplement til realtid.
Installation
Mistral SDK indlæser ikke streaming-afhængigheder som standard. Du skal eksplicit anmode om realtime-ekstraen, hvilket tilføjer support til WebSocket-forbindelser og asynkron lydbehandling:
pip install "mistralai[realtime]"
Det krævede lydformat
I modsætning til offline-tilstand, der accepterer en bred vifte af containere, forventer Voxtral Realtime en rå stream i ét enkelt, ikke-forhandlingsbart format:
- Kodning: 16-bit signed little-endian PCM (
pcm_s16le) - Sample rate: 16.000 Hz (16 kHz)
- Kanaler: Mono (1 kanal)
Denne begrænsning er ingen showstopper: Dette format er det mest standardiserede, der findes, og alle optageværktøjer producerer det nativt, uanset om det er PyAudio, FFmpeg eller PulseAudio. Du deklarerer det én gang over for klienten, som bruger det til at fortolke de bytes, du sender.
from mistralai.client.models import AudioFormat
# Definer lydformatet
audio_format = AudioFormat(
encoding="pcm_s16le",
sample_rate=16000
)
De to stream-begivenheder
Når du itererer over transskriptionen, returnerer SDK to typer objekter. TranscriptionStreamTextDelta udsendes for hvert nyt transskriberet fragment og indeholder den delvise tekst, du kan vise med det samme; det er dette, der driver brugerens skærm. TranscriptionStreamDone ankommer præcis én gang, når lyd-streamen slutter, uanset om det er ved slutningen af en fil, eller når mikrofonen lukkes; det signalerer, at der ikke kommer mere, og at du kan konsolidere resultatet. Hele din logik passer derfor ind i en asynkron løkke, der skelner mellem disse to tilfælde:
from mistralai.client.models import (
TranscriptionStreamTextDelta,
TranscriptionStreamDone
)
async for event in flux_transcription:
if isinstance(event, TranscriptionStreamTextDelta):
# Ny tekst tilgængelig
print(event.text, end="", flush=True)
elif isinstance(event, TranscriptionStreamDone):
# Transskription afsluttet
print("\n[Finished]")
Første komplette eksempel
For at blive fortrolig med mekanismen uden at skulle bruge en mikrofon, er den enkleste tilgang at simulere en stream fra en fil, der allerede er konverteret til PCM. Funktionen lire_fichier_pcm er en asynkron generator: Den læser filen i blokke og yielder dem én efter én, præcis som et lydkort ville gøre. Resten af programmet er noget, du vil genbruge senere uden ændringer.
import asyncio
import os
from mistralai.client import Mistral
from mistralai.client.models import (
AudioFormat,
TranscriptionStreamTextDelta,
TranscriptionStreamDone
)
client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
audio_format = AudioFormat(encoding="pcm_s16le", sample_rate=16000)
async def lire_fichier_pcm(chemin: str, taille_chunk: int = 32000):
"""Læser en PCM-fil i chunks for at simulere en stream."""
with open(chemin, "rb") as f:
while True:
chunk = f.read(taille_chunk)
if not chunk:
break
yield chunk
async def main():
flux_audio = lire_fichier_pcm("audio.pcm")
async for event in client.audio.realtime.transcribe_stream(
audio_stream=flux_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\nTransskription afsluttet.")
asyncio.run(main())
Hvis din kildefil er en MP3, kan den ikke sendes som den er: Konverter den først med FFmpeg, og sørg for at håndhæve de tre egenskaber, modellen kræver.
ffmpeg -i audio.mp3 -f s16le -acodec pcm_s16le -ar 16000 -ac 1 audio.pcm
Hvornår skal du skifte til realtid?
Valgkriteriet er simpelt: Realtid er berettiget, når nogen venter på teksten, mens lyden produceres. Dette gælder for live-undertekster til en konference, et webinar eller et onlinekursus, hvor publikum læser, mens de lytter; til en stemmeassistent, der skal forstå brugeren, mens denne taler, for at kunne svare uden akavede pauser; til diktering, hvor tale bliver til tekst foran talerens øjne; og endelig til konferencetransskription, hvor teksten skal vises, efterhånden som den tales. Alle andre steder forbliver offline-tilstanden rigere og simplere at implementere.
De følgende lektioner viser dig, hvordan du optager fra mikrofonen, finjusterer latenstiden og bygger disse brugstilfælde fra ende til ende.
Vigtige pointer
- Voxtral Mini Transcribe Realtime 3 transskriberer lyd i streaming-tilstand med en justerbar forsinkelse fra 80 ms til 1,2 s (eller 2,4 s)
- Krævet lydformat: 16-bit PCM, 16 kHz, mono
- To begivenhedstyper:
TextDelta(delvis tekst) ogDone(slut) - Installer med
pip install "mistralai[realtime]" - Asynkron programmering krævet (
async/await) - Højttaleradskillelse (ekskl. detektering af talestop) og kontekstbias tilgængelig i realtid, uden segment-tidsstempler; indstillinger låses efter første lyd-chunk
- Generation 2 af realtidsmodellen er open weights under Apache 2.0 til suveræn udrulning