Salt la conținutul principal
Română— Alege o limbă
Meniu

Cazuri de utilizare a transcrierii în timp real

Lecția 13 din 16 Actualizată 3 noiembrie 2026 Dezvoltator
Pe această pagină
  1. Patru aplicații concrete de streaming
  2. Subtitrare live
  3. Asistent vocal interactiv
  4. Dictare vocală cu salvarea automată
  5. Transcriere de conferință cu metadate
  6. Puncte cheie

Curs actualizat la 3 noiembrie 2026 pentru Voxtral 3, pe baza ghidului Migrate from Voxtral 2 de la Mistral: modelele Voxtral 2 (voxtral-mini-2602, voxtral-mini-transcribe-realtime-2602, voxtral-mini-tts-2603), depreciate la 31 octombrie 2026 și retrase la 30 aprilie 2027, sunt înlocuite în exemple prin voxtral-mini-transcribe-3, voxtral-mini-transcribe-realtime-3 și voxtral-mini-tts-3-0. Modificări cheie: marcajele temporale sunt doar pe segmente (word returnează o eroare 400), diarizarea în timp real este suportată, setările sesiunii în timp real sunt blocate după primul fragment audio, iar intrările context_bias sunt în format liber (fraze cu spații). Surse: Migrate from Voxtral 2 · Speech to Text.

Patru aplicații concrete de streaming

Dețineți acum toate componentele esențiale: fluxul, microfonul și reglarea latenței. Această lecție le asamblează în patru aplicații complete—subtitrare live, asistent vocal, dictare și transcriere de conferință—pe care le puteți utiliza ca atare drept punct de plecare. Fiecare ilustrează o problemă pe care modul offline nu o poate rezolva și fiecare utilizează o setare diferită de latență, oferindu-vă o înțelegere concretă a ajustărilor discutate anterior.

Subtitrare live

Subtitrarea este cel mai vizibil caz de utilizare în timp real și, totodată, cel mai exigent din punct de vedere al prezentării. Transcrierea nu este suficientă: trebuie să fragmentați textul în rânduri scurte, să afișați doar două simultan și să derulați întregul conținut fără a despărți vreodată un cuvânt la jumătate. Exact asta face clasa următoare. Când linia curentă atinge lungimea maximă, aceasta găsește ultimul spațiu înainte de acea limită și întrerupe acolo; dacă nu se găsește niciun spațiu—un cuvânt foarte lung, un URL dictat—taie la lungimea maximă în loc să permită depășirea liniei. Setarea de 800 de milisecunde reflectă prioritatea acestui caz de utilizare: un text lizibil este preferabil unui text instantaneu dar fragmentat, iar publicul nu va observa această ușoară întârziere.

import asyncio
import os
from mistralai.client import Mistral
from mistralai.client.models import (
    AudioFormat,
    TranscriptionStreamTextDelta,
    TranscriptionStreamDone
)

class LiveCaptioning:
    """Sistem de subtitrare live cu gestionarea liniilor."""

    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]")

Asistent vocal interactiv

Un asistent vocal nu își poate permite tăcerea. Trebuie să înțeleagă utilizatorul în timp ce acesta vorbește, altfel va lăsa un gol după fiecare întrebare, ceea ce trădează imediat natura automată a răspunsului. Transcrierea în timp real este prima verigă a unui lanț din trei pași: Speech-to-Text, apoi LLM, apoi Text-to-Speech. Aici, latența scade la 300 de milisecunde, cea mai agresivă valoare din întreaga lecție, iar textul se afișează prin suprascrierea liniei curente folosind un caracter de revenire la începutul liniei, creând impresia unei propoziții care se completează sub ochii dumneavoastră.

A doua jumătate a funcției trece la LLM. Răspunsul este solicitat tot sub formă de flux, astfel încât primele cuvinte sosesc înainte ca modelul să își fi terminat propoziția: reactivitatea câștigată în etapa de transcriere nu este irosită în pasul următor. Promptul de sistem impune concizia, un detaliu decisiv în interacțiunea vocală, unde un răspuns de zece rânduri devine inaudibil.

async def assistant_vocal(audio_source):
    """Transcrie apoi răspunde prin intermediul unui LLM."""
    client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
    audio_format = AudioFormat(encoding="pcm_s16le", sample_rate=16000)

    # Pasul 1: Transcrie întrebarea
    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"\rYou: {texte_en_cours}", end="", flush=True)
        elif isinstance(event, TranscriptionStreamDone):
            break

    question = "".join(question_parts).strip()
    print()

    if not question:
        print("No question detected.")
        return

    # Pasul 2: Trimite către LLM pentru a obține un răspuns
    print("Assistant: ", end="", flush=True)

    reponse_stream = client.chat.stream(
        model="mistral-large-latest",
        messages=[
            {
                "role": "system",
                "content": "You are a concise voice assistant. "
                           "Respond in 2-3 sentences maximum."
            },
            {"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")

Dictare vocală cu salvarea automată

Dictarea pune o problemă pe care cele două cazuri anterioare o ignoră: durata. O sesiune se poate întinde pe parcursul unei ore, iar pierderea textului din cauza unei erori sau a unei întreruperi ar fi inacceptabilă. De aici necesitatea salvării automate, declanșată aproximativ la fiecare o sută de cuvinte, care rescrie fișierul de ieșire din mers. Contorul nb_mots servește, de asemenea, ca feedback pentru utilizator: vă indică cât ați produs, o informație pe care oricine dictează un raport se așteaptă să o primească. Latența de 600 de milisecunde plasează cursorul de partea preciziei, deoarece cineva care dictează își recitește textul și preferă un cuvânt exact unuia instantaneu.

class DicteeVocale:
    """Dictare vocală cu salvare automată."""

    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("Dictating... (Ctrl+C to stop)\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 every 100 words
                if self.nb_mots % 100 < 5:
                    self._sauvegarder()

            elif isinstance(event, TranscriptionStreamDone):
                break

        self._sauvegarder()
        print(f"\n\nDictation finished: {self.nb_mots} words")
        print(f"File: {self.fichier_sortie}")

    def _sauvegarder(self):
        contenu = "".join(self.texte)
        with open(self.fichier_sortie, "w", encoding="utf-8") as f:
            f.write(contenu)

Transcriere de conferință cu metadate

Pentru o conferință lungă, textul brut nu are mare valoare dacă nu este identificabil. Peste șase luni, nimeni nu va ști din ce sesiune sau de la ce vorbitor provine un fișier numit transcription.txt. Funcția următoare încadrează, așadar, transcrierea într-o structură documentată—numele conferinței, vorbitorul, marcajele temporale de start și sfârșit, numărul de cuvinte—și o exportă sub formă de JSON cu un nume marcat temporal, imediat utilizabil de un motor de căutare intern sau de un pipeline de arhivare. Latența de 1.200 de milisecunde este perfect confortabilă aici: publicul ascultă vorbitorul, afișajul fiind doar un supliment, iar precizia are prioritate.

import json
from datetime import datetime

async def transcribe_conference(
    audio_source,
    conference_name: str,
    speaker: str = "Inconnu"
):
    """Transcrie o sesiune de conferință cu metadate."""
    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"Transcription: {conference_name}")
    print(f"Speaker: {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\nSession saved: {filename}")
    return session

Revizuiți cele patru latențe în ordine—300, 600, 800, apoi 1.200 de milisecunde—și observați că ele urmează o singură logică: cu cât utilizatorul se așteaptă la o reacție din partea mașinii, cu atât întârzierea trebuie să fie mai scurtă; cu cât se așteaptă la un document utilizabil, cu atât aceasta poate fi mai lungă. Luați una dintre aceste aplicații și conectați-o la generatorul de microfon din lecția anterioară: veți avea un instrument cu adevărat utilizabil în doar câteva minute.

Puncte cheie

  • Subtitrarea live utilizează o latență de 800 ms și gestionează afișajul linie cu linie
  • Asistentul vocal înlănțuie transcrierea în timp real și un LLM pentru a răspunde la întrebări
  • Dictarea vocală salvează automat textul din mers
  • Transcrierea de conferință adaugă metadate și exportă în JSON
  • Fiecare caz de utilizare are latența sa optimă: de la 300 ms (asistent) la 1.200 ms (conferință), în intervalul acceptat de 80 până la 1.200 ms sau 2.400 ms