Preskok na glavno vsebino
Slovenščina— Izberite jezik
Meni

Primeri uporabe prepisa v realnem času

Lekcija 13 od 16 Posodobljeno 3. november 2026 Razvijalec
Na tej strani
  1. Štirje konkretni aplikaciji za pretakanje
  2. Podnaslavljenje v živo
  3. Interaktivni glasovni pomočnik
  4. Glasovno narekovanje z samodejnim shranjevanjem
  5. Prepis konference z metapodatki
  6. Ključne ugotovitve

Posodobitev tečaja z dne 3. novembra 2026 za Voxtral 3, na podlagi vodnika Mistral Migrate from Voxtral 2: modeli Voxtral 2 (voxtral-mini-2602, voxtral-mini-transcribe-realtime-2602, voxtral-mini-tts-2603), ki so bili umaknjeni 31. oktobra 2026 in dokončno ukinjeni 30. aprila 2027, so v primerih nadomeščeni z modeli voxtral-mini-transcribe-3, voxtral-mini-transcribe-realtime-3 in voxtral-mini-tts-3-0. Ključne spremembe: časovni žigi so na voljo le za segmente (word vrne napako 400), podprta je diarizacija v realnem času, nastavitve seje v realnem času so zaklenjene po prvem zvočnem delčku, vnosi context_bias pa so v prostem formatu (besedne zveze s presledki). Viri: Migrate from Voxtral 2 · Speech to Text.

Štirje konkretni aplikaciji za pretakanje

Zdaj imaš vse gradnike: pretok, mikrofon in prilagajanje zakasnitve. Ta lekcija jih združuje v štiri celovite aplikacije – podnaslavljenje v živo, glasovni pomočnik, narekovanje in prepis konferenc –, ki jih lahko uporabiš kot izhodišče. Vsaka ponazarja težavo, ki je v načinu brez povezave ni mogoče rešiti, in vsaka uporablja drugačno nastavitev zakasnitve, kar ti daje konkreten občutek za uglaševanje, o katerem smo razpravljali prej.

Podnaslavljenje v živo

Podnaslavljenje je najbolj vidna uporaba v realnem času in hkrati najbolj zahtevna glede predstavitve. Samo prepisovanje ni dovolj: besedilo moraš razbiti na kratke vrstice, prikazati le dve hkrati in celotno vsebino pomikati navzgor, ne da bi kdaj razpolovil besedo. Točno to počne spodnji razred. Ko trenutna vrstica doseže največjo dolžino, poišče zadnji presledek pred to mejo in tam naredi prelom; če presledka ni – gre za zelo dolgo besedo ali narekovan URL – prereže pri največji dolžini, namesto da bi dovolil prelivanje vrstice. Nastavitev 800 milisekund odraža prioriteto tega primera uporabe: berljivo besedilo je boljše od trenutnega, a prekinjenega besedila, občinstvo pa te majhne zamude ne bo opazilo.

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

class LiveCaptioning:
    """Sistem za podnaslavljenje v živo z upravljanjem vrstic."""

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

Interaktivni glasovni pomočnik

Glasovni pomočnik si ne more privoščiti tišine. Uporabnika mora razumeti medtem, ko govori, sicer za vsakim vprašanjem nastane vrzel, ki takoj razkrije, da gre za stroj. Prepis v realnem času je prva povezava v tridelni verigi: govor-v-besedilo, nato LLM in nato besedilo-v-govor. Tu zakasnitev pade na 300 milisekund, kar je najbolj agresivna vrednost v celotni lekciji, besedilo pa se prikazuje s prepisovanjem trenutne vrstice z uporabo povratka vozička, kar ustvarja vtis, da se stavek dopolnjuje pred tvojimi očmi.

Drugi polovici funkcije preklopi na LLM. Odziv je prav tako zahtevan kot pretok, tako da prve besede prispejo, preden model konča svoj stavek: odzivnost, pridobljena v fazi prepisa, se ne zapravi v naslednjem koraku. Sistemski poziv uveljavlja jedrnatost, kar je odločilna podrobnost v govorni interakciji, kjer desetvrstični odgovor postane neslušen.

async def assistant_vocal(audio_source):
    """Prepiše in nato odgovori prek LLM."""
    client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
    audio_format = AudioFormat(encoding="pcm_s16le", sample_rate=16000)

    # 1. korak: Prepis vprašanja
    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

    # 2. korak: Pošlji LLM za pridobitev odgovora
    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")

Glasovno narekovanje z samodejnim shranjevanjem

Narekovanje predstavlja težavo, ki jo prejšnja dva primera ignorirata: trajanje. Seja se lahko raztegne čez uro, izguba besedila zaradi zrušitve ali izpada pa bi bila nesprejemljiva. Zato samodejno shranjevanje, ki se sproži približno vsakih sto besed in sproti prepisuje izhodno datoteko. Števec nb_mots služi tudi kot povratna informacija uporabniku: pove ti, koliko si proizvedel, kar vsakdo, ki narekuje poročilo, pričakuje. Zakasnitev 600 milisekund postavlja kazalec na stran natančnosti, saj nekdo, ki narekuje, svoje besedilo prebere in raje ima točno besedo kot trenutno.

class DicteeVocale:
    """Glasovno narekovanje z samodejnim shranjevanjem."""

    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)

                # Samodejno shranjevanje vsakih 100 besed
                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)

Prepis konference z metapodatki

Za dolgo konferenco surovo besedilo ni vredno veliko, če ni prepoznavno. Čez šest mesecev nihče ne bo vedel, iz katere seje ali od katerega govorca izvira datoteka z imenom transcription.txt. Spodnja funkcija zato ovije prepis v dokumentirano strukturo – ime konference, govorec, časovni žigi začetka in konca, število besed – in ga izvozi kot JSON pod imenom s časovnim žigom, ki je takoj uporaben za interni iskalnik ali arhivski pipeline. Zakasnitev 1.200 milisekund je tu povsem sprejemljiva: občinstvo posluša govorca, prikaz je le dodatek in natančnost ima prednost.

import json
from datetime import datetime

async def transcribe_conference(
    audio_source,
    conference_name: str,
    speaker: str = "Inconnu"
):
    """Prepiše sejo konference z metapodatki."""
    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

Preglej štiri zakasnitve po vrsti – 300, 600, 800 in nato 1.200 milisekund – in opazi, da sledijo eni sami logiki: bolj ko uporabnik pričakuje reakcijo stroja, krajša mora biti zamuda; bolj ko pričakuje uporaben dokument, daljša je lahko. Vzemi eno od teh aplikacij in jo priklopi na generator mikrofona iz prejšnje lekcije: v nekaj minutah boš imel resnično uporaben alat.

Ključne ugotovitve

  • Podnaslavljenje v živo uporablja zakasnitev 800 ms in upravlja prikaz vrstico za vrstico
  • Glasovni pomočnik povezuje prepis v realnem času in LLM za odgovarjanje na vprašanja
  • Glasovno narekovanje samodejno sproti shranjuje besedilo
  • Prepis konferenc dodaja metapodatke in izvaža v JSON
  • Vsak primer uporabe ima svojo optimalno zakasnitev: od 300 ms (pomočnik) do 1.200 ms (konferenca), znotraj sprejetega območja od 80 do 1.200 ms ali 2.400 ms