Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

Ievads reāllaika transkripcijā

Nodarbība 9 no 16 Atjaunota 2026. gada 3. novembris Programmētājs
Šajā lapā
  1. Jauna paradigma: audio straumēšana
  2. Ko piedāvā reāllaika modelis
  3. Instalācija
  4. Nepieciešamais audio formāts
  5. Divi straumes notikumi
  6. Pirmais pilnais piemērs
  7. Kad pāriet uz reāllaiku
  8. Galvenās atziņas

Kurss atjaunināts 2026. gada 3. novembrī priekš Voxtral 3, balstoties uz Mistral ceļvedi Migrate from Voxtral 2: Voxtral 2 modeļi (voxtral-mini-2602, voxtral-mini-transcribe-realtime-2602, voxtral-mini-tts-2603), kas tika deprecated 2026. gada 31. oktobrī un izslēgti 2027. gada 30. aprīlī, piemēros ir aizstāti ar voxtral-mini-transcribe-3, voxtral-mini-transcribe-realtime-3 un voxtral-mini-tts-3-0. Galvenās izmaiņas: laika zīmogi ir tikai segmentu līmenī (word atgriež 400 kļūdu), runātāju atdalīšana (diarization) ir pieejama reāllaikā, reāllaika sesijas iestatījumi tiek bloķēti pēc pirmā audio fragmenta, un context_bias ievades ir brīvas formas (frāzes ar atstarpēm). Avoti: Migrate from Voxtral 2 · Speech to Text.

Jauna paradigma: audio straumēšana

Līdz šim tu esi strādājis bezsaistes (offline) režīmā: tu nosūtīji pilnu audio failu, gaidīji, kamēr modelis to apstrādā, un tikai tad izmantoji rezultātu. Šī darbplūsma ir piemērota esošiem ierakstiem, piemēram, arhivētām sapulcēm, apraidēm vai intervijām. Tā neizdodas, kad audio pienāk nepārtraukti: neviens negaidīs divu stundu konferences beigās, lai redzētu pirmos subtitrus, un balss asistents, kas saprot jautājumu tikai pēc ilga klusuma brīža, šķiet bojāts.

Voxtral Realtime risina šo vajadzību ar straumēšanas arhitektūru. Audio tiek transkribēts tiešraidē, vārdu pa vārdam, un aizkave starp skaņu un tekstu kļūst par iestatījumu, ko tu vari kontrolēt, samazinot to līdz pat 200 milisekundēm. Šī pāreja ir tikpat daudz mentāla, cik tehniska: tu vairs nedomā izolētos pieprasījumos, bet gan plūsmās, un tavai programmai ir jābūt gatavai saņemt tekstu jebkurā brīdī.

Ko piedāvā reāllaika modelis

Modelis tiek izsaukts ar identifikatoru voxtral-mini-transcribe-realtime-3 un fundamentāli atšķiras no tā bezsaistes līdzinieka. Tas saņem audio fragmentus un nepārtraukti ģenerē teksta gabalus, nekad negaidot ieraksta beigām. Tā latentumu kontrolē parametrs target_streaming_delay_ms, kuru tu detalizēti izpētīsi vēlāk šajā kursā. Tas aptver 45 valodas un dialektus, un valodu var fiksēt vai noteikt automātiski. Tā 2. paaudzes priekštecis voxtral-mini-transcribe-realtime-2602 (4 miljardi parametru) ir publicēts kā atvērti svari (open weights) ar Apache 2.0 licenci Hugging Face Hub vietnē pilnībā suverēnai instalācijai uz taviem pašu serveriem.

Ar Voxtral 3 reāllaika veiktspēja ir gandrīz panākusi bezsaistes režīma līmeni. Runātāju atdalīšana (diarization) ir pieejama — lai gan ne tajā pašā sesijā ar runas beig noteikšanu (turn-end detection) — tāpat kā konteksta novirzīšana (context biasing) un runas beig noteikšana. Pastāv divas atšķirības: segmenti satur runātāja etiķeti, bet ne sākuma vai beigu laiku, un visi sesijas iestatījumi (valoda, vārdu krājums, runātāju atdalīšana, aizkave) ir jānosūta pirms pirmā audio fragmenta, pēc kura tie tiek bloķēti. Ja tavs lietojuma gadījums prasa precīzus laika zīmogus, tev ir nepieciešams bezsaistes režīms, iespējams, kā papildinājums reāllaikam.

Instalācija

Mistral SDK pēc noklusējuma neielādē straumēšanas atkarības. Tev ir tieši jāpieprasa papildinājums realtime, kas pievieno atbalstu WebSocket savienojumiem un asinhronai audio apstrādei:

pip install "mistralai[realtime]"

Nepieciešamais audio formāts

Atšķirībā no bezsaistes režīma, kas pieņem plašu konteineru klāstu, Voxtral Realtime sagaida neapstrādātu plūsmu vienā, nepārrunājamā formātā:

  • Kodējums: 16 bitu zīmēts mazākais bajts vispirms PCM (pcm_s16le)
  • Diskretizācijas frekvence: 16 000 Hz (16 kHz)
  • Kanāli: Mono (1 kanāls)

Šis ierobežojums nav šķērslis: šis formāts ir visstandartiskākais, un visi uztveršanas rīki to ģenerē dabiski, vai tā būtu PyAudio, FFmpeg vai PulseAudio. Tu to deklarē klientam vienreiz, un tas to izmanto, lai interpretētu baitus, kurus tu pārraidi.

from mistralai.client.models import AudioFormat

# Definē audio formātu
audio_format = AudioFormat(
    encoding="pcm_s16le",
    sample_rate=16000
)

Divi straumes notikumi

Kad tu iterē cauri transkripcijai, SDK atgriež divu veidu objektus. TranscriptionStreamTextDelta tiek ģenerēts katram jaunam transkribētam fragmentam un nes daļēju tekstu, ko vari nekavējoties attēlot; tieši tas darbina lietotāja ekrānu. TranscriptionStreamDone pienāk tieši vienu reizi, kad audio plūsma beidzas, vai nu faila beigās, vai aizverot mikrofonu; tas signalizē, ka nekas vairāk nenāks un ka tu vari konsolidēt rezultātu. Tava visa loģika tādējādi ietilpst asinhronā ciklā, kas atšķir šos divus gadījumus:

from mistralai.client.models import (
    TranscriptionStreamTextDelta,
    TranscriptionStreamDone
)

async for event in flux_transcription:
    if isinstance(event, TranscriptionStreamTextDelta):
        # Pieejams jauns teksts
        print(event.text, end="", flush=True)
    elif isinstance(event, TranscriptionStreamDone):
        # Transkripcija pabeigta
        print("\n[Pabeigts]")

Pirmais pilnais piemērs

Lai iepazītos ar mehānismu, neizmantojot mikrofonu, vienkāršākā pieeja ir simulēt plūsmu no faila, kas jau ir konvertēts uz PCM. Funkcija lire_fichier_pcm ir asinhrons ģenerators: tā nolasa failu blokos un izdala tos pa vienam, tieši tā, kā to darītu skaņas karte. Pārējā programma ir tas, ko tu vēlāk atkārtoti izmantosi bez izmaiņām.

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

client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
audio_format = AudioFormat(encoding="pcm_s16le", sample_rate=16000)

async def lire_fichier_pcm(chemin: str, taille_chunk: int = 32000):
    """Nolasa PCM failu fragmentos, lai simulētu plūsmu."""
    with open(chemin, "rb") as f:
        while True:
            chunk = f.read(taille_chunk)
            if not chunk:
                break
            yield chunk

async def main():
    flux_audio = lire_fichier_pcm("audio.pcm")

    async for event in client.audio.realtime.transcribe_stream(
        audio_stream=flux_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\nTranskripcija pabeigta.")

asyncio.run(main())

Ja tava avota fails ir MP3, to nevar nosūtīt tādu, kāds tas ir: vispirms konvertē to ar FFmpeg, piespiežot trīs modeļa prasītās īpašības.

ffmpeg -i audio.mp3 -f s16le -acodec pcm_s16le -ar 16000 -ac 1 audio.pcm

Kad pāriet uz reāllaiku

Atlases kritērijs ir vienkāršs: reāllaiks ir attaisnojams, kad kāds gaida tekstu, kamēr skaņa tiek ģenerēta. Tas attiecas uz tiešraides subtitriem konferencē, vebinārā vai tiešsaistes kursā, kur auditorija lasa vienlaikus ar klausīšanos; uz balss asistentu, kam ir jāsaprot lietotājs runas laikā, lai atbildētu bez neērtām pauzēm; uz diktēšanu, kur runa pārvēršas tekstā runātāja acu priekšā; un visbeidzot uz konferenču transkripciju, kad tekstam ir jāparādās tikpat ātri, cik tas tiek runāts. Visur citur bezsaistes režīms paliek bagātāks un vienkāršāk ieviešams.

Nākamajās nodarbībās tu redzēsi, kā uztvert mikrofonu, pielāgot latentumu un izveidot šos lietojuma gadījumus no sākuma līdz beigām.

Galvenās atziņas

  • Voxtral Mini Transcribe Realtime 3 transkribē audio straumēšanas režīmā ar regulējamu aizkavi no 80 ms līdz 1,2 s (vai 2,4 s)
  • Nepieciešamais audio formāts: 16 bitu PCM, 16 kHz, mono
  • Divi notikumu veidi: TextDelta (daļējs teksts) un Done (beigas)
  • Instalē ar pip install "mistralai[realtime]"
  • Nepieciešama asinhronā programmēšana (async/await)
  • Runātāju atdalīšana (izņemot runas beig noteikšanu) un konteksta novirzīšana pieejama reāllaikā bez segmentu laika zīmogiem; iestatījumi tiek bloķēti pēc pirmā audio fragmenta
  • Reāllaika modeļa 2. paaudze ir ar atvērtiem svariem (Apache 2.0) suverēnai izvietošanai