Implementacija prepisa v realnem času v Pythonu
Na tej strani
Posodobitev tečaja z dne 3. novembra 2026 za Voxtral 3, na podlagi vodnika Mistral Migrate from Voxtral 2: modeli Voxtral 2 (
voxtral-mini-2602,voxtral-mini-transcribe-realtime-2602,voxtral-mini-tts-2603, zastareli 31. oktobra 2026 in umaknjeni 30. aprila 2027) so v primerih nadomeščeni zvoxtral-mini-transcribe-3,voxtral-mini-transcribe-realtime-3invoxtral-mini-tts-3-0. Ključne spremembe: časovni žigi so samo po segmentih (wordvrne napako 400), diarizacija je mogoča v realnem času, nastavitve seje v realnem času so zaklenjene po prvem zvočnem delčku, vnosicontext_biaspa so proste oblike (fraze s presledki). Viri: Migrate from Voxtral 2 · Speech to Text.
Celoten asinhroni tok v Pythonu
Zdaj boš napisal celoten cevovod za prepis v realnem času, od prvega zvočnega bajta do končne besedilne datoteke. Vse temelji na asyncio: program mora hkrati brati zvok in prejemati dogodke modela, ne da bi katera koli operacija blokirala drugo. Standardna sinhrona koda bi tukaj preprosto čakala, latenca, ki si jo skrbno konfiguriral, pa bi izginila v mrtvem času tvojega lastnega programa.
Arhitektura programa za pretakanje
Ne glede na aplikacijo struktura ostaja enaka in se bere od leve proti desni. Navzgor je zvočni vir: asinhroni generator, ki proizvaja zvočne delčke PCM. Danes je to lahko datoteka, jutri mikrofon ali omrežni tok. V sredini je odjemalec Voxtral, kar pomeni SDK, ki potiska te delčke modelu in ti vrača dogodke. Navzdol je obdelava dogodkov: tvoja poslovna logika, ki prikazuje besedilo, ga kopiči, shranjuje ali posreduje drugi storitvi.
Audio Source → [PCM chunks] → Mistral SDK → [events] → Your Code
Ta ločitev ima praktično prednost: zvočni vir je zamenljiv. Koda za prepis, ki jo napišeš spodaj, bo delovala enako z generatorjem mikrofona iz naslednje lekcije, ne da bi spremenil eno samo vrstico.
Osnovna implementacija
Dve podrobnosti v tem prvem programu si zaslužita tvojo pozornost. Generator source_audio_fichier razreže datoteko na bloke po 32.000 bajtov, kar točno ustreza eni sekundi 16-bitnega mono PCM zvoka pri 16 kHz: 16.000 vzorcev, pomnoženih z 2 bajtoma. Ukaz await asyncio.sleep po vsakem yield simulira realni čas; komentiraj to vrstico in zaženi program na nekajminutnem izseku ter videl boš, da je datoteka porabljena v delčku sekunde, kar te ne bo naučilo ničesar o obnašanju pretoka. Na strani sprejema texte_complet kopiči fragmente, tako da imaš na koncu na voljo celotno besedilo, poleg živega prikaza.
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):
"""Asinhroni generator, ki bere PCM datoteko v delčkih.
taille_chunk = 32000 bajtov = 1 sekunda 16-bitnega mono PCM zvoka pri 16kHz
(16000 vzorcev × 2 bajta = 32000 bajtov)
"""
with open(chemin, "rb") as f:
while True:
chunk = f.read(taille_chunk)
if not chunk:
break
yield chunk
# Simulacija realnega časa (1 delček = 1 sekunda)
await asyncio.sleep(len(chunk) / 32000)
async def transcrire_realtime(source_audio):
"""Prepiše zvočni tok v realnem času z Voxtralom."""
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--- Prepis končan ---")
return "".join(texte_complet)
async def main():
source = source_audio_fichier("audio.pcm")
texte = await transcrire_realtime(source)
# Shrani rezultat
with open("transcription_realtime.txt", "w", encoding="utf-8") as f:
f.write(texte)
print(f"\nBesedilo shranjeno ({len(texte)} znakov)")
asyncio.run(main())
Živi prikaz temelji na print(event.text, end="", flush=True). Brez flush=True Python medpomni izhod in besedilo bi se pojavljalo v serijah: tvoj prepis bi bil tehnično v realnem času, a vizualno trzajoč.
Strukturiranje obdelave za proizvodnjo
Ko tvoja aplikacija preraste demo fazo, zanka if/elif postane okorna: želiš šteti fragmente, meriti trajanje, priklopiti zaslon ali napajati bazo podatkov. Težavo enkrat za vselej rešiš z encapsulacijo logike v razred. Vsaka vrsta dogodka dobi svojo namensko metodo, dodajaš pa lahko tudi vedenje – na primer pošiljanje vsakega delta zapisa spletnemu vmesniku – ne da bi se dotaknil zanke za sprejem.
class GestionnaireTranscription:
"""Upravlja dogodke prepisa v realnem času."""
def __init__(self):
self.texte_complet = []
self.nb_deltas = 0
self.debut = None
async def traiter(self, source_audio):
"""Začne prepis in obdela dogodke."""
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):
"""Klicano za vsak nov fragment besedila."""
self.texte_complet.append(event.text)
self.nb_deltas += 1
# Živi prikaz
print(event.text, end="", flush=True)
def _on_done(self, event):
"""Klicano ob koncu prepisa."""
import time
duree = time.time() - self.debut
print(f"\n\nKončano v {duree:.1f}s")
print(f"Prejeti fragmenti: {self.nb_deltas}")
def obtenir_resultat(self) -> str:
"""Vrne celotno prepisano besedilo."""
return "".join(self.texte_complet)
async def main():
gestionnaire = GestionnaireTranscription()
source = source_audio_fichier("audio.pcm")
texte = await gestionnaire.traiter(source)
print(f"Rezultat: {len(texte)} znakov")
asyncio.run(main())
Števec nb_deltas ni zgolj trik: glede na trajanje zvoka kaže hitrost oddajanja modela in te opozori, če se tok poslabša.
Preživetje omrežnih prekinitev
Pretokovna povezava ostane odprta ves čas govora, kar jo izpostavlja veliko bolj kot nekajsekundno zahtevo brez povezave. Utripajoč Wi-Fi, preklop omrežja na mobilni napravi ali izpad operaterja lahko prekine tok. Spodnji vzorec ponovno zažene prepis do trikrat, z zamikom, ki se z vsakim poskusom povečuje, da se omrežju omogoči čas za obnovitev. Poleg tega se izjema posreduje naprej: eksplicitna napaka je boljša od aplikacije, ki se zdi, kot da ne posluša ničesar.
import asyncio
from mistralai.client import Mistral
from mistralai.client.models import (
AudioFormat,
TranscriptionStreamTextDelta,
TranscriptionStreamDone
)
MAX_TENTATIVES = 3
DELAI_RECONNEXION = 2 # sekunde
async def transcrire_avec_retry(source_audio, tentative=1):
"""Prepis z samodejno ponovno povezavo."""
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[Končano]")
except ConnectionError as e:
if tentative < MAX_TENTATIVES:
print(f"\nOmrežna napaka (poskus {tentative}/{MAX_TENTATIVES})")
await asyncio.sleep(DELAI_RECONNEXION * tentative)
await transcrire_avec_retry(source_audio, tentative + 1)
else:
print(f"\nNeuspešno po {MAX_TENTATIVES} poskusih: {e}")
raise
Priprava obstoječe datoteke
Za testiranje z datoteko MP3 ali WAV, ki jo že imaš pri roki, lahko avtomatiziraš pretvorbo v PCM iz Pythona, namesto da bi jo izvajal ročno. Spodnja funkcija delo prepusti FFmpeg-u, iz imena vhoda izpelje izhodno ime in vrne nastalo pot, pripravljeno za predajo source_audio_fichier.
import subprocess
def convertir_en_pcm(chemin_entree: str, chemin_sortie: str = None) -> str:
"""Pretvori zvočno datoteko v 16-bitni 16kHz mono PCM prek 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
# Uporaba
chemin_pcm = convertir_en_pcm("reunion.mp3")
# Nato uporabi source_audio_fichier(chemin_pcm)
Pri tej funkciji bodi previden pri dveh stvareh. check=True sproži izjemo, če FFmpeg odpove, kar je bolje, kot da kasneje v toku odkriješ prazno PCM datoteko; capture_output=True pa skrije izhod orodja, zato se bo dolg postopek pretvorbe zdel, kot da je program zamrznil. Pri urah dolgih posnetkih načrtuj izpis sporočila pred klicem in po njem.
Ključne ugotovitve
- Pretakanje uporablja asinhrone generatorje (
async for,yield) - Delček 32.000 bajtov = 1 sekunda 16-bitnega mono PCM zvoka pri 16 kHz
- Obdelavo dogodkov strukturiraj v razred za proizvodnjo
- Implementiraj mehanizem za ponovne poskuse za obravnavo omrežnih napak
- Uporabi FFmpeg za pretvorbo obstoječih zvočnih datotek v PCM
- Živi prikaz uporablja
print(text, end="", flush=True)