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

Ροή ήχου σε πραγματικό χρόνο

Μάθημα 12 / 18 Ενημερώθηκε 3 Νοεμβρίου 2026 Για developers
Σε αυτήν τη σελίδα
  1. Ροή ήχου σε πραγματικό χρόνο
  2. Ροή με το TTS API
  3. Μέτρηση της καθυστέρησης
  4. Ασύγχρονη ροή
  5. Προ-συμπλήρωση buffer
  6. Ενσωμάτωση σε μια ροή εργασίας LLM + TTS
  7. Βασικά σημεία

Ενημέρωση 2 Νοεμβρίου 2026 — Μοντέλα ήχου. Αρκετά μοντέλα σε αυτό το μάθημα έχουν καταργηθεί: τα tts-1, tts-1-hd και gpt-4o-mini-tts θα σταματήσουν να λειτουργούν στις 6 Ιανουαρίου 2027 (διάδοχος: gpt-realtime-2.1-mini, το οποίο ο οδηγός TTS της OpenAI αναφέρει ότι δεν υποστηρίζεται από το /v1/audio/speech: η μετάβαση στη σύνθεση φωνής μεταφέρεται στο Realtime API)· τα gpt-realtime, gpt-4o-realtime και τα παλαιότερα μοντέλα ήχου στις 20 Ιανουαρίου 2027 (gpt-realtime-2.1, gpt-realtime-2.1-mini, gpt-audio-1.5)· τα whisper-1, gpt-4o-transcribe και το /v1/audio/translations στις 26 Φεβρουαρίου 2027 (gpt-transcribe, gpt-live-transcribe, v1/realtime/translations). Για επικοινωνία πλήρους διπλής κατεύθυνσης (full-duplex), το GPT-Live 1 είναι διαθέσιμο στο API από τις 10 Σεπτεμβρίου 2026. Ενημερώθηκε στις 3 Νοεμβρίου 2026: Η ροή εργασίας LLM → TTS επεξεργαζόταν προηγουμένως οποιοδήποτε συμβάν που περιείχε πεδίο delta, συμπεριλαμβανομένων ορισμάτων κλήσης συνάρτησης ή περιλήψεων συλλογισμού· πλέον φιλτράρει αυστηρά μόνο το response.output_text.delta, δηλαδή το πραγματικό κείμενο απόκρισης.

Ροή ήχου σε πραγματικό χρόνο

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

Ροή με το TTS API

Το TTS API υποστηρίζει εγγενώς τη ροή δεδομένων. Αντί να περιμένετε το ολοκληρωμένο αρχείο, λαμβάνετε τον ήχο σε τμήματα:

from openai import OpenAI
import pyaudio

client = OpenAI()

def stream_tts_to_speaker(text: str, voice: str = "alloy"):
    """Δημιουργία και αναπαραγωγή ήχου σε λειτουργία ροής."""
    # Αρχικοποίηση του προγράμματος αναπαραγωγής ήχου
    pa = pyaudio.PyAudio()
    player = pa.open(
        format=pyaudio.paInt16,
        channels=1,
        rate=24000,
        output=True
    )

    try:
        # Δημιουργία της απόκρισης ροής
        with client.audio.speech.with_streaming_response.create(
            model="tts-1",
            voice=voice,
            input=text,
            response_format="pcm"  # Raw PCM για άμεση αναπαραγωγή
        ) as response:
            # Ανάγνωση και αναπαραγωγή τμήμα προς τμήμα
            for chunk in response.iter_bytes(chunk_size=4096):
                player.write(chunk)

    finally:
        player.stop_stream()
        player.close()
        pa.terminate()

stream_tts_to_speaker("Hello, here is a real-time streaming response.")

Η μορφή pcm είναι ιδανική για ροή, καθώς δεν απαιτεί αποκωδικοποίηση: τα raw bytes είναι έτοιμα για άμεση αναπαραγωγή.

Μέτρηση της καθυστέρησης

Ο χρόνος μέχρι το πρώτο byte (TTFB) είναι η βασική μετρική για την απόδοση της ροής:

import time

def measure_tts_latency(text: str, voice: str = "alloy") -> dict:
    """Μέτρηση των καθυστερήσεων ροής TTS."""
    start_time = time.time()
    first_byte_time = None
    total_bytes = 0

    with client.audio.speech.with_streaming_response.create(
        model="tts-1",
        voice=voice,
        input=text,
        response_format="pcm"
    ) as response:
        for chunk in response.iter_bytes(chunk_size=4096):
            if first_byte_time is None:
                first_byte_time = time.time()
            total_bytes += len(chunk)

    end_time = time.time()

    return {
        "ttfb_ms": round((first_byte_time - start_time) * 1000),
        "total_ms": round((end_time - start_time) * 1000),
        "total_bytes": total_bytes,
        "audio_duration_s": round(total_bytes / (24000 * 2), 2)
    }

metrics = measure_tts_latency("Hello, how are you?")
print(f"TTFB: {metrics['ttfb_ms']}ms, Total: {metrics['total_ms']}ms")

Ασύγχρονη ροή

Για εφαρμογές πλευράς διακομιστή, χρησιμοποιήστε τον ασύγχρονο πελάτη:

from openai import AsyncOpenAI
import asyncio

async_client = AsyncOpenAI()

async def stream_tts_async(text: str, voice: str = "alloy"):
    """Ασύγχρονη ροή TTS για διακομιστές."""
    chunks = []

    async with async_client.audio.speech.with_streaming_response.create(
        model="tts-1",
        voice=voice,
        input=text,
        response_format="pcm"
    ) as response:
        async for chunk in response.iter_bytes(chunk_size=4096):
            chunks.append(chunk)
            # Εδώ, θα στέλνατε το τμήμα στον πελάτη μέσω WebSocket
            yield chunk

# Χρήση σε έναν διακομιστή FastAPI
from fastapi import FastAPI
from fastapi.responses import StreamingResponse

app = FastAPI()

@app.get("/tts/stream")
async def tts_stream(text: str, voice: str = "alloy"):
    return StreamingResponse(
        stream_tts_async(text, voice),
        media_type="audio/pcm"
    )

Προ-συμπλήρωση buffer

Για να εξασφαλίσετε ομαλή αναπαραγωγή χωρίς κενά, συσσωρεύστε ένα μικρό buffer πριν ξεκινήσετε:

async def buffered_tts_playback(
    text: str,
    voice: str = "alloy",
    buffer_size: int = 3  # Αριθμός τμημάτων για προ-φόρτωση
):
    """Αναπαραγωγή TTS με buffer προ-συμπλήρωσης."""
    pa = pyaudio.PyAudio()
    player = pa.open(
        format=pyaudio.paInt16,
        channels=1,
        rate=24000,
        output=True
    )

    buffer = []
    playback_started = False

    try:
        async with async_client.audio.speech.with_streaming_response.create(
            model="tts-1",
            voice=voice,
            input=text,
            response_format="pcm"
        ) as response:
            async for chunk in response.iter_bytes(chunk_size=4096):
                buffer.append(chunk)

                if not playback_started and len(buffer) >= buffer_size:
                    playback_started = True
                    # Εκκένωση του αρχικού buffer
                    for buffered_chunk in buffer:
                        player.write(buffered_chunk)
                    buffer.clear()
                elif playback_started:
                    player.write(chunk)

        # Αναπαραγωγή των υπόλοιπων τμημάτων
        for remaining in buffer:
            player.write(remaining)

    finally:
        player.stop_stream()
        player.close()
        pa.terminate()

Ενσωμάτωση σε μια ροή εργασίας LLM + TTS

Σε έναν πράκτορα φωνής που δεν χρησιμοποιεί το Realtime API, μπορείτε να συνδυάσετε τη ροή του LLM με τη ροή του TTS:

async def llm_to_tts_pipeline(user_message: str):
    """Ροή εργασίας: Ροή LLM → Ροή TTS σε πραγματικό χρόνο."""
    # Φάση 1: Συσσώρευση απόκρισης LLM ανά πρόταση
    sentence_buffer = ""

    stream = client.responses.create(
        model="gpt-5.6-luna",
        input=[{"role": "user", "content": user_message}],
        stream=True
    )

    for event in stream:
        # Μόνο το κείμενο απόκρισης πρέπει να εκφωνηθεί
        if event.type == "response.output_text.delta":
            sentence_buffer += event.delta

            # Εντοπισμός τέλους πρότασης
            if sentence_buffer.rstrip().endswith((".", "!", "?")):
                sentence = sentence_buffer.strip()
                sentence_buffer = ""

                # Φάση 2: Ροή αυτής της πρότασης στο TTS
                stream_tts_to_speaker(sentence)

    # Επεξεργασία του υπόλοιπου buffer
    if sentence_buffer.strip():
        stream_tts_to_speaker(sentence_buffer.strip())

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

  • Η ροή TTS μειώνει το TTFB σε μερικές εκατοντάδες χιλιοστά του δευτερολέπτου, ξεκινώντας την αναπαραγωγή πριν ολοκληρωθεί η δημιουργία
  • Η μορφή pcm είναι βέλτιστη για ροή: δεν απαιτείται αποκωδικοποίηση, άμεση αναπαραγωγή
  • Ένα buffer προ-συμπλήρωσης 2–3 τμημάτων αποτρέπει τα κενά στην αρχή της αναπαραγωγής
  • Ο ασύγχρονος πελάτης είναι απαραίτητος για διακομιστές που διαχειρίζονται πολλαπλές ταυτόχρονες συνδέσεις
  • Ο συνδυασμός ροής LLM και ροής TTS επιτρέπει τη δημιουργία ενός αποκρινόμενου πράκτορα φωνής χωρίς τη χρήση του Realtime API