Μετάβαση στο κύριο περιεχόμενο
Ελληνικά— Επιλέξτε γλώσσα
Μενού

Έλεγχος λανθάνουσας καθυστέρησης

Μάθημα 12 / 16 Ενημερώθηκε 3 Νοεμβρίου 2026 Για developers
Σε αυτήν τη σελίδα
  1. Η ισορροπία μεταξύ λανθάνουσας καθυστέρησης και ακρίβειας
  2. Η παράμετρος target_streaming_delay_ms
  3. Το μοτίβο Διπλής Καθυστέρησης (Dual Delay)
  4. Διαχείριση της αντικατάστασης στην οθόνη
  5. Επιλογή της σωστής καθυστέρησης για την περίπτωσή σας
  6. Μέτρηση της πραγματικής καθυστέρησης που επιτεύχθηκε
  7. Βασικά σημεία

Το μάθημα ενημερώθηκε στις 3 Νοεμβρίου 2026 για το Voxtral 3, βάσει του οδηγού Migrate from Voxtral 2 της Mistral: Τα μοντέλα Voxtral 2 (voxtral-mini-2602, voxtral-mini-transcribe-realtime-2602, voxtral-mini-tts-2603), που απεσύρθησαν στις 31 Οκτωβρίου 2026 και θα καταργηθούν οριστικά στις 30 Απριλίου 2027, αντικαθίστανται στα παραδείγματα από τα voxtral-mini-transcribe-3, voxtral-mini-transcribe-realtime-3 και voxtral-mini-tts-3-0. Βασικές αλλαγές: η χρονική σήμανση γίνεται μόνο ανά τμήμα (η τιμή word επιστρέφει σφάλμα 400), η διάκριση ομιλητών σε πραγματικό χρόνο είναι εφικτή, οι ρυθμίσεις συνεδρίας σε πραγματικό χρόνο κλειδώνουν μετά το πρώτο κομμάτι ήχου και οι είσοδοι context_bias δέχονται ελεύθερο κείμενο (φράσεις με κενά). Πηγές: Migrate from Voxtral 2 · Speech to Text.

Η ισορροπία μεταξύ λανθάνουσας καθυστέρησης και ακρίβειας

Η απομαγνητοφώνηση σε πραγματικό χρόνο βασίζεται σε έναν συμβιβασμό που δεν μπορείτε να αποφύγετε: η ταχύτητα απόκρισης επιτυγχάνεται εις βάρος της ακρίβειας. Όσο περισσότερο περιμένει το μοντέλο πριν εκπέμψει μια λέξη, τόσο περισσότερο συμφραζόμενο διαθέτει για να διακρίνει μεταξύ παρόμοιων ακουστικών υποθέσεων—και τόσο περισσότερο περιμένει ο χρήστης σας. Μια φράση όπως «πήρε τη θάλασσα» έναντι του «πήρε το πικρό» μπορεί να ξεκαθαρίσει μόνο από τα συμφραζόμενα που ακολουθούν· ένα μοντέλο που βιάζεται θα επιλέξει μερικές φορές τη λάθος εκδοχή.

Το Voxtral Realtime δεν κρύβει αυτόν τον συμβιβασμό πίσω από μια αυτόματη ρύθμιση: σας τον παραδίδει ρητά μέσω της παραμέτρου target_streaming_delay_ms. Εσείς αποφασίζετε το σημείο ισορροπίας, κατά περίπτωση.

Η παράμετρος target_streaming_delay_ms

Αυτή η τιμή εκφράζει σε χιλιοστά του δευτερολέπτου (ms) την καθυστέρηση-στόχο μεταξύ της λήψης του ήχου και της εκπομπής του αντίστοιχου κειμένου. Με το Voxtral 3, δέχεται οποιονδήποτε ακέραιο από 80 έως 1.200 ή 2.400· οποιαδήποτε άλλη τιμή προκαλεί συμβάν σφάλματος. Την περνάτε απευθείας στην κλήση ροής (streaming), ακριβώς όπως το μοντέλο και τη μορφή ήχου, και όπως όλες οι ρυθμίσεις συνεδρίας, κλειδώνει μετά το πρώτο κομμάτι ήχου:

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 for event in client.audio.realtime.transcribe_stream(
    audio_stream=source_audio,
    model="voxtral-mini-transcribe-realtime-3",
    audio_format=audio_format,
    target_streaming_delay_ms=240,  # 240 ms
):
    if isinstance(event, TranscriptionStreamTextDelta):
        print(event.text, end="", flush=True)

Τρία εύρη τιμών καλύπτουν σχεδόν όλες τις περιπτώσεις χρήσης. Μεταξύ 200 και 300 χιλιοστών του δευτερολέπτου, η απομαγνητοφώνηση είναι εξαιρετικά ανταποκρινόμενη: αυτή είναι η ρύθμιση για φωνητικούς βοηθούς, όπου η άμεση αντίδραση έχει τη μεγαλύτερη σημασία και το κείμενο μπορεί να περιέχει περισσότερες διορθώσεις. Μεταξύ 500 και 1.000 χιλιοστών του δευτερολέπτου, επιτυγχάνετε μια καλή ισορροπία, κατάλληλη για υπότιτλους σε ζωντανή μετάδοση και υπαγόρευση. Πέρα από αυτό, μεταξύ 2.000 και 3.000 χιλιοστών του δευτερολέπτου, το μοντέλο εργάζεται με πολύ περισσότερο συμφραζόμενο και παράγει σημαντικά καθαρότερο κείμενο, με τίμημα μια καθυστέρηση που αντιλαμβάνεται σαφώς ο χρήστης.

Το μοτίβο Διπλής Καθυστέρησης (Dual Delay)

Πρέπει πραγματικά να επιλέξετε; Το Voxtral Realtime προσφέρει μια λύση: εκκινήστε δύο ροές παράλληλα στον ίδιο ήχο, με διαφορετικές καθυστερήσεις, και απορρίψτε έτσι τον συμβιβασμό. Η γρήγορη ροή, ρυθμισμένη για παράδειγμα στα 240 χιλιοστά του δευτερολέπτου, παρέχει άμεση οπτική ανατροφοδότηση που καθησυχάζει τον χρήστη και δείχνει ότι το σύστημα ακούει. Η αργή ροή, ρυθμισμένη στα 2.400 χιλιοστά του δευτερολέπτου, παράγει μια πιο ακριβή απομαγνητοφώνηση που αντικαθιστά σταδιακά το προσωρινό κείμενο.

Γνωρίζετε αυτή τη συμπεριφορά ακόμα κι αν δεν της έχετε δώσει όνομα: έτσι λειτουργούν οι υπότιτλοι σε ζωντανή μετάδοση στο YouTube ή στο Google Meet, όπου το κείμενο εμφανίζεται σχεδόν ακαριαία και στη συνέχεια διορθώνεται λίγα δευτερόλεπτα αργότερα. Η υλοποίηση περιλαμβάνει τον ορισμό δύο coroutines πανομοιότυπων εκτός από την καθυστέρηση, και στη συνέχεια την εκτέλεσή τους ταυτόχρονα με το asyncio.gather.

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

async def dual_latency_stream(source_audio_fast, source_audio_slow):
    """Εκτελεί δύο απομαγνητοφωνήσεις παράλληλα με διαφορετικές καθυστερήσεις."""
    client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
    audio_format = AudioFormat(encoding="pcm_s16le", sample_rate=16000)

    results = {"fast": [], "slow": []}

    async def fast_stream():
        async for event in client.audio.realtime.transcribe_stream(
            audio_stream=source_audio_fast,
            model="voxtral-mini-transcribe-realtime-3",
            audio_format=audio_format,
            target_streaming_delay_ms=240,
        ):
            if isinstance(event, TranscriptionStreamTextDelta):
                results["fast"].append(event.text)
                # Εμφάνιση άμεσα (θα αντικατασταθεί από την αργή ροή)
                print(f"\r[FAST] {''.join(results['fast'][-10:])}",
                      end="", flush=True)

    async def slow_stream():
        async for event in client.audio.realtime.transcribe_stream(
            audio_stream=source_audio_slow,
            model="voxtral-mini-transcribe-realtime-3",
            audio_format=audio_format,
            target_streaming_delay_ms=2400,
        ):
            if isinstance(event, TranscriptionStreamTextDelta):
                results["slow"].append(event.text)
                # Εμφάνιση διορθωμένης έκδοσης
                print(f"\n[ACCURATE] {''.join(results['slow'][-10:])}",
                      flush=True)

    # Εκτέλεση και των δύο ροών παράλληλα
    await asyncio.gather(fast_stream(), slow_stream())

    return {
        "fast": "".join(results["fast"]),
        "slow": "".join(results["slow"])
    }

Σημειώστε ότι η συνάρτηση λαμβάνει δύο ξεχωριστές πηγές ήχου, όχι μία: ένας async generator μπορεί να καταναλωθεί μόνο μία φορά, επομένως πρέπει να duplicάρετε τη ροή upstream για να τροφοδοτήσετε και τις δύο απομαγνητοφωνήσεις.

Διαχείριση της αντικατάστασης στην οθόνη

Σε ένα τερματικό, η διπλή έξοδος από τον παραπάνω κώδικα αρκεί για να κατανοήσετε τον μηχανισμό, αλλά μια πραγματική διεπαφή πρέπει να συγχωνεύσει τις δύο ροές σε ένα ενιαίο, ευανάγνωστο κείμενο. Η καθιερωμένη σύμβαση είναι να εμφανίζεται το προσωρινό κείμενο σε μια διακριτική απόχρωση—γκρι—και το επιβεβαιωμένο κείμενο σε λευκό, με το όριο μεταξύ τους να προχωρά καθώς η αργή ροή προλαβαίνει την γρήγορη. Η κλάση παρακάτω υλοποιεί αυτό το όριο με το final_position: όλα όσα προηγούνται προέρχονται από την αργή ροή και δεν θα αλλάξουν, όλα όσα έπονται προέρχονται από την γρήγορη ροή και παραμένουν επιδεκτικά διόρθωσης.

class DualLatencyDisplay:
    """Διαχειρίζεται την εμφάνιση με διπλή καθυστέρηση."""

    def __init__(self):
        self.fast_text = ""
        self.final_text = ""
        self.final_position = 0

    def on_fast_text(self, text: str):
        """Νέο κείμενο από την γρήγορη ροή (προσωρινό)."""
        self.fast_text += text
        self._display()

    def on_slow_text(self, text: str):
        """Νέο κείμενο από την αργή ροή (τελικό)."""
        self.final_text += text
        self.final_position = len(self.final_text)
        self._display()

    def _display(self):
        """Εμφανίζει το τελικό κείμενο συν το γρήγορο κείμενο που δεν έχει επιβεβαιωθεί ακόμα."""
        provisional_text = self.fast_text[self.final_position:]
        display = self.final_text + provisional_text
        print(f"\r{display}", end="", flush=True)

Αυτή η άνεση έχει ένα κόστος που θα ήταν ανέντιμο να αγνοήσουμε: δύο ροές σημαίνουν δύο συνδέσεις και διπλάσιος όγκος ήχου προς επεξεργασία. Κρατήστε το Dual Delay για διεπαφές όπου ο χρήστης διαβάζει το κείμενο καθώς παράγεται· για επεξεργασία στο παρασκήνιο, μια μοναδική, καλά ρυθμισμένη ροή είναι περισσότερο από αρκετή.

Επιλογή της σωστής καθυστέρησης για την περίπτωσή σας

Περίπτωση χρήσηςΣυνιστώμενη καθυστέρησηΛόγος
Φωνητικός βοηθός200-300 msΟ χρήστης αναμένει άμεση αντίδραση
Φωνητική υπαγόρευση500-800 msΙσορροπία μεταξύ ανταπόκρισης και ακρίβειας
Υπότιτλοι σε ζωντανή μετάδοση800-1.200 msΗ ακρίβεια είναι σημαντική, μια μικρή καθυστέρηση είναι αποδεκτή
Απομαγνητοφώνηση συνεδρίου1.200 ή 2.400 msΜέγιστη ακρίβεια, η καθυστέρηση δεν είναι κρίσιμη

Μέτρηση της πραγματικής καθυστέρησης που επιτεύχθηκε

Η τιμή που ζητάτε είναι ένας στόχος, όχι μια εγγύηση: η απόσταση δικτύου, ο φόρτος υπηρεσίας και το μέγεθος των κομματιών (chunk size) σας προστίθενται σε αυτήν. Πριν αναφέρετε έναν αριθμό στους χρήστες σας, μετρήστε τον από το σημείο όπου θα εκτελείται πραγματικά η εφαρμογή σας. Η συνάρτηση παρακάτω χρονομετρά την καθυστέρηση μέχρι να φτάσει το πρώτο απόσπασμα και τη συγκρίνει με τον ζητούμενο στόχο.

import time

async def measure_latency(source_audio, delay_ms):
    """Μετρά την πραγματική καθυστέρηση της απομαγνητοφώνησης."""
    client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
    audio_format = AudioFormat(encoding="pcm_s16le", sample_rate=16000)

    start = time.time()
    first_text = None

    async for event in client.audio.realtime.transcribe_stream(
        audio_stream=source_audio,
        model="voxtral-mini-transcribe-realtime-3",
        audio_format=audio_format,
        target_streaming_delay_ms=delay_ms,
    ):
        if isinstance(event, TranscriptionStreamTextDelta):
            if first_text is None:
                first_text = time.time()
                latency = (first_text - start) * 1000
                print(f"First text after {latency:.0f} ms "
                      f"(target: {delay_ms} ms)")
            print(event.text, end="", flush=True)
        elif isinstance(event, TranscriptionStreamDone):
            break

    print(f"\nTotal duration: {time.time() - start:.1f}s")

Εκτελέστε αυτή τη μέτρηση με 240, στη συνέχεια 800 και μετά 2.400 χιλιοστά του δευτερολέπτου στο ίδιο απόσπασμα, και διαβάστε τις τρεις απομαγνητοφωνήσεις παράλληλα. Το χάσμα ποιότητας μεταξύ της πρώτης και της τελευταίας θα σας πει, καλύτερα από οποιαδήποτε γενική σύσταση, ποια καθυστέρηση μπορεί να αντέξει η εφαρμογή σας.

Βασικά σημεία

  • Το target_streaming_delay_ms ελέγχει τον συμβιβασμό καθυστέρησης/ακρίβειας
  • Χαμηλές τιμές (80 έως 300 ms): ανταποκρινόμενες αλλά λιγότερο ακριβείς
  • Υψηλές τιμές (1.200 ms ή 2.400 ms): ακριβείς αλλά με αντιληπτή καθυστέρηση· γίνονται δεκτές μόνο τιμές από 80 έως 1.200 και 2.400
  • Το μοτίβο Dual Delay συνδυάζει δύο ροές για ανταπόκριση ΚΑΙ ακρίβεια
  • Η γρήγορη ροή δίνει άμεση ανατροφοδότηση, η αργή ροή διορθώνει το κείμενο
  • Επιλέξτε την καθυστέρηση με βάση την περίπτωσή σας (φωνητικός βοηθός έναντι υποτίτλων)