Ir para o conteúdo principal
Português— Escolher um idioma
Menu

Otimizar a Qualidade da Transcrição

Aula 9 de 18 Atualizada a 3 de novembro de 2026 Programador
Nesta página
  1. Otimizar a Qualidade da Transcrição
  2. O parâmetro prompt
  3. O parâmetro temperature
  4. Pré-processamento de áudio
  5. Pós-processamento da transcrição
  6. Pipeline de transcrição completo
  7. Pontos-chave

Atualização de 2 de novembro de 2026 — Modelos de áudio. Vários modelos neste curso estão obsoletos: tts-1, tts-1-hd e gpt-4o-mini-tts deixarão de funcionar a 6 de janeiro de 2027 (a substituição indicada é gpt-realtime-2.1-mini, que o guia de TTS da OpenAI afirma não ser suportada por /v1/audio/speech: a migração da síntese de voz passa para a Realtime API); gpt-realtime, gpt-4o-realtime e modelos de áudio legados a 20 de janeiro de 2027 (gpt-realtime-2.1, gpt-realtime-2.1-mini, gpt-audio-1.5); whisper-1, gpt-4o-transcribe e /v1/audio/translations a 26 de fevereiro de 2027 (gpt-transcribe, gpt-live-transcribe, v1/realtime/translations). Para voz em full-duplex, o GPT-Live 1 está disponível na API desde 10 de setembro de 2026. Lição atualizada a 3 de novembro de 2026: exemplos alterados para gpt-transcribe (prompt, keywords, languages), o modelo recomendado pela OpenAI; temperatura 0 não é uma escolha de “sempre mais provável”: segundo a referência da API, o modelo ajusta então a temperatura automaticamente em passos. Fontes: Transcrição de ficheiros · Criar transcrição.

Otimizar a Qualidade da Transcrição

O Whisper produz transcrições excelentes por predefinição, mas várias técnicas podem melhorar significativamente a qualidade, especialmente em casos difíceis: ruído de fundo, sotaques regionais, vocabulário técnico e nomes próprios. Esta lição abrange parâmetros avançados e estratégias de pós-processamento.

O parâmetro prompt

O contexto é a sua alavanca principal para melhorar a qualidade. Com gpt-transcribe, o modelo recomendado pela OpenAI, o contexto passa por três parâmetros: prompt (uma frase de contexto no idioma do áudio), keywords (termos a reconhecer) e languages (idiomas esperados).

# Sem contexto, os nomes de produtos correm o risco de ser mal transcritos
result = client.audio.transcriptions.create(
    model="gpt-transcribe",
    file=audio_file,
    languages=["fr"],
)

# Com contexto e palavras-chave
result = client.audio.transcriptions.create(
    model="gpt-transcribe",
    file=audio_file,
    languages=["fr"],
    prompt="Reunião técnica da Corsen AI sobre agentes de voz.",
    keywords=["GPT-6.1 Sol", "Responses API", "Realtime API", "Corsen AI", "Mordehai Attia"],
)

Melhores práticas para o prompt

  • Liste nomes próprios: pessoas, empresas, produtos
  • Inclua jargão técnico: acrónimos, termos específicos do domínio
  • Especifique o estilo esperado: pontuação, capitalização
  • Com whisper-1, tudo passa pelo único prompt, limitado a 224 tokens: o guia especifica que o Whisper não segue instruções como um modelo de texto, daí a vantagem de simplesmente listar as grafias corretas aí
  • Com gpt-transcribe, coloque os termos em keywords, um por entrada, sem <, > ou quebras de linha, caso contrário a API rejeita o pedido
def build_transcription_prompt(context: dict) -> str:
    """Constrói um prompt de contexto para transcrição."""
    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": "Reunião técnica sobre agentes de voz"
})

O parâmetro temperature

O endpoint aceita um temperature entre 0 e 1, com predefinição 0. Ao contrário de um equívoco comum, o valor 0 não significa “sempre a palavra mais provável”: segundo a referência da API, o modelo recorre então às suas probabilidades de tokens para aumentar a temperatura automaticamente em passos, até certos limiares.

Na prática, mantenha o valor predefinido. A documentação de gpt-transcribe enfatiza o contexto (prompt, keywords, languages), não a temperatura; em whisper-1, uma temperatura ligeiramente superior (0,2, por exemplo) pode ser testada em áudio degradado caso a caso.

Pré-processamento de áudio

A qualidade do áudio de entrada é o fator mais decisivo. Invista no pré-processamento:

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

def preprocess_audio(input_path: str, output_path: str) -> str:
    """Pré-processa o áudio para uma transcrição ótima."""
    audio = AudioSegment.from_file(input_path)

    # 1. Converter para mono (o estéreo não acrescenta nada para voz)
    audio = audio.set_channels(1)

    # 2. Redimensionar para 16 kHz (suficiente para o Whisper)
    audio = audio.set_frame_rate(16000)

    # 3. Normalizar o volume
    audio = normalize(audio)

    # 4. Comprimir a gama dinâmica (reduz a diferença entre alto e baixo)
    audio = compress_dynamic_range(audio)

    # 5. Exportar como MP3 a 64 kbps
    audio.export(output_path, format="mp3", bitrate="64k")
    return output_path

Redução de ruído

Para gravações ruidosas, o pré-processamento com noisereduce melhora significativamente os resultados:

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

def reduce_noise(input_path: str, output_path: str) -> str:
    """Reduz o ruído de fundo antes da transcrição."""
    data, rate = sf.read(input_path)

    # Redução de ruído adaptativa
    reduced = nr.reduce_noise(
        y=data,
        sr=rate,
        prop_decrease=0.8,  # 80% de redução de ruído
        stationary=False     # Ruído não estacionário (ex.: café)
    )

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

Pós-processamento da transcrição

Mesmo com um bom pré-processamento, a transcrição bruta pode exigir correções. Utilize o GPT para o pós-processamento:

async def post_process_transcription(raw_text: str, context: str) -> str:
    """Corrige e formata uma transcrição do Whisper."""
    response = client.responses.create(
        model="gpt-5.6-luna",
        input=[
            {"role": "system", "content": (
                "É um corretor de transcrições. "
                "Corrija erros óbvios do Whisper sem alterar o significado. "
                "Adicione a pontuação em falta. "
                "Corrija a capitalização de nomes próprios e acrónimos. "
                "Não resuma nem reformule."
            )},
            {"role": "user", "content": (
                f"Contexto: {context}\n\n"
                f"Transcrição bruta:\n{raw_text}"
            )}
        ]
    )

    return response.output_text

Pipeline de transcrição completo

Reúna todas as etapas num pipeline robusto:

async def transcribe_high_quality(
    file_path: str,
    language: str = "fr",
    speakers: list[str] = None,
    technical_terms: list[str] = None
) -> dict:
    """Pipeline de transcrição de alta qualidade completo."""
    # 1. Pré-processamento
    processed_path = preprocess_audio(file_path, "/tmp/processed.mp3")

    # 2. Construir contexto: apenas parâmetros preenchidos
    options = {}
    terms = (speakers or []) + (technical_terms or [])
    if terms:
        options["keywords"] = terms

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

    # 4. Pós-processamento
    context = f"Idioma: {language}, Oradores: {speakers}"
    corrected = await post_process_transcription(result.text, context)

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

Pontos-chave

  • O contexto é a alavanca mais eficaz: prompt, keywords e languages com gpt-transcribe; o único prompt, limitado a 224 tokens, com whisper-1
  • temperature tem predefinição 0 e, a 0, o modelo ajusta a temperatura automaticamente se necessário: mantenha o valor predefinido
  • O pré-processamento de áudio (mono, 16 kHz, normalização, remoção de ruído) melhora a qualidade mais do que qualquer parâmetro da API
  • O pós-processamento com GPT corrige a pontuação, a capitalização e erros residuais
  • Um pipeline completo combina pré-processamento, prompting contextual e pós-processamento para máxima qualidade