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

API TTS: ustvarjanje govora

Lekcija 10 od 18 Posodobljeno 3. november 2026 Razvijalec
Na tej strani
  1. API TTS: ustvarjanje govora
  2. Tvoj prvi klic TTS
  3. Razpoložljivi modeli
  4. Izhodne oblike
  5. Ustvarjanje zvoka v serijah
  6. Omejitev znakov in razdeljevanje
  7. Po 6. januarju 2027: kako spraviti model Realtime do govora
  8. Ključne ugotovitve

Posodobitev 2. novembra 2026 — Zvočni modeli. Več modelov v tem tečaju je zastarelih: tts-1, tts-1-hd in gpt-4o-mini-tts bodo ukinjeni 6. januarja 2027 (naslednik: gpt-realtime-2.1-mini, za katerega vodnik OpenAI za TTS navaja, da ga /v1/audio/speech ne podpira: selitev sinteze govora prehaja na API Realtime); gpt-realtime, gpt-4o-realtime in stari zvočni modeli 20. januarja 2027 (gpt-realtime-2.1, gpt-realtime-2.1-mini, gpt-audio-1.5); whisper-1, gpt-4o-transcribe in /v1/audio/translations 26. februarja 2027 (gpt-transcribe, gpt-live-transcribe, v1/realtime/translations). Za polno duplexni glas je GPT-Live 1 na voljo v API-ju od 10. septembra 2026. Lekcija popravljena 3. novembra 2026: response.stream_to_file() na rezultatu speech.create() je zastarel po mnenju SDK-ja („Zaradi napake ta metoda dejansko ne pretaka”) → uporabite with_streaming_response, kot v uradnem vodniku; modeli in glasovi posodobljeni (gpt-4o-mini-tts in njegova navodila za glas, 13 glasov, vključno z marin in cedar); novo poglavje o selitvi na gpt-realtime-2.1-mini pred 6. januarjem 2027, na podlagi vodnika Realtime conversations. Viri: Text to speech · Create speech · Realtime conversations · Deprecations.

API TTS: ustvarjanje govora

API OpenAI za pretvorbo besedila v govor (TTS) pretvori besedilo v visokokakovosten zvok. Za razliko od API-ja Realtime, ki upravlja celotne glasovne pogovore, je API TTS storitev za enkratni klic: pošljete besedilo in prejmete zvočno datoteko. To je idealno orodje za ustvarjanje napovedi, glasovnih obvestil, avdio knjig ali dostopne vsebine.

Tvoj prvi klic TTS

Ustvarjanje govora je izjemno preprosto:

from openai import OpenAI
from pathlib import Path

client = OpenAI()

speech_file = Path("welcome.mp3")

with client.audio.speech.with_streaming_response.create(
    model="gpt-4o-mini-tts",
    voice="coral",
    input="Dobrodošel na Corsen Academy. "
          "Tvoje usposabljanje za glasovne agente se začne zdaj.",
    instructions="Govori s toplim, umirjenim tonom.",
) as response:
    response.stream_to_file(speech_file)

API vrne zvočni tok, ki ga lahko neposredno shraniš ali pretočiš v predvajalnik. Uporabi with_streaming_response, kot je prikazano tukaj: klicanje stream_to_file() na rezultatu navadnega speech.create() je zastarelo po mnenju SDK-ja, ki opozarja, da ta metoda dejansko ne pretaka zvoka.

Razpoložljivi modeli

Trije modeli Audio API so zastareli in bodo ukinjeni 6. januarja 2027: to je prehodno obdobje, ko jih boš še vedno uporabljal.

ModelPosebnostGlasovi
gpt-4o-mini-ttsSprejema navodila: naglas, čustva, intonacija, hitrost, ton, šepetanje13 glasov, vključno z marin in cedar, priporočeni za kakovost
tts-1Manjša zakasnitev, nižja kakovost9 glasov: alloy, ash, coral, echo, fable, onyx, nova, sage, shimmer
tts-1-hdVišja kakovost kot tts-1, večja zakasnitevIstih 9 glasov

Navodila ne delujejo z tts-1 in tts-1-hd. Parameter speed, od 0,25 do 4,0, prilagodi hitrost pri vseh modelih. Po navodilih vodnika so glasovi optimizirani za angleščino: poslušaj jih v francoščini na OpenAI.fm pred izbiro. Pravilnik o uporabi OpenAI prav tako zahteva, da svoje uporabnike jasno obvestiš, da je glas, ki ga slišijo, ustvarjen s strani umetne inteligence.

Izhodne oblike

API proizvaja šest formatov, izbranih s parametrom response_format:

OblikaUporaba
mp3 (privzeto)Splošna uporaba
opusPretakanje in komunikacija prek interneta, nizka zakasnitev
aacDigitalno stiskanje, prednostno za YouTube, Android in iOS
flacBrezizgubno stiskanje, za arhiviranje
wavNestisnjeno, za izogibanje stroškom dekodiranja
pcmSurovi vzorci pri 24 kHz, 16-bitni podpisani, brez glave
for fmt in ("mp3", "opus", "aac", "flac", "wav", "pcm"):
    with client.audio.speech.with_streaming_response.create(
        model="gpt-4o-mini-tts",
        voice="marin",
        input="Besedilo za pretvorbo",
        response_format=fmt,
    ) as response:
        response.stream_to_file(f"example.{fmt}")

Za glasovnega agenta, zgrajenega na API-ju Realtime, je oblika pcm najbolj priročna: njeni vzorci 24 kHz, 16-bit ustrezajo obliki audio/pcm API-ja Realtime pri 24 kHz.

Ustvarjanje zvoka v serijah

Za velike količine besedila obdeluj segmente vzporedno:

import asyncio
from openai import AsyncOpenAI

async_client = AsyncOpenAI()

async def generate_speech_batch(segments: list[dict]) -> list[bytes]:
    """Ustvari zvok za več segmentov vzporedno."""
    async def generate_one(segment):
        response = await async_client.audio.speech.create(
            model="gpt-4o-mini-tts",
            voice=segment.get("voice", "alloy"),
            input=segment["text"],
            response_format="mp3"
        )
        return await response.aread()

    tasks = [generate_one(seg) for seg in segments]
    return await asyncio.gather(*tasks)

# Uporaba
segments = [
    {"text": "Poglavje eno. Uvod v glasovne agente.", "voice": "onyx"},
    {"text": "Glasovni agenti preoblikujejo interakcijo med človekom in računalnikom.", "voice": "onyx"},
    {"text": "V tem poglavju bomo raziskali osnove.", "voice": "onyx"},
]

audio_chunks = asyncio.run(generate_speech_batch(segments))

# Združevanje datotek
from pydub import AudioSegment
import io

combined = AudioSegment.empty()
for chunk in audio_chunks:
    segment = AudioSegment.from_mp3(io.BytesIO(chunk))
    combined += segment

combined.export("chapter_1.mp3", format="mp3")

Omejitev znakov in razdeljevanje

API TTS ima omejitev 4.096 znakov na zahtevo. Za daljša besedila jih razdeli pametno:

def split_text_for_tts(text: str, max_chars: int = 4000) -> list[str]:
    """Razdeli besedilo na segmente ob upoštevanju omejitev TTS."""
    sentences = text.replace(". ", ".\n").split("\n")
    segments = []
    current = ""

    for sentence in sentences:
        if len(current) + len(sentence) + 1 > max_chars:
            if current:
                segments.append(current.strip())
            current = sentence
        else:
            current += " " + sentence if current else sentence

    if current:
        segments.append(current.strip())

    return segments

Po 6. januarju 2027: kako spraviti model Realtime do govora

OpenAI določa gpt-realtime-2.1-mini kot nadomestilo za tri modele in opozarja: to ni model za končno točko /v1/audio/speech; selitev spremeni delovni tok. Prekoračiš sejo Realtime. Vodnik Realtime conversations prikazuje, kako dobiti odgovor brez konteksta, ki ignorira pogovor in sledi le svojim navodilom: to je način, da ga prisiliš izgovoriti dano besedilo.

import base64
import json
import os
import wave

import websocket  # pip install websocket-client

TEXT = "Dobrodošel na Corsen Academy. Tvoje usposabljanje za glasovne agente se začne zdaj."

ws = websocket.WebSocket()
ws.connect(
    "wss://api.openai.com/v1/realtime?model=gpt-realtime-2.1-mini",
    header=[f"Authorization: Bearer {os.environ['OPENAI_API_KEY']}"],
)

# Samo zvočni izhod, 16-bitni PCM pri 24 kHz, z izbranim glasom
ws.send(json.dumps({
    "type": "session.update",
    "session": {
        "type": "realtime",
        "output_modalities": ["audio"],
        "audio": {"output": {"format": {"type": "audio/pcm", "rate": 24000}, "voice": "marin"}},
    },
}))

# Odgovor brez konteksta (prazen vhod), ki mora izgovoriti besedilo tako, kot je
ws.send(json.dumps({
    "type": "response.create",
    "response": {
        "input": [],
        "output_modalities": ["audio"],
        "instructions": f"Izgovori točno naslednje besedilo, brez dodajanja česar koli:\n{TEXT}",
    },
}))

audio, transcription = bytearray(), []
while True:
    event = json.loads(ws.recv())
    if event["type"] == "response.output_audio.delta":
        audio += base64.b64decode(event["delta"])
    elif event["type"] == "response.output_audio_transcript.delta":
        transcription.append(event["delta"])
    elif event["type"] == "error":
        raise RuntimeError(event["error"]["message"])
    elif event["type"] == "response.done":
        break
ws.close()

with wave.open("welcome.wav", "wb") as wav:
    wav.setnchannels(1)
    wav.setsampwidth(2)  # 16 bitov
    wav.setframerate(24000)
    wav.writeframes(bytes(audio))
print("Izgovorjeno besedilo:", "".join(transcription))

V proizvodnem okolju sta pomembni dve razliki glede na Audio API. Rezultat ni več zagotovljen beseda za besedo: model Realtime sledi navodilu; ne bere datoteke. Zato primerjaj prepis tega, kar je povedal, vrnjen v response.output_audio_transcript.delta, s pričakovanim besedilom in ponovno ustvari, če pride do neskladja. Spremeni se tudi zaračunavanje: sledi tarifam modela Realtime, v besedilnih in zvočnih žetonih, navedenim na njegovem specifikacijskem listu. Končno, zavrnjen ključ ne prepreči povezave: prispe tik zatem, v dogodku error.

Ključne ugotovitve

  • gpt-4o-mini-tts, tts-1 in tts-1-hd bodo ukinjeni 6. januarja 2027; gpt-4o-mini-tts je edini, ki sprejema navodila za glas (instructions)
  • Zvok snemaj z with_streaming_response: stream_to_file() na navadnem speech.create() je zastarel
  • Šest izhodnih formatov: MP3, Opus, AAC, FLAC, WAV in surovi PCM
  • Oblika PCM je idealna za integracijo z API-jem Realtime
  • Omejitev 4.096 znakov na zahtevo: dolga besedila razdeli na mejah stavkov
  • Obdelava v serijah z asinhronim odjemalcem pospeši ustvarjanje velikih vsebin
  • Selitev poteka prek seje Realtime z gpt-realtime-2.1-mini: odgovor brez konteksta, 24 kHz PCM zvok, prepis za primerjavo z besedilom