Przypadki użycia transkrypcji w czasie rzeczywistym
Na tej stronie
Kurs zaktualizowany 3 listopada 2026 r. dla Voxtral 3, na podstawie przewodnika Mistral Migrate from Voxtral 2: modele Voxtral 2 (
voxtral-mini-2602,voxtral-mini-transcribe-realtime-2602,voxtral-mini-tts-2603), wycofane 31 października 2026 r. i usunięte 30 kwietnia 2027 r., zostały zastąpione w przykładach przezvoxtral-mini-transcribe-3,voxtral-mini-transcribe-realtime-3orazvoxtral-mini-tts-3-0. Kluczowe zmiany: znaczniki czasu dotyczą tylko segmentów (wordzwraca błąd 400), obsługiwana jest diarizacja w czasie rzeczywistym, ustawienia sesji w czasie rzeczywistym są blokowane po pierwszym fragmencie audio, a dane wejściowecontext_biasmają dowolny format (frazy ze spacjami). Źródła: Migrate from Voxtral 2 · Speech to Text.
Cztery konkretne aplikacje strumieniowe
Masz już wszystkie niezbędne elementy: strumień, mikrofon i strojenie opóźnienia. W tej lekcji złożymy je w cztery kompletne aplikacje – napisy na żywo, asystent głosowy, dyktowanie i transkrypcja konferencji – które możesz wykorzystać jako gotowy punkt wyjścia. Każda z nich ilustruje problem, którego nie da się rozwiązać w trybie offline, i każda używa innego ustawienia opóźnienia, dając Ci konkretne odczucie dotyczące omawianego wcześniej strojenia.
Napisy na żywo
Napisy to najbardziej widoczny przypadek użycia w czasie rzeczywistym, a także najbardziej wymagający pod względem prezentacji. Sama transkrypcja nie wystarczy: musisz podzielić tekst na krótkie linie, wyświetlać tylko dwie naraz i przewijać całość, nigdy nie dzieląc słowa w połowie. Dokładnie to robi poniższa klasa. Gdy bieżąca linia osiągnie maksymalną długość, klasa znajduje ostatnią spację przed tym limitem i dzieli w tym miejscu; jeśli nie znaleziono spacji – bardzo długie słowo, dyktowany adres URL – następuje cięcie przy maksymalnej długości, zamiast pozwalać na przepełnienie linii. Ustawienie 800 milisekund odzwierciedla priorytet tego przypadku użycia: czytelny tekst jest lepszy niż natychmiastowy, ale popsuty, a odbiorcy nie zauważą tego niewielkiego opóźnienia.
import asyncio
import os
from mistralai.client import Mistral
from mistralai.client.models import (
AudioFormat,
TranscriptionStreamTextDelta,
TranscriptionStreamDone
)
class LiveCaptioning:
"""System napisów na żywo z zarządzaniem liniami."""
def __init__(self, max_chars_per_line=50, max_lines=2):
self.max_chars = max_chars_per_line
self.max_lines = max_lines
self.current_line = ""
self.lines = []
async def run(self, audio_source):
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=audio_source,
model="voxtral-mini-transcribe-realtime-3",
audio_format=audio_format,
target_streaming_delay_ms=800,
):
if isinstance(event, TranscriptionStreamTextDelta):
self._add_text(event.text)
elif isinstance(event, TranscriptionStreamDone):
self._afficher_final()
def _add_text(self, texte):
self.current_line += texte
if len(self.current_line) >= self.max_chars:
pos = self.current_line.rfind(" ", 0, self.max_chars)
if pos > 0:
self.lines.append(self.current_line[:pos])
self.current_line = self.current_line[pos + 1:]
else:
self.lines.append(self.current_line[:self.max_chars])
self.current_line = self.current_line[self.max_chars:]
if len(self.lines) > self.max_lines:
self.lines = self.lines[-self.max_lines:]
self._afficher()
def _afficher(self):
for ligne in self.lines:
print(f" {ligne}")
print(f" {self.current_line}", end="", flush=True)
def _afficher_final(self):
print("\n\n[Captioning finished]")
Interaktywny asystent głosowy
Asystent głosowy nie może sobie pozwolić na ciszę. Musi rozumieć użytkownika w trakcie mówienia, w przeciwnym razie po każdym pytaniu powstanie przerwa, która natychmiast zdradzi maszynę. Transkrypcja w czasie rzeczywistym jest pierwszym ogniwem trzyetapowego łańcucha: mowa na tekst, następnie LLM, a potem tekst na mowę. Tutaj opóźnienie spada do 300 milisekund, co jest najbardziej agresywną wartością w całej lekcji, a tekst wyświetla się poprzez nadpisywanie bieżącej linii za pomocą znaku powrotu karetki, tworząc wrażenie zdania kończącego się na Twoich oczach.
Druga połowa funkcji przełącza się na LLM. Odpowiedź jest również żądana jako strumień, więc pierwsze słowa docierają, zanim model zakończy swoje zdanie: responsywność uzyskana na etapie transkrypcji nie jest marnowana w kolejnym kroku. Monit systemowy wymusza zwięzłość, co jest decydującym szczegółem w interakcji głosowej, gdzie dziesięcioliniowa odpowiedź staje się niesłyszalna.
async def assistant_vocal(audio_source):
"""Transkrybuje, a następnie odpowiada za pomocą LLM."""
client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
audio_format = AudioFormat(encoding="pcm_s16le", sample_rate=16000)
# Krok 1: Transkrypcja pytania
question_parts = []
async for event in client.audio.realtime.transcribe_stream(
audio_stream=audio_source,
model="voxtral-mini-transcribe-realtime-3",
audio_format=audio_format,
target_streaming_delay_ms=300,
):
if isinstance(event, TranscriptionStreamTextDelta):
question_parts.append(event.text)
texte_en_cours = "".join(question_parts)
print(f"\rTy: {texte_en_cours}", end="", flush=True)
elif isinstance(event, TranscriptionStreamDone):
break
question = "".join(question_parts).strip()
print()
if not question:
print("Nie wykryto pytania.")
return
# Krok 2: Wysyłka do LLM w celu uzyskania odpowiedzi
print("Asystent: ", end="", flush=True)
reponse_stream = client.chat.stream(
model="mistral-large-latest",
messages=[
{
"role": "system",
"content": "Jesteś zwięzłym asystentem głosowym. "
"Odpowiadaj maksymalnie w 2-3 zdaniach."
},
{"role": "user", "content": question}
]
)
for chunk in reponse_stream:
texte = chunk.data.choices[0].delta.content
if texte:
print(texte, end="", flush=True)
print("\n")
Dyktowanie głosowe z automatycznym zapisem
Dyktowanie stwarza problem, którego dwa poprzednie przypadki ignorują: czas trwania. Sesja może przeciągnąć się ponad godzinę, a utrata tekstu z powodu awarii lub przerwania połączenia byłaby nie do przyjęcia. Stąd automatyczny zapis, wyzwalany mniej więcej co sto słów, który na bieżąco nadpisuje plik wyjściowy. Licznik nb_mots służy również jako informacja zwrotna dla użytkownika: mówi Ci, ile już wyprodukowałeś, czego oczekuje każdy dyktujący raport. Opóźnienie 600 milisekund stawia kursor po stronie precyzji, ponieważ ktoś dyktujący odczytuje swój tekst i woli dokładne słowo niż natychmiastowe.
class DicteeVocale:
"""Dyktowanie głosowe z automatycznym zapisem."""
def __init__(self, fichier_sortie="dictee.txt"):
self.fichier_sortie = fichier_sortie
self.texte = []
self.nb_mots = 0
async def run(self, audio_source):
client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
audio_format = AudioFormat(encoding="pcm_s16le", sample_rate=16000)
print("Dyktowanie... (Ctrl+C, aby zatrzymać)\n")
async for event in client.audio.realtime.transcribe_stream(
audio_stream=audio_source,
model="voxtral-mini-transcribe-realtime-3",
audio_format=audio_format,
target_streaming_delay_ms=600,
):
if isinstance(event, TranscriptionStreamTextDelta):
self.texte.append(event.text)
self.nb_mots += len(event.text.split())
print(event.text, end="", flush=True)
# Autosave co 100 słów
if self.nb_mots % 100 < 5:
self._sauvegarder()
elif isinstance(event, TranscriptionStreamDone):
break
self._sauvegarder()
print(f"\n\nDyktowanie zakończone: {self.nb_mots} słów")
print(f"Plik: {self.fichier_sortie}")
def _sauvegarder(self):
contenu = "".join(self.texte)
with open(self.fichier_sortie, "w", encoding="utf-8") as f:
f.write(contenu)
Transkrypcja konferencji z metadanymi
W przypadku długiej konferencji surowy tekst niewiele znaczy, jeśli nie można go zidentyfikować. Po sześciu miesiącach nikt nie będzie wiedział, z której sesji lub od którego mówcy pochodzi plik o nazwie transcription.txt. Poniższa funkcja opakowuje więc transkrypcję w udokumentowaną strukturę – nazwa konferencji, mówca, znaczniki czasu rozpoczęcia i zakończenia, liczba słów – i eksportuje ją jako JSON pod nazwą ze znacznikiem czasu, gotową do natychmiastowego użycia przez wewnętrzny silnik wyszukiwania lub potok archiwizacji. Opóźnienie 1200 milisekund jest tutaj całkowicie komfortowe: publiczność słucha mówcy, wyświetlacz jest tylko dodatkiem, a precyzja ma pierwszeństwo.
import json
from datetime import datetime
async def transcribe_conference(
audio_source,
conference_name: str,
speaker: str = "Inconnu"
):
"""Transkrybuje sesję konferencyjną z metadanymi."""
client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
audio_format = AudioFormat(encoding="pcm_s16le", sample_rate=16000)
session = {
"conference": conference_name,
"speaker": speaker,
"debut": datetime.now().isoformat(),
"texte": [],
}
print(f"Transkrypcja: {conference_name}")
print(f"Mówca: {speaker}")
print("-" * 50)
async for event in client.audio.realtime.transcribe_stream(
audio_stream=audio_source,
model="voxtral-mini-transcribe-realtime-3",
audio_format=audio_format,
target_streaming_delay_ms=1200,
):
if isinstance(event, TranscriptionStreamTextDelta):
session["texte"].append(event.text)
print(event.text, end="", flush=True)
elif isinstance(event, TranscriptionStreamDone):
break
session["fin"] = datetime.now().isoformat()
session["texte"] = "".join(session["texte"])
session["nb_mots"] = len(session["texte"].split())
filename = f"session_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
with open(filename, "w", encoding="utf-8") as f:
json.dump(session, f, ensure_ascii=False, indent=2)
print(f"\n\nSesja zapisana: {filename}")
return session
Przejrzyj cztery opóźnienia po kolei – 300, 600, 800, a następnie 1200 milisekund – i zauważ, że podążają one za jedną logiką: im bardziej użytkownik oczekuje reakcji od maszyny, tym krótsze musi być opóźnienie; im bardziej oczekuje użytecznego dokumentu, tym może być ono dłuższe. Weź jedną z tych aplikacji i podłącz ją do generatora mikrofonu z poprzedniej lekcji: w kilka minut otrzymasz naprawdę użyteczne narzędzie.
Kluczowe wnioski
- Napisy na żywo wykorzystują opóźnienie 800 ms i zarządzają wyświetlaniem linia po linii
- Asystent głosowy łączy transkrypcję w czasie rzeczywistym z LLM, aby odpowiadać na pytania
- Dyktowanie głosowe automatycznie zapisuje tekst na bieżąco
- Transkrypcja konferencji dodaje metadane i eksportuje do JSON
- Każdy przypadek użycia ma swoje optymalne opóźnienie: od 300 ms (asystent) do 1200 ms (konferencja), w akceptowalnym zakresie od 80 do 1200 ms lub 2400 ms