Implementuoti transkripciją realiuoju laiku naudojant Python
Šiame puslapyje
Kursas atnaujintas 2026 m. lapkričio 3 d. Voxtral 3 versijai, remiantis „Mistral“ vadovu Migrate from Voxtral 2: Voxtral 2 modeliai (
voxtral-mini-2602,voxtral-mini-transcribe-realtime-2602,voxtral-mini-tts-2603), pasenę 2026 m. spalio 31 d. ir pašalinti 2027 m. balandžio 30 d., pavyzdžiuose pakeisti įvoxtral-mini-transcribe-3,voxtral-mini-transcribe-realtime-3irvoxtral-mini-tts-3-0. Pagrindiniai pokyčiai: laiko žymos tik segmentų lygmenyje (wordgrąžina 400 klaidą), diarizacija galima realiuoju laiku, realiuoju laiku vykdomos sesijos nustatymai užrakomi po pirmojo garso fragmento, ocontext_biasįvestys yra laisvos formos (frazės su tarpais). Šaltiniai: Migrate from Voxtral 2 · Speech to Text.
Pilna asinchroninė srautinė programa Python kalba
Dabar sukursi visą transkripcijos realiuoju laiku konvejerį – nuo pirmojo garso baito iki galutinio teksto failo. Viskas remiasi asyncio: programa turi vienu metu skaityti garso duomenis ir gauti modelio įvykius, neblokuojant nei vienos operacijos. Įprastas sinchroninis kodas tiesiog lauktų, o tavo kruopščiai sukonfigūruota delsą išgaruotų dėl pačios programos neveiklumo laikotarpių.
Srautinės programos architektūra
Nepriklausomai nuo taikomosios programos, struktūra lieka ta pati ir skaitoma iš kairės į dešinę. Viršutinėje grandyje – garso šaltinis: asinchroninis generatorius, kuriantis PCM garso fragmentus. Šiandien tai gali būti failas, rytoj – mikrofonas arba tinklo srautas. Centre – Voxtral klientas, t. y. SDK, kuris siunčia šiuos fragmentus modeliui ir grąžina tau įvykius. Apatinėje grandyje – įvykių apdorojimas: tavo verslo logika, kuri rodo tekstą, kaupia jį, išsaugo arba persiunčia kitai tarnybai.
Audio Source → [PCM chunks] → Mistral SDK → [events] → Your Code
Šis atskyrimas turi praktinės naudos: garso šaltinį galima lengvai pakeisti. Toliau parašytas transkripcijos kodas veiks identiškai su kitame pamokoje pateiktu mikrofono generatoriumi, nekeičiant nei vienos eilutės.
Bazinis įgyvendinimas
Šioje pirmojoje programoje du aspektai nusipelno tavo dėmesio. source_audio_fichier generatorius padalija failą į 32 000 baitų blokus, kas tiksliai atitinka vieną sekundę 16 bitų mono PCM garso esant 16 kHz dažniui: 16 000 imtinių, padaugintų iš 2 baitų. Po kiekvieno yield esantis await asyncio.sleep imituoja realų laiką; jei šią eilutę užkomentuosi ir paleisi programą su kelių minučių ištrauka, pamatysi, kad failas suvartojamas per akimirką, ir nieko nesužinosi apie srautinio apdorojimo elgseną. Priėmimo pusėje texte_complet kaupia fragmentus, kad pabaigoje turėtum visą tekstą, be gyvo rodymo ekrane.
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):
"""Asinchroninis generatorius, skaitantis PCM failą fragmentais.
taille_chunk = 32000 baitų = 1 sekundė 16 bitų mono PCM garso esant 16 kHz
(16000 imtinių × 2 baitai = 32000 baitų)
"""
with open(chemin, "rb") as f:
while True:
chunk = f.read(taille_chunk)
if not chunk:
break
yield chunk
# Imituoti realų laiką (1 fragmentas = 1 sekundė)
await asyncio.sleep(len(chunk) / 32000)
async def transcrire_realtime(source_audio):
"""Transkribuoja garso srautą realiuoju laiku naudojant 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--- Transkripcija baigta ---")
return "".join(texte_complet)
async def main():
source = source_audio_fichier("audio.pcm")
texte = await transcrire_realtime(source)
# Išsaugoti rezultatą
with open("transcription_realtime.txt", "w", encoding="utf-8") as f:
f.write(texte)
print(f"\nTekstas išsaugotas ({len(texte)} simbolių)")
asyncio.run(main())
Gyvas rodymas remiasi print(event.text, end="", flush=True). Be flush=True, „Python“ buferizuoja išvestį ir tekstas atsirastų grupėmis: tavo transkripcija techniškai būtų realiuoju laiku, bet vizualiai trūkčiotų.
Apdorojimo struktūravimas gamybai
Kai tavo programa išauga už demonstracinio projekto ribų, if/elif ciklas tampa nepatogus: nori skaičiuoti fragmentus, matuoti trukmę, prijungti rodiklį arba maitinti duomenų bazę. Logikos encapsuliavimas klasėje išsprendžia šią problemą kartą ir visiems laikams. Kiekvienas įvykio tipas gauna savo atskirą metodą, ir gali pridėti naują elgseną – pavyzdžiui, siųsti kiekvieną deltą į žiniatinklio sąsają – neliesdamas priėmimo ciklo.
class GestionnaireTranscription:
"""Tvarko transkripcijos realiuoju laiku įvykius."""
def __init__(self):
self.texte_complet = []
self.nb_deltas = 0
self.debut = None
async def traiter(self, source_audio):
"""Pradeda transkripciją ir apdoroja įvykius."""
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):
"""Kviečiamas kiekvienam naujam teksto fragmentui."""
self.texte_complet.append(event.text)
self.nb_deltas += 1
# Gyvas rodymas
print(event.text, end="", flush=True)
def _on_done(self, event):
"""Kviečiamas transkripcijos pabaigoje."""
import time
duree = time.time() - self.debut
print(f"\n\nBaigta per {duree:.1f}s")
print(f"Gauti fragmentai: {self.nb_deltas}")
def obtenir_resultat(self) -> str:
"""Grąžina visą transkribuotą tekstą."""
return "".join(self.texte_complet)
async def main():
gestionnaire = GestionnaireTranscription()
source = source_audio_fichier("audio.pcm")
texte = await gestionnaire.traiter(source)
print(f"Rezultatas: {len(texte)} simbolių")
asyncio.run(main())
nb_deltas skaitiklis nėra tik dekoracija: lyginant su garso trukme, jis rodo modelio generavimo greitį ir įspėja, jei srautas pradeda blogėti.
Atsparumas tinklo trikdžiams
Srautinio ryšio jungtis išlieka atvira visą kalbos trukmę, todėl ji yra daug labiau pažeidžiama nei kelių sekundžių neprisijungusio režimo užklausa. Silpnas „Wi-Fi“, tinklo perjungimas mobiliuosiuose įrenginiuose arba operatoriaus gedimas gali nutraukti srautą. Toliau pateiktas šablonas paleidžia transkripciją iš naujo iki trijų kartų, didinant delsą po kiekvieno bandymo, kad tinklas spėtų atsistatyti. Viršijus šį limitą, išimtis perduodama toliau: aiškus gedimas yra geriau nei programa, kuri atrodo klausanti tuštumos.
import asyncio
from mistralai.client import Mistral
from mistralai.client.models import (
AudioFormat,
TranscriptionStreamTextDelta,
TranscriptionStreamDone
)
MAX_TENTATIVES = 3
DELAI_RECONNEXION = 2 # sekundės
async def transcrire_avec_retry(source_audio, tentative=1):
"""Transkripcija su automatiniu persijungimu."""
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[Baigta]")
except ConnectionError as e:
if tentative < MAX_TENTATIVES:
print(f"\nTinklo klaida (bandymas {tentative}/{MAX_TENTATIVES})")
await asyncio.sleep(DELAI_RECONNEXION * tentative)
await transcrire_avec_retry(source_audio, tentative + 1)
else:
print(f"\nNepavyko po {MAX_TENTATIVES} bandymų: {e}")
raise
Esamo failo paruošimas
Norėdamas testuoti su turimu MP3 arba WAV failu, gali automatizuoti konvertavimą į PCM tiesiai iš „Python“, užuot tai daręs rankiniu būdu. Toliau pateikta funkcija perduoda darbą „FFmpeg“, iš įvesties failo pavadinimo sugeneruoja išvesties pavadinimą ir grąžina gautą kelią, paruoštą perduoti į source_audio_fichier.
import subprocess
def convertir_en_pcm(chemin_entree: str, chemin_sortie: str = None) -> str:
"""Konvertuoja garso failą į 16 bitų 16 kHz mono PCM naudojant 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
# Naudojimas
chemin_pcm = convertir_en_pcm("reunion.mp3")
# Tada naudoti source_audio_fichier(chemin_pcm)
Su šia funkcija reikia imtis dviejų atsargumo priemonių. check=True išmeta išimtį, jei „FFmpeg“ nepavyksta, o tai yra geriau nei vėliau sraute atrasti tuščią PCM failą; capture_output=True paslepia įrankio išvestį, todėl ilgo konvertavimo metu programa gali atrodyti sustingusi. Valandų trukmės įrašams numatyk pranešimų spausdinimą prieš ir po kvietimo.
Svarbiausi punktai
- Srautinis apdorojimas naudoja asinchroninius generatorius (
async for,yield) - 32 000 baitų fragmentas = 1 sekundė 16 bitų mono PCM garso esant 16 kHz
- Gamyboje įvykių apdorojimą struktūruok klasėje
- Įgyvendink pakartotinio bandymo mechanizmą tinklo klaidoms valdyti
- Naudok „FFmpeg“ esamiems garso failams konvertuoti į PCM
- Gyvam rodymui naudok
print(text, end="", flush=True)