Aqbeż għall-kontenut ewlieni
Malti— Agħżel lingwa
Menu

Każijiet ta' Użu għat-Traskrizzjoni f'Ħin Real

Lezzjoni 13 / 16 Aġġornat 3 ta’ Novembru 2026 Zviluppatur
F'din il-paġna
  1. Erba’ applikazzjonijiet konkreti ta’ streaming
  2. Sottotitli live (Live captioning)
  3. Assistent vokali interattiv
  4. Dettatura vokali b’awtosaving
  5. Traskrizzjoni ta’ konferenza b’metadata
  6. Punti Ewlenin

Il-kors aġġornat fit-3 ta’ Novembru 2026 għal Voxtral 3, ibbażat fuq il-gwida Migrate from Voxtral 2 ta’ Mistral: Il-mudelli Voxtral 2 (voxtral-mini-2602, voxtral-mini-transcribe-realtime-2602, voxtral-mini-tts-2603), iddeprekati fil-31 ta’ Ottubru 2026 u rtirati fit-30 ta’ April 2027, ġew sostitwiti fl-eżempji b’voxtral-mini-transcribe-3, voxtral-mini-transcribe-realtime-3, u voxtral-mini-tts-3-0. Bidliet ewlenin: it-timstamps huma biss għas-segmenti (word jirritorna żball 400), id-djarizzazzjoni f’ħin reali hija appoġġjata, is-settings tas-sessjoni f’ħin reali jissakkaw wara l-ewwel biċċa awdjo, u l-inputs ta’ context_bias huma f’forma libera (frażijiet b’ispazji). Sorsi: Migrate from Voxtral 2 · Speech to Text.

Erba’ applikazzjonijiet konkreti ta’ streaming

Issa għandek il-blokok tal-bini kollha: l-istream, il-mikrofonu, u l-aġġustament tal-latency. Din il-lezzjoni tgħaqqadhom f’erba’ applikazzjonijiet sħaħ—sottotitli live, assistent vokali, dettatura, u traskrizzjoni ta’ konferenzi—li tista’ tuża hekk kif inhuma bħala punt tat-tluq. Kull waħda turi problema li l-modalità offline ma tistax issolvi, u kull waħda tuża setting ta’ latency differenti, u tagħtik sens konkret tal-aġġustament diskuss qabel.

Sottotitli live (Live captioning)

Is-sottotitli huma l-aktar każ ta’ użu f’ħin reali viżibbli, u wkoll l-aktar wieħed li jeħtieġ preżentazzjoni attenta. It-traskrizzjoni mhix biżżejjed: trid taqsam it-test f’linji qosra, turi żewġ linji biss f’daqqa, u tiskrollja kollox mingħajr qatt ma taqsam kelma f’nofsha. Dan huwa eżattament dak li tagħmel il-klassi li ġejja. Meta l-linja attuntali tilħaq it-tul massimu, issib l-aħħar spazju qabel dak il-limitu u taqsam hemm; jekk ma jinstab l-ebda spazju—kelma twila ħafna, URL dettata—taqta’ fit-tul massimu minflok ma tħalli l-linja toħroġ mill-qafas. Is-setting ta’ 800 millisekonda jirrifletti l-prijorità ta’ dan il-każ ta’ użu: test li jinqara huwa aħjar minn test immedjat iżda mkisser, u l-udjenza ma tinnotax dan id-dewmien żgħir.

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

class LiveCaptioning:
    """Sistema ta' sottotitli live b'ġestjoni tal-linji."""

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

Assistent vokali interattiv

Assistent vokali ma jistax jiflaħ is-skiet. Irid jifhem lill-utent waqt li qed jitkellem, inkella jħalli vojt wara kull mistoqsija li minnufih jiżvela li hija magna. It-traskrizzjoni f’ħin reali hija l-ewwel rabta f’katina ta’ tliet passi: Speech-to-Text, imbagħad LLM, imbagħad Text-to-Speech. Hawnhekk, il-latency tinżel għal 300 millisekonda, l-aktar valur aggressiv fil-lezzjoni kollha, u t-test jintwera billi jissostitwixxi l-linja attwali bl-użu ta’ carriage return, u joħloq l-impressjoni ta’ sentenza li qed titlesta quddiem għajnejk.

In-nofs it-tieni tal-funzjoni jgħaddi għall-LLM. Ir-risposta tintalab hi wkoll bħala stream, sabiex l-ewwel kliem jaslu qabel ma l-mudell ikun lesta s-sentenza tiegħu: ir-responsività miksuba fil-fażi tat-traskrizzjoni ma tintilifx fil-pass li jmiss. Is-system prompt jinfurza l-konċiżjoni, dettall deċiżiv fl-interazzjoni mitkellma fejn tweġiba ta’ għaxar linji ssir mhux mistmagħa.

async def assistant_vocal(audio_source):
    """Tittraskrivi u mbagħad twieġeb permezz ta' LLM."""
    client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
    audio_format = AudioFormat(encoding="pcm_s16le", sample_rate=16000)

    # Pass 1: Ittraskrivi l-mistoqsija
    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("L-ebda mistoqsija ma nstabet.")
        return

    # Pass 2: Ibgħat lill-LLM biex tikseb tweġiba
    print("Assistant: ", end="", flush=True)

    reponse_stream = client.chat.stream(
        model="mistral-large-latest",
        messages=[
            {
                "role": "system",
                "content": "Int assistent vokali konċiż. "
                           "Wieġeb b'massimu ta' 2-3 sentenzi."
            },
            {"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")

Dettatura vokali b’awtosaving

Id-dettatura tippreżenta problema li ż-żewġ każijiet preċedenti jinjoraw: id-durata. Sessjoni tista’ testendi għal aktar minn siegħa, u li titlef it-test minħabba ħsara jew qtugħ ikun inaċċettabbli. Għalhekk is-saving awtomatiku, attivat bejn wieħed u ieħor kull mitt kelma, li jikteb mill-ġdid il-fajl tal-output waqt it-tħaddim. Il-kontatur nb_mots iservi wkoll bħala feedback għall-utent: jgħidlek kemm ipproduċejt, informazzjoni li kulħadd li qed jiddetta rapport jistenna. Il-latency ta’ 600 millisekonda tpoġġi l-kursur fuq in-naħa tal-preċiżjoni, peress li min qed jiddetta jaqra lura t-test tiegħu u jippreferi kelma preċiża minn waħda immedjata.

class DicteeVocale:
    """Dettatura vokali b'saving awtomatiku."""

    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("Qed niddetta... (Ctrl+C biex tieqaf)\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 kull 100 kelma
                if self.nb_mots % 100 < 5:
                    self._sauvegarder()

            elif isinstance(event, TranscriptionStreamDone):
                break

        self._sauvegarder()
        print(f"\n\nDettatura lesta: {self.nb_mots} kelma")
        print(f"Fajl: {self.fichier_sortie}")

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

Traskrizzjoni ta’ konferenza b’metadata

Għal konferenza twila, it-test mhux maħdum ma jiswa’ ħafna jekk ma jkunx identifikabbli. Sitt xhur wara, ħadd ma jkun jaf minn liema sessjoni jew kelliem ġie fajl imsejjaħ transcription.txt. Il-funzjoni li ġejja għalhekk tgħatti t-traskrizzjoni f’struttura dokumentata—isem il-konferenza, il-kelliem, it-timstamps tal-bidu u t-tmiem, in-numru ta’ kliem—u tesportaha bħala JSON taħt isem b’timestamp, immedjatament użabbli minn magna ta’ tfittxija interna jew pipeline ta’ arkivjar. Il-latency ta’ 1,200 millisekonda hija komda ħafna hawnhekk: l-udjenza tisma’ lill-kelliem, id-display huwa biss suppliment, u l-preċiżjoni tieħu prijorità.

import json
from datetime import datetime

async def transcribe_conference(
    audio_source,
    conference_name: str,
    speaker: str = "Inconnu"
):
    """Tittraskrivi sessjoni ta' konferenza b'metadata."""
    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"Traskrizzjoni: {conference_name}")
    print(f"Kelliem: {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\nSessjoni salvata: {filename}")
    return session

Irrevedi l-erba’ latencies fl-ordni—300, 600, 800, u mbagħad 1,200 millisekonda—u nnuta li jsegwu loġika waħda: aktar ma l-utent jistenna reazzjoni mill-magna, iqsar irid ikun id-dewmien; aktar ma jistenna dokument użabbli, itwal jista’ jkun. Ħu waħda minn dawn l-applikazzjonijiet u qabbadha mal-ġeneratur tal-mikrofonu mil-lezzjoni ta’ qabel: ikollok għodda verament użabbli f’ftit minuti biss.

Punti Ewlenin

  • Is-sottotitli live jużaw latency ta’ 800 ms u jimmaniġġjaw id-display linja b’linja
  • L-assistent vokali jgħaqqad it-traskrizzjoni f’ħin reali u LLM biex iwieġeb mistoqsijiet
  • Id-dettatura vokali tissalva awtomatikament it-test waqt it-tħaddim
  • It-traskrizzjoni tal-konferenza żżid metadata u tesporta lejn JSON
  • Kull każ ta’ użu għandu l-latency ottimali tiegħu: 300 ms (assistent) sa 1,200 ms (konferenza), fir-raġġ aċċettat ta’ 80 sa 1,200 ms jew 2,400 ms