Przejdź do głównej treści
Polski— Wybierz język
Menu

Optymalizacja jakości transkrypcji

Lekcja 9 z 18 Zaktualizowano 3 listopada 2026 Programista
Na tej stronie
  1. Optymalizacja jakości transkrypcji
  2. Parametr prompt
  3. Parametr temperature
  4. Preprocessing audio
  5. Postprocessing transkrypcji
  6. Kompletny potok transkrypcji
  7. Kluczowe wnioski

Aktualizacja z 2 listopada 2026 — Modele audio. Kilka modeli w tym kursie zostało wycofanych: tts-1, tts-1-hd i gpt-4o-mini-tts przestaną działać 6 stycznia 2027 (zalecanym zamiennikiem jest gpt-realtime-2.1-mini, który zgodnie z przewodnikiem OpenAI TTS nie jest obsługiwany przez /v1/audio/speech: migracja syntezy głosu przechodzi do Realtime API); gpt-realtime, gpt-4o-realtime oraz starsze modele audio 20 stycznia 2027 (gpt-realtime-2.1, gpt-realtime-2.1-mini, gpt-audio-1.5); whisper-1, gpt-4o-transcribe i /v1/audio/translations 26 lutego 2027 (gpt-transcribe, gpt-live-transcribe, v1/realtime/translations). W przypadku głosu pełnodupleksowego GPT-Live 1 jest dostępny w API od 10 września 2026. Lekcja zaktualizowana 3 listopada 2026: przykłady przełączono na gpt-transcribe (prompt, keywords, languages), model rekomendowany przez OpenAI; temperatura 0 nie oznacza wyboru „zawsze najbardziej prawdopodobnego“: zgodnie z dokumentacją API model sam dostosowuje wówczas temperaturę krokami. Źródła: Transkrypcja pliku · Utwórz transkrypcję.

Optymalizacja jakości transkrypcji

Whisper domyślnie generuje doskonałe transkrypcje, ale kilka technik może znacząco poprawić ich jakość, zwłaszcza w trudnych przypadkach: szum tła, regionalne akcenty, słownictwo techniczne i nazwy własne. Ta lekcja omawia zaawansowane parametry i strategie postprocessingu.

Parametr prompt

Kontekst to Twoje główne narzędzie do poprawy jakości. W przypadku gpt-transcribe, modelu rekomendowanego przez OpenAI, kontekst przekazywany jest przez trzy parametry: prompt (zdanie kontekstowe w języku nagrania), keywords (terminy do rozpoznania) oraz languages (oczekiwane języki).

# Bez kontekstu nazwy produktów ryzykują błędną transkrypcję
result = client.audio.transcriptions.create(
    model="gpt-transcribe",
    file=audio_file,
    languages=["fr"],
)

# Z kontekstem i słowami kluczowymi
result = client.audio.transcriptions.create(
    model="gpt-transcribe",
    file=audio_file,
    languages=["fr"],
    prompt="Spotkanie techniczne Corsen AI dotyczące agentów głosowych.",
    keywords=["GPT-6.1 Sol", "Responses API", "Realtime API", "Corsen AI", "Mordehai Attia"],
)

Najlepsze praktyki dla promptu

  • Wymień nazwy własne: osoby, firmy, produkty
  • Uwzględnij żargon techniczny: akronimy, terminy branżowe
  • Określ oczekiwany styl: interpunkcja, wielkość liter
  • W przypadku whisper-1 wszystko trafia do pojedynczego parametru prompt, ograniczonego do 224 tokenów: przewodnik precyzuje, że Whisper nie podąża za instrukcjami jak model tekstowy, stąd korzyść z prostego wymienienia tam poprawnych pisowni
  • W przypadku gpt-transcribe umieść terminy w keywords, po jednym wpisie, bez <, > czy znaków nowej linii, w przeciwnym razie API odrzuci żądanie
def build_transcription_prompt(context: dict) -> str:
    """Buduje prompt kontekstowy do transkrypcji."""
    parts = []

    if context.get("speakers"):
        parts.append(", ".join(context["speakers"]))

    if context.get("technical_terms"):
        parts.append(", ".join(context["technical_terms"]))

    if context.get("topic"):
        parts.append(context["topic"])

    return ". ".join(parts)

prompt = build_transcription_prompt({
    "speakers": ["Mordehai Attia", "Yoram Halberstam"],
    "technical_terms": ["Realtime API", "WebSocket", "VAD", "PCM16"],
    "topic": "Spotkanie techniczne dotyczące agentów głosowych"
})

Parametr temperature

Endpoint akceptuje temperature w zakresie od 0 do 1, domyślnie ustawione na 0. Wbrew powszechnemu przekonaniu, wartość 0 nie oznacza „zawsze najbardziej prawdopodobne słowo“: zgodnie z dokumentacją API model opiera się wówczas na prawdopodobieństwach tokenów, aby samoczynnie podnieść temperaturę krokami, aż do określonych progów.

W praktyce pozostaw wartość domyślną. Dokumentacja gpt-transcribe kładzie nacisk na kontekst (prompt, keywords, languages), a nie na temperaturę; w przypadku whisper-1 nieco wyższą temperaturę (np. 0,2) można przetestować doraźnie przy zdegradowanym audio.

Preprocessing audio

Jakość wejściowego audio jest najbardziej decydującym czynnikiem. Zainwestuj w preprocessing:

from pydub import AudioSegment
from pydub.effects import normalize, compress_dynamic_range

def preprocess_audio(input_path: str, output_path: str) -> str:
    """Przetwarza wstępnie audio dla optymalnej transkrypcji."""
    audio = AudioSegment.from_file(input_path)

    # 1. Konwersja do mono (stereo nic nie wnosi dla głosu)
    audio = audio.set_channels(1)

    # 2. Próbkowanie do 16 kHz (wystarczające dla Whisper)
    audio = audio.set_frame_rate(16000)

    # 3. Normalizacja głośności
    audio = normalize(audio)

    # 4. Kompresja dynamiki (zmniejsza różnicę między głośnymi a cichymi fragmentami)
    audio = compress_dynamic_range(audio)

    # 5. Eksport jako MP3 64 kbps
    audio.export(output_path, format="mp3", bitrate="64k")
    return output_path

Redukcja szumów

W przypadku nagrań zaszumionych wstępne przetworzenie za pomocą noisereduce znacząco poprawia wyniki:

import noisereduce as nr
import soundfile as sf
import numpy as np

def reduce_noise(input_path: str, output_path: str) -> str:
    """Redukuje szum tła przed transkrypcją."""
    data, rate = sf.read(input_path)

    # Adaptacyjna redukcja szumów
    reduced = nr.reduce_noise(
        y=data,
        sr=rate,
        prop_decrease=0.8,  # 80% redukcji szumu
        stationary=False     # Szum niestacjonarny (np. kawiarnia)
    )

    sf.write(output_path, reduced, rate)
    return output_path

Postprocessing transkrypcji

Nawet przy dobrym preprocessingu surowa transkrypcja może wymagać korekt. Wykorzystaj GPT do postprocessingu:

async def post_process_transcription(raw_text: str, context: str) -> str:
    """Koryguje i formatuje transkrypcję Whisper."""
    response = client.responses.create(
        model="gpt-5.6-luna",
        input=[
            {"role": "system", "content": (
                "Jesteś korektorem transkrypcji. "
                "Popraw oczywiste błędy Whisper bez zmiany znaczenia. "
                "Dodaj brakującą interpunkcję. "
                "Popraw wielkość liter w nazwach własnych i akronimach. "
                "Nie streszczaj ani nie parafrazuj."
            )},
            {"role": "user", "content": (
                f"Kontekst: {context}\n\n"
                f"Surowa transkrypcja:\n{raw_text}"
            )}
        ]
    )

    return response.output_text

Kompletny potok transkrypcji

Połącz wszystkie kroki w solidny potok:

async def transcribe_high_quality(
    file_path: str,
    language: str = "fr",
    speakers: list[str] = None,
    technical_terms: list[str] = None
) -> dict:
    """Kompletny potok transkrypcji wysokiej jakości."""
    # 1. Preprocessing
    processed_path = preprocess_audio(file_path, "/tmp/processed.mp3")

    # 2. Budowa kontekstu: tylko wypełnione parametry
    options = {}
    terms = (speakers or []) + (technical_terms or [])
    if terms:
        options["keywords"] = terms

    # 3. Transkrypcja
    with open(processed_path, "rb") as f:
        result = client.audio.transcriptions.create(
            model="gpt-transcribe",
            file=f,
            languages=[language],
            **options,
        )

    # 4. Postprocessing
    context = f"Język: {language}, Prelegenci: {speakers}"
    corrected = await post_process_transcription(result.text, context)

    return {
        "raw_text": result.text,
        "corrected_text": corrected,
        "languages": result.languages,
    }

Kluczowe wnioski

  • Kontekst to najskuteczniejsze narzędzie: prompt, keywords i languages w przypadku gpt-transcribe; pojedynczy prompt ograniczony do 224 tokenów w przypadku whisper-1
  • temperature domyślnie wynosi 0, a przy tej wartości model sam dostosowuje temperaturę w razie potrzeby: pozostaw wartość domyślną
  • Preprocessing audio (mono, 16 kHz, normalizacja, odszumianie) poprawia jakość bardziej niż jakikolwiek parametr API
  • Postprocessing przez GPT koryguje interpunkcję, wielkość liter i pozostałe błędy
  • Kompletny potok łączy preprocessing, promptowanie kontekstowe i postprocessing, aby osiągnąć maksymalną jakość