Transcription en temps réel

Utilisez la transcription en temps réel lorsque votre application doit convertir en texte le son d’un microphone, d’un appel ou d’un autre flux audio en direct, sans réponse vocale de l’assistant. Le modèle recommandé renvoie des fragments de transcription au fil de la parole, puis la transcription finale de chaque tour de parole lorsque votre application le valide.

Commencez avec gpt-live-transcribe. Si vous disposez déjà d’un enregistrement audio, utilisez la transcription de fichiers. Pour comparer les workflows, consultez la présentation de la transcription.

Créez une session de transcription

Pour transcrire un flux audio côté serveur via WebSocket avec une clé API standard, connectez-vous à wss://api.openai.com/v1/realtime?intent=transcription. Utilisez l’en-tête d’authentification indiqué dans le guide WebSocket, mais omettez model dans l’URL. L’URL du guide qui précise le modèle crée une session de conversation incompatible avec la mise à jour de transcription ci-dessous.

Une fois la connexion établie, envoyez session.update avec type: "transcription" et sélectionnez gpt-live-transcribe dans la configuration de la session. Pour l’audio provenant d’un navigateur, consultez le guide 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
      }
    }
  }
}

Cet exemple utilise un flux audio PCM à 24 kHz. Dans les sessions de transcription avec gpt-live-transcribe, omettez audio.input.turn_detection ou attribuez-lui la valeur null. Le modèle ne prend en charge ni server_vad ni semantic_vad. Pour connaître toutes les options de configuration, consultez la référence des sessions Realtime.

Envoyez l’audio en continu

Envoyez les blocs audio avec input_audio_buffer.append :

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

Envoyez input_audio_buffer.commit à la fin de chaque tour de parole pour recevoir sa transcription finale :

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

Utilisez la détection d’activité vocale (VAD) côté client pour repérer la fin du tour de parole, puis envoyez input_audio_buffer.commit.

Traitez les événements de transcription

Écoutez les événements qui transmettent les fragments successifs de la transcription et ceux qui en signalent la fin :

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);
  }
});

Un événement delta contient le fragment de texte qui vient d’être transcrit :

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

Un événement de fin contient la transcription finale de l’élément validé :

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

Les événements de fin peuvent arriver dans un ordre différent de celui des tours de parole. Utilisez item_id pour associer chaque événement de transcription à l’élément d’entrée validé correspondant.

Après avoir configuré une session de transcription, utilisez cette fonction Go pour envoyer de l’audio mono PCM16 à 24 kHz, valider le tour de parole et associer la transcription finale à l’élément validé :

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)
		}
	}
}

Ajoutez du contexte à la transcription

Ajoutez du contexte si vous vous attendez à entendre du vocabulaire spécialisé ou plusieurs langues. Pour modifier la configuration de la transcription en cours de session, envoyez un nouvel événement 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
      }
    }
  }
}

• Utilisez prompt pour décrire l’enregistrement ou le contexte dans lequel il a été réalisé.
• Utilisez keywords pour indiquer la forme exacte des noms de produits, des acronymes et des autres termes susceptibles de figurer dans l’enregistrement.
• Utilisez languages pour indiquer les langues attendues dans le flux audio.

Les formats de codes de langue pris en charge comprennent :

• Les codes ISO 639-1, comme en, es et fr.
• Certains codes ISO 639-3, comme eng, spa, yue et cmn.
• Les codes régionaux de la langue zh, comme zh-cn, zh-tw et zh-hk.

La Realtime API rejette les codes de langue non pris en charge ou mal formés.

Les mots-clés guident le modèle sans l’obliger à les inclure dans la transcription. Écrivez chaque mot-clé sur une seule ligne, sans y inclure <, >, de retour chariot ni de saut de ligne. La Realtime API rejette la mise à jour de la session si un mot-clé contient l’un de ces caractères ou si prompt dépasse la longueur maximale autorisée par le modèle.

gpt-live-transcribe utilise languages à la place du champ singulier language. N’envoyez pas les deux champs.

Transcrivez un tour de parole validé

Utilisez gpt-transcribe dans une session Realtime uniquement si la transcription doit commencer après la validation du tour de parole ou si vous avez besoin de récupérer les langues détectées. Ce workflow nécessite une connexion WebSocket.

Lorsque gpt-transcribe transcrit l’audio entrant dans une session de la Realtime API ou s’exécute dans une session dédiée à la transcription, il utilise automatiquement les tours de parole déjà transcrits comme contexte.

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
      }
    }
  }
}

Ajoutez les données audio au tampon, puis envoyez input_audio_buffer.commit. Le modèle peut alors émettre des fragments de transcription avant l’événement de fin. Cet événement indique également les langues détectées :

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

Lorsque gpt-transcribe ne parvient pas à identifier la langue de manière fiable, languages est un tableau vide. gpt-live-transcribe ne renvoie aucune prédiction sur la langue détectée.

Ajustez la latence et la précision

La transcription en continu implique un compromis entre latence et qualité de transcription. Un délai plus court peut permettre d’obtenir le texte partiel plus tôt. Un délai plus long donne au modèle davantage de contexte audio avant qu’il ne produise du texte et peut réduire le taux d’erreur sur les mots.

Commencez par définir audio.input.transcription.delay et testez ce réglage avec vos propres enregistrements. Pour vos premiers essais, utilisez :

• minimal pour les interactions les plus sensibles à la latence ;
• low pour les sous-titres en direct à faible latence ;
• medium pour un compromis entre latence et précision ;
• high lorsque la précision prime sur l’affichage immédiat ;
• xhigh lorsque votre workflow peut tolérer le délai le plus long pour fournir davantage de contexte au modèle.

Le délai exact en millisecondes peut varier selon la configuration du modèle. Mesurez-le avec des enregistrements représentatifs au lieu de supposer que chaque niveau correspond à une durée fixe.

Ne vous fiez pas uniquement à de l’audio synthétique pour choisir un réglage. Faites des essais avec des microphones représentatifs, des enregistrements téléphoniques, différents accents, du bruit de fond, des passages d’une langue à l’autre, du vocabulaire spécialisé et des sessions longues.

Gérez les scores de confiance, les horodatages et l’identification des locuteurs

gpt-live-transcribe ne fournit ni horodatages par mot, ni étiquettes de locuteur, ni scores de confiance pour la transcription. Si votre application nécessite des horodatages ou des étiquettes de locuteur, utilisez un modèle de transcription de fichiers compatible ou prévoyez une solution de repli dans votre application.

Vérifications avant la mise en production

• Définissez une latence cible et un seuil de précision avant d’ajuster les réglages.
• Testez avec des enregistrements issus de la production, en complément des échantillons sans bruit.
• Testez chaque langue cible.
• Incluez dans votre jeu d’évaluation des nombres, des dates, des montants en devises, des adresses e-mail, des noms de produits et des termes propres à votre domaine.
• Suivez les transcriptions vides, tronquées ou reçues en retard séparément du taux d’erreur sur les mots.
• Déterminez comment votre interface doit mettre à jour le texte partiel lorsqu’un nouveau fragment corrige du texte déjà affiché.
• Utilisez item_id pour remettre les transcriptions finales dans l’ordre et les associer aux éléments correspondants.
• Prévoyez une solution de repli si les horodatages, les étiquettes de locuteur ou les champs de confiance ne sont pas pris en charge.

Guides associés