Teosta reaalajas transkriptsioon Pythonis
Sellel lehel
Kursust uuendati 3. novembril 2026 Voxtral 3 jaoks, tuginedes Mistrali juhendile Migrate from Voxtral 2: Voxtral 2 mudelid (
voxtral-mini-2602,voxtral-mini-transcribe-realtime-2602,voxtral-mini-tts-2603), mis tunnistati aegunuks 31. oktoobril 2026 ja lõpetati 30. aprillil 2027, on näidetes asendatud mudelitegavoxtral-mini-transcribe-3,voxtral-mini-transcribe-realtime-3javoxtral-mini-tts-3-0. Peamised muudatused: ajatemplid on ainult lõigu tasemel (wordtagastab vea 400), diaariseerimine on võimalik reaalajas, reaalajas seansi seaded lukustuvad pärast esimest helilõiku jacontext_biassisendid on vabas vormingus (fraasid tühikutega). Allikad: Migrate from Voxtral 2 · Speech to Text.
Täielik asünkroonne voog Pythonis
Nüüd kirjutad sa täieliku reaalajas transkriptsiooni torustiku, alates esimesest helibaidist kuni lõpliku tekstifailini. Kõik põhineb asyncio-l: programm peab lugema heli ja võtma vastu mudeli sündmusi samaaegselt, ilma et kumbki toiming teist blokeeriks. Tavaline sünkroonne kood lihtsalt ootaks sellises olukorras ja latentsus, mille sa hoolikalt seadistasid, kaoks su programmi surnud aja sisse.
Voogudega töötava programmi arhitektuur
Sõltumata rakendusest jääb struktuur samaks ja loetakse vasakult paremale. Ülesvoolu asub heliallikas: asünkroonne generaator, mis toodab PCM-helilõike. Täna võib see olla fail, homme mikrofon või võrguvoog. Keskel on Voxtrali klient, ehk SDK, mis surub need lõigud mudelile ja annab sündmusi sulle. Allavoolu toimub sündmuste töötlemine: sinu äriloogika, mis kuvab teksti, kogub seda, salvestab või edastab teisele teenusele.
Heliallikas → [PCM lõigud] → Mistral SDK → [sündmused] → Sinu kood
Sellel eraldatusel on praktiline kasu: heliallikat saab vahetada. Allpool kirjutatud transkriptsioonikood töötab identselt järgmise tunni mikrofonigeneraatoriga, ilma et peaksid rida muutma.
Põhiline teostus
Selles esimeses programmis väärivad tähelepanu kaks detaili. Generaator source_audio_fichier lõikab faili 32 000-baidisteks plokkideks, mis vastab täpselt ühele sekundile 16-bitises monos PCM-helis sagedusega 16 kHz: 16 000 diskreetimist korrutatuna 2 baidiga. Järgnev await asyncio.sleep pärast iga yield-i simuleerib reaalaja kulgu; kommenteeri see rida välja ja käivita programm mõneminutilisel lõigul ning näed, et fail tarbitakse murdosa sekundiga, õpetamata sulle voogude käitumise kohta midagi. Vastuvõtu poolel kogub texte_complet fragmente, nii et sul on lõpus olemas kogu tekst lisaks otsekuvale.
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):
"""Asünkroonne generaator, mis loeb PCM-faili tükkidena.
taille_chunk = 32000 baiti = 1 sekund 16-bitist mono PCM-heli sagedusega 16 kHz
(16000 diskreetimist × 2 baiti = 32000 baiti)
"""
with open(chemin, "rb") as f:
while True:
chunk = f.read(taille_chunk)
if not chunk:
break
yield chunk
# Simuleeri reaalaja kulgu (1 lõik = 1 sekund)
await asyncio.sleep(len(chunk) / 32000)
async def transcrire_realtime(source_audio):
"""Transkribeerib helivoo reaalajas Voxtrali abil."""
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--- Transkriptsioon lõpetatud ---")
return "".join(texte_complet)
async def main():
source = source_audio_fichier("audio.pcm")
texte = await transcrire_realtime(source)
# Salvesta tulemus
with open("transcription_realtime.txt", "w", encoding="utf-8") as f:
f.write(texte)
print(f"\nTekst salvestatud ({len(texte)} tähemärki)")
asyncio.run(main())
Otsekuvamine põhineb käsul print(event.text, end="", flush=True). Ilma flush=True-ta puhverdab Python väljundi ja tekst ilmub pakettidena: su transkriptsioon oleks tehniliselt reaalajas, kuid visuaalselt hakatav.
Töötlemise struktureerimine tootmiseks
Kui su rakendus kasvab üle demo, muutub if/elif tsükkel kohmakaks: soovid lugeda fragmente, mõõta kestust, ühendada kuva või toita andmebaasi. Loogika kapseldamine klassi lahendab probleemi lõplikult. Iga sündmuse tüüp saab oma meetodi ja saad lisada käitumist – näiteks saata iga delta veebiliidesesse – ilma vastuvõtutsüklit puutumata.
class GestionnaireTranscription:
"""Haldab reaalajas transkriptsiooni sündmusi."""
def __init__(self):
self.texte_complet = []
self.nb_deltas = 0
self.debut = None
async def traiter(self, source_audio):
"""Käivitab transkriptsiooni ja töötleb sündmusi."""
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):
"""Kutsutakse iga uue tekstifragmendi korral."""
self.texte_complet.append(event.text)
self.nb_deltas += 1
# Otsekuvamine
print(event.text, end="", flush=True)
def _on_done(self, event):
"""Kutsutakse transkriptsiooni lõpus."""
import time
duree = time.time() - self.debut
print(f"\n\nLõpetatud {duree:.1f}s jooksul")
print(f"Saadud fragmente: {self.nb_deltas}")
def obtenir_resultat(self) -> str:
"""Tagastab kogu transkribeeritud teksti."""
return "".join(self.texte_complet)
async def main():
gestionnaire = GestionnaireTranscription()
source = source_audio_fichier("audio.pcm")
texte = await gestionnaire.traiter(source)
print(f"Tulemus: {len(texte)} tähemärki")
asyncio.run(main())
Loendur nb_deltas ei ole lihtsalt ilunumber: võrrelduna heli kestusega näitab see mudeli edastuskiirust ja hoiatab sind, kui voog halveneb.
Võrgukatkestuste üleelamine
Voogühendus püsib avatud kogu kõne kestuse vältel, muutes selle palju haavatavamaks kui mõne sekundi pikkune võrguühenduseta päring. Vilkuv Wi-Fi, võrgulüliti mobiilseadmes või operaatori tõrge võib voo katkestada. Allpool olev muster taaskäivitab transkriptsiooni kuni kolm korda, viivitusega, mis iga katsega suureneb, et anda võrgule aega taastuda. Seejärel visatakse erand edasi: selge ebaõnnestumine on parem kui rakendus, mis näib mitte midagi kuulavat.
import asyncio
from mistralai.client import Mistral
from mistralai.client.models import (
AudioFormat,
TranscriptionStreamTextDelta,
TranscriptionStreamDone
)
MAX_TENTATIVES = 3
DELAI_RECONNEXION = 2 # sekundit
async def transcrire_avec_retry(source_audio, tentative=1):
"""Transkriptsioon automaatse uuestiühendusega."""
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[Lõpetatud]")
except ConnectionError as e:
if tentative < MAX_TENTATIVES:
print(f"\nVõrguviga (katse {tentative}/{MAX_TENTATIVES})")
await asyncio.sleep(DELAI_RECONNEXION * tentative)
await transcrire_avec_retry(source_audio, tentative + 1)
else:
print(f"\nEbaõnnestus pärast {MAX_TENTATIVES} katset: {e}")
raise
Olemasoleva faili ettevalmistamine
Et testida MP3- või WAV-failiga, mis sul juba käepärast on, saad automatiseerida PCM-iks teisendamise Pythonist, selle asemel et seda käsitsi teha. Allpool olev funktsioon delegeerib töö FFmpegile, tuletab väljundnime sisendnime põhjal ja tagastab saadud tee, mis on valmis edastamiseks funktsioonile source_audio_fichier.
import subprocess
def convertir_en_pcm(chemin_entree: str, chemin_sortie: str = None) -> str:
"""Teisendab helifaili 16-bitiseks 16 kHz monoks PCM-iks FFmegi abil."""
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
# Kasutus
chemin_pcm = convertir_en_pcm("reunion.mp3")
# Seejärel kasuta source_audio_fichier(chemin_pcm)
Selle funktsiooniga on seotud kaks ettevaatusabinõu. check=True viskab erandi, kui FFmpeg ebaõnnestub, mis on parem kui hiljem voos tühja PCM-faili avastamine; ja capture_output=True peidab tööriista väljundi, nii et pikk teisendamine paneb programmi näima külmutatuna. Tunnipikkuste salvestiste puhul planeeri sõnumi trükkimine enne ja pärast väljakutset.
Peamised punktid
- Voogude kasutamine põhineb asünkroonsetel generaatoritel (
async for,yield) - 32 000-baidine lõik = 1 sekund 16-bitist mono PCM-heli sagedusega 16 kHz
- Struktureeri sündmuste töötlemine klassiks tootmiseks
- Rakenda uuestiproovimise mehhanism võrguvigade käsitlemiseks
- Kasuta FFmegit olemasolevate helifailide PCM-iks teisendamiseks
- Otsekuvamine kasutab
print(text, end="", flush=True)