Реализация на транскрипция в реално време с Python
На тази страница
Курсът е актуализиран на 3 ноември 2026 г. за Voxtral 3, въз основа на ръководството на Mistral Migrate from Voxtral 2: Моделите Voxtral 2 (
voxtral-mini-2602,voxtral-mini-transcribe-realtime-2602,voxtral-mini-tts-2603'), обявени за остарели на 31 октомври 2026 г. и изтеглени от употреба на 30 април 2027 г., са заменени в примерите сvoxtral-mini-transcribe-3,voxtral-mini-transcribe-realtime-3иvoxtral-mini-tts-3-0. Основни промени: временните марки са само за сегменти (wordвръща грешка 400), диаризацията е възможна в реално време, настройките на сесията в реално време се заключват след първия аудио чънк, а входовете заcontext_bias` са в свободен формат (фрази с интервали). Източници: Migrate from Voxtral 2 · Speech to Text.
Пълният асинхронен поток в Python
Сега ще напишете цялостен конвейер за транскрипция в реално време, от първия аудио байт до крайния текстов файл. Всичко разчита на asyncio: програмата трябва да чете аудио и да получава събития от модела едновременно, без нито една от операциите да блокира другата. Стандартният синхронен код просто би изчакал тук и латентността, която внимателно сте конфигурирали, би изчезнала в мъртвото време на собствената ви програма.
Архитектура на стрийминг програмата
Независимо от приложението, структурата остава същата и се чете от ляво надясно. В началото има аудио източник: асинхронен генератор, който произвежда чънкове с PCM аудио. Днес това може да е файл, утре – микрофон или мрежов поток. В центъра е клиентът на Voxtral, тоест SDK, който изпраща тези чънкове към модела и връща събития към вас. В края е обработката на събитията: вашата бизнес логика, която показва текста, го натрупва, запазва го или го препраща към друга услуга.
Audio Source → [PCM chunks] → Mistral SDK → [events] → Your Code
Това разделение има практическа полза: аудио източникът е взаимозаменяем. Кодът за транскрипция, който ще напишете по-долу, ще работи идентично с генератора за микрофон от следващия урок, без да променяте нито един ред.
Основна реализация
Два детайла в тази първа програма заслужават вниманието Ви. Генераторът source_audio_fichier разделя файла на блокове от 32 000 байта, което съответства точно на една секунда 16-битово моно PCM аудио при 16 kHz: 16 000 проби, умножени по 2 байта. Следващият await asyncio.sleep след всяко yield симулира реално време; ако коментирате този ред и стартирате програмата с откъс от няколко минути, ще видите как файлът се консумира за част от секундата, което не Ви учи на нищо относно поведението при стрийминг. От страната на получаването, texte_complet натрупва фрагменти, така че да разполагате с пълния текст в края, в допълнение към дисплея на живо.
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):
"""Асинхронен генератор, който чете PCM файл на чънкове.
taille_chunk = 32000 байта = 1 секунда 16-битово моно PCM аудио при 16kHz
(16000 проби × 2 байта = 32000 байта)
"""
with open(chemin, "rb") as f:
while True:
chunk = f.read(taille_chunk)
if not chunk:
break
yield chunk
# Симулиране на реално време (1 чънк = 1 секунда)
await asyncio.sleep(len(chunk) / 32000)
async def transcrire_realtime(source_audio):
"""Транскрибира аудио поток в реално време с 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--- Транскрипцията приключи ---")
return "".join(texte_complet)
async def main():
source = source_audio_fichier("audio.pcm")
texte = await transcrire_realtime(source)
# Запазване на резултата
with open("transcription_realtime.txt", "w", encoding="utf-8") as f:
f.write(texte)
print(f"\nТекстът е запазен ({len(texte)} знака)")
asyncio.run(main())
Дисплеят на живо разчита на print(event.text, end="", flush=True). Без flush=True, Python буферира изхода и текстът би се появявал на пакети: транскрипцията Ви би била технически в реално време, но визуално накъсана.
Структуриране на обработката за продукция
След като приложението Ви излезе извън рамките на демо версия, цикълът if/elif става тромав: искате да броите фрагменти, да измервате продължителността, да свържете дисплей или да захранвате база данни. Обгръщането на логиката в клас решава проблема веднъж завинаги. Всеки тип събитие получава свой собствен метод, а Вие можете да добавяте поведение – например изпращане на всяка делта към уеб интерфейс – без да докосвате цикъла за получаване.
class GestionnaireTranscription:
"""Управлява събитията за транскрипция в реално време."""
def __init__(self):
self.texte_complet = []
self.nb_deltas = 0
self.debut = None
async def traiter(self, source_audio):
"""Стартира транскрипцията и обработва събитията."""
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):
"""Извиква се за всеки нов текстов фрагмент."""
self.texte_complet.append(event.text)
self.nb_deltas += 1
# Дисплей на живо
print(event.text, end="", flush=True)
def _on_done(self, event):
"""Извиква се в края на транскрипцията."""
import time
duree = time.time() - self.debut
print(f"\n\nПриключи за {duree:.1f}s")
print(f"Получени фрагменти: {self.nb_deltas}")
def obtenir_resultat(self) -> str:
"""Връща пълния транскрибиран текст."""
return "".join(self.texte_complet)
async def main():
gestionnaire = GestionnaireTranscription()
source = source_audio_fichier("audio.pcm")
texte = await gestionnaire.traiter(source)
print(f"Резултат: {len(texte)} знака")
asyncio.run(main())
Броячът nb_deltas не е просто украса: спрямо продължителността на аудиото, той показва скоростта на емисия на модела и Ви предупреждава, ако потокът се влоши.
Оцеляване при прекъсвания на мрежата
Стрийминг връзката остава отворена през цялата продължителност на речта, което я излага на риск много повече от няколко секундна офлайн заявка. Прекъсващ Wi-Fi, превключване на мрежата на мобилно устройство или прекъсване на оператора могат да прекъснат потока. Долният шаблон рестартира транскрипцията до три пъти, със закъснение, което се увеличава с всяка попытка, за да се даде време на мрежата да се възстанови. Оттам нататък изключението се предава нататък: една явна грешка е по-добра от приложение, което изглежда, че не слуша нищо.
import asyncio
from mistralai.client import Mistral
from mistralai.client.models import (
AudioFormat,
TranscriptionStreamTextDelta,
TranscriptionStreamDone
)
MAX_TENTATIVES = 3
DELAI_RECONNEXION = 2 # секунди
async def transcrire_avec_retry(source_audio, tentative=1):
"""Транскрипция с автоматично повторно свързване."""
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[Приключи]")
except ConnectionError as e:
if tentative < MAX_TENTATIVES:
print(f"\nМрежова грешка (опит {tentative}/{MAX_TENTATIVES})")
await asyncio.sleep(DELAI_RECONNEXION * tentative)
await transcrire_avec_retry(source_audio, tentative + 1)
else:
print(f"\nНеуспех след {MAX_TENTATIVES} опита: {e}")
raise
Подготовка на съществуващ файл
За да тествате с MP3 или WAV файл, който вече имате под ръка, можете да автоматизирате конвертирането в PCM от Python, вместо да го изпълнявате ръчно. Функцията по-долу възлага работата на FFmpeg, извежда изходното име от входното име и връща получения път, готов за предаване на source_audio_fichier.
import subprocess
def convertir_en_pcm(chemin_entree: str, chemin_sortie: str = None) -> str:
"""Конвертира аудио файл в 16-битов 16kHz моно PCM чрез 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
# Употреба
chemin_pcm = convertir_en_pcm("reunion.mp3")
# След това използвайте source_audio_fichier(chemin_pcm)
Две предпазни мерки с тази функция. check=True поражда изключение, ако FFmpeg се провали, което е по-добре от откриването на празен PCM файл по-късно в потока; а capture_output=True скрива изхода на инструмента, така че дългото конвертиране няма да накара програмата да изглежда замръзнала. За записи с продължителност един час, планирайте да отпечатате съобщение преди и след извикването.
Ключови изводи
- Стриймингът използва асинхронни генератори (
async for,yield) - Чънк от 32 000 байта = 1 секунда 16-битово моно PCM аудио при 16 kHz
- Структурирайте обработката на събитията в клас за продукция
- Внедрете механизъм за повторни опити за справяне с мрежови грешки
- Използвайте FFmpeg за конвертиране на съществуващи аудио файлове в PCM
- Дисплеят на живо използва
print(text, end="", flush=True)