Transcrição em tempo real

Use a transcrição em tempo real quando seu aplicativo precisar converter em texto o áudio de um microfone, de uma chamada ou de outra transmissão ao vivo, sem que o assistente responda por voz. O modelo recomendado retorna novos trechos da transcrição à medida que recebe a fala e a transcrição final quando o aplicativo confirma cada turno de áudio.

Comece com gpt-live-transcribe. Se o áudio já estiver gravado, use a transcrição de arquivos. Para comparar os fluxos de trabalho, consulte a visão geral da transcrição.

Crie uma sessão de transcrição

Para transcrever via WebSocket no servidor com uma chave de API padrão, conecte-se a wss://api.openai.com/v1/realtime?intent=transcription. Use o cabeçalho de autenticação indicado no guia de WebSocket, mas omita model da URL. A URL que especifica o modelo, apresentada nesse guia, cria uma sessão de conversa que não aceita a atualização de transcrição a seguir.

Após a abertura da conexão, envie session.update com type: "transcription" e selecione gpt-live-transcribe na configuração da sessão. Para trabalhar com áudio no navegador, consulte o guia de WebRTC.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18{
  "type": "session.update",
  "session": {
    "type": "transcription",
    "audio": {
      "input": {
        "format": {
          "type": "audio/pcm",
          "rate": 24000
        },
        "transcription": {
          "model": "gpt-live-transcribe"
        },
        "turn_detection": null
      }
    }
  }
}

Este exemplo usa áudio PCM a 24 kHz. Em sessões de transcrição com gpt-live-transcribe, omita audio.input.turn_detection ou defina seu valor como null. O modelo não oferece suporte a server_vad nem a semantic_vad. Para consultar a configuração completa da sessão, veja a referência de sessões Realtime.

Transmita o áudio

Envie blocos de áudio com input_audio_buffer.append.

1
2
3
4
5
6ws.send(
  JSON.stringify({
    type: "input_audio_buffer.append",
    audio: base64Pcm16,
  })
);

Envie input_audio_buffer.commit ao final de cada turno de áudio para receber a transcrição final.

1
2
3
4
5ws.send(
  JSON.stringify({
    type: "input_audio_buffer.commit",
  })
);

Use a detecção de atividade de voz (VAD) no cliente para identificar o fim da fala e, em seguida, envie input_audio_buffer.commit.

Processe os eventos de transcrição

Escute os eventos que trazem novos trechos da transcrição e os que indicam sua conclusão.

1
2
3
4
5
6
7
8
9
10
11ws.on("message", (data) => {
  const event = JSON.parse(data);

  if (event.type === "conversation.item.input_audio_transcription.delta") {
    process.stdout.write(event.delta);
  }

  if (event.type === "conversation.item.input_audio_transcription.completed") {
    console.log("\nFinal transcript:", event.transcript);
  }
});

Um evento delta contém o trecho da transcrição que acabou de ficar disponível.

123456{
  "type": "conversation.item.input_audio_transcription.delta",
  "item_id": "item_003",
  "content_index": 0,
  "delta": "Hello,"
}

Um evento de conclusão contém a transcrição final do item confirmado.

123456{
  "type": "conversation.item.input_audio_transcription.completed",
  "item_id": "item_003",
  "content_index": 0,
  "transcript": "Hello, how are you?"
}

Os eventos de conclusão podem chegar em uma ordem diferente da dos turnos de fala. Use item_id para associar cada evento de transcrição ao item de entrada confirmado correspondente.

Depois de configurar a sessão de transcrição, use esta função em Go para enviar áudio PCM16 mono a 24 kHz, confirmar o turno e associar a transcrição final ao item confirmado.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43func transcribeTurn(ctx context.Context, conn *realtime.RealtimeConnection, audio []byte) error {
	for start := 0; start < len(audio); start += 9600 {
		end := min(start+9600, len(audio))
		if err := conn.Send(ctx, realtime.RealtimeClientEventParamOfInputAudioBufferAppend(base64.StdEncoding.EncodeToString(audio[start:end]))); err != nil {
			return err
		}
	}
	if err := conn.Send(ctx, realtime.RealtimeClientEventUnionParam{
		OfInputAudioBufferCommit: &realtime.InputAudioBufferCommitEventParam{},
	}); err != nil {
		return err
	}
	// Match the final transcript to the committed item, not event arrival order.
	var itemID string
	for {
		event, err := conn.Recv(ctx)
		if err != nil {
			return err
		}
		switch event.Type {
		case "input_audio_buffer.committed":
			itemID = event.OfInputAudioBufferCommittedEvent.ItemID
		case "conversation.item.input_audio_transcription.delta":
			delta := event.OfConversationItemInputAudioTranscriptionDeltaEvent
			if itemID != "" && delta.ItemID == itemID {
				fmt.Fprintf(os.Stderr, "Partial transcript (%s): %s\n", delta.ItemID, delta.Delta)
			}
		case "conversation.item.input_audio_transcription.completed":
			completed := event.OfConversationItemInputAudioTranscriptionCompletedEvent
			if itemID == "" || completed.ItemID != itemID {
				continue
			}
			fmt.Println("Final transcript:", completed.Transcript)
			return nil
		case "conversation.item.input_audio_transcription.failed":
			if itemID != "" && event.OfConversationItemInputAudioTranscriptionFailedEvent.ItemID == itemID {
				return fmt.Errorf("transcription failed")
			}
		case "error":
			return fmt.Errorf("Realtime API error: %s", event.OfRealtimeErrorEvent.Error.Message)
		}
	}
}

Adicione contexto à transcrição

Adicione contexto quando o áudio contiver vocabulário especializado ou quando houver previsão de fala em mais de um idioma. Para alterar a configuração de transcrição durante uma sessão em andamento, envie outro evento session.update.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22{
  "type": "session.update",
  "session": {
    "type": "transcription",
    "audio": {
      "input": {
        "format": {
          "type": "audio/pcm",
          "rate": 24000
        },
        "transcription": {
          "model": "gpt-live-transcribe",
          "prompt": "A customer support call about a premium plan and account AC-42.",
          "keywords": ["premium plan", "AC-42", "billing"],
          "languages": ["en", "fr"],
          "delay": "low"
        },
        "turn_detection": null
      }
    }
  }
}

• Use prompt para descrever a gravação ou o contexto em que ela foi feita.
• Use keywords para indicar nomes de produtos, siglas e outros termos literais que possam aparecer no áudio.
• Use languages para indicar os idiomas esperados no áudio de entrada.

Os formatos de código de idioma aceitos incluem os seguintes grupos.

• Códigos ISO 639-1, como en, es e fr.
• Alguns códigos ISO 639-3, como eng, spa, yue e cmn.
• Códigos regionais de zh, como zh-cn, zh-tw e zh-hk.

A Realtime API rejeita códigos de idioma não aceitos ou com formato incorreto.

As palavras-chave servem de referência para o modelo, que pode gerar a transcrição sem incluí-las. Mantenha cada palavra-chave em uma única linha, sem <, >, retorno de carro ou avanço de linha. A Realtime API rejeita a atualização da sessão se uma palavra-chave contiver algum desses caracteres ou se prompt exceder o limite de comprimento do modelo.

gpt-live-transcribe usa languages em vez do campo no singular language. Não envie os dois campos.

Transcreva um turno confirmado

Use gpt-transcribe em uma sessão Realtime somente se você precisar que a transcrição comece após a confirmação do turno de áudio ou que o resultado inclua os idiomas detectados. Esse fluxo de trabalho específico exige uma conexão WebSocket.

Quando gpt-transcribe transcreve o áudio de entrada em uma sessão da Realtime API ou é executado em uma sessão dedicada à transcrição, o modelo usa automaticamente os turnos já transcritos como contexto.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18{
  "type": "session.update",
  "session": {
    "type": "transcription",
    "audio": {
      "input": {
        "format": {
          "type": "audio/pcm",
          "rate": 24000
        },
        "transcription": {
          "model": "gpt-transcribe"
        },
        "turn_detection": null
      }
    }
  }
}

Adicione o áudio ao buffer e envie input_audio_buffer.commit. O modelo pode então emitir novos trechos da transcrição antes do evento de conclusão. Esse evento também inclui os idiomas detectados.

1234567{
  "type": "conversation.item.input_audio_transcription.completed",
  "item_id": "item_003",
  "content_index": 0,
  "transcript": "Bonjour, pouvez-vous m'entendre ?",
  "languages": [{ "code": "fr" }]
}

Quando gpt-transcribe não consegue identificar o idioma com confiança, languages é um array vazio. gpt-live-transcribe não retorna previsões de idioma.

Ajuste a latência e a precisão

Na transcrição em tempo real, o atraso influencia a qualidade do texto. Com um atraso menor, o texto parcial pode ficar disponível mais cedo. Um atraso maior dá ao modelo mais contexto de áudio antes de emitir o texto e pode reduzir a taxa de erro de palavras.

Comece definindo audio.input.transcription.delay e faça testes com o áudio real do seu aplicativo. Use estes valores como ponto de partida.

• minimal para as interações mais sensíveis à latência.
• low para legendas ao vivo com baixa latência.
• medium para equilibrar latência e precisão.
• high quando a precisão for mais importante que a exibição imediata.
• xhigh quando o fluxo de trabalho tolerar o maior atraso para que o modelo tenha mais contexto.

O atraso exato em milissegundos pode variar conforme a configuração do modelo. Meça o desempenho com áudio representativo, sem presumir que cada nível tenha um atraso fixo.

Evite escolher a configuração com base apenas em áudio sintético. Faça testes com microfones representativos, áudio de chamadas telefônicas, diferentes sotaques, ruído de fundo, alternância de idiomas na fala, vocabulário especializado e sessões longas.

Trabalhe com níveis de confiança, marcações de tempo e identificação de falantes

gpt-live-transcribe não retorna marcações de tempo por palavra, identificadores de falantes nem pontuações de confiança da transcrição. Se o aplicativo precisar de marcações de tempo ou de identificação de falantes, use um modelo de transcrição de arquivos compatível ou implemente uma alternativa no aplicativo.

Lista de verificação para produção

• Defina uma meta de latência e um limiar de precisão antes de ajustar a configuração.
• Faça testes com áudio real de produção, além de amostras sem ruído.
• Teste cada idioma que o aplicativo precisa atender.
• Inclua números, datas, valores monetários, endereços de e-mail, nomes de produtos e termos especializados no conjunto de avaliação.
• Monitore as transcrições vazias, truncadas e atrasadas separadamente da taxa de erro de palavras.
• Defina como a interface deve atualizar o texto parcial quando eventos delta posteriores corrigirem trechos anteriores.
• Use item_id para ordenar e conciliar as transcrições finais.
• Mantenha uma alternativa para os casos em que o modelo não oferecer suporte a marcações de tempo, identificadores de falantes ou campos de confiança.

Guias relacionados