Skip to main content

Traduction audio et vidéo en temps réel - Qwen

qwen3.5-livetranslate-flash-realtime est un modèle de traduction en temps réel enrichi par la vision, compatible avec 60 langues (29 avec sortie audio et texte, 31 en texte uniquement). Il traite les entrées audio et image provenant de flux vidéo ou de fichiers locaux, exploite le contexte visuel pour améliorer la précision et génère du texte et de l'audio traduits en temps réel.

Essayez une démo en ligne avec le déploiement en un clic via Function Compute .

Fonctionnalités

  • Prise en charge multilingue : traduction entre 60 langues — 29 avec sortie audio et texte, 31 en texte uniquement — dont le chinois, l'anglais, le français, l'allemand, le russe, le japonais, le coréen, l'espagnol, le portugais et l'arabe.
  • Enrichissement visuel : analyse des indices visuels tels que les mouvements des lèvres, les gestes et le texte à l'écran afin d'améliorer la précision de la traduction, particulièrement dans les environnements bruyants ou pour les mots ambigus.
  • Latence de 2,3 secondes : interprétation simultanée avec une latence pouvant descendre à 2,3 secondes.
  • Séparation des locuteurs en temps réel : distingue les locuteurs et leurs propos lorsque plusieurs personnes parlent à tour de rôle, afin de savoir qui a dit quoi.
  • Interprétation simultanée sans perte : prédiction des unités sémantiques pour résoudre les différences d'ordre des mots entre les langues, offrant une qualité comparable à la traduction hors ligne.
  • Voix naturelle : reproduction automatique de l'intonation et de l'émotion de l'audio source.
  • Configuration des mots-clés prioritaires : des mots-clés configurables améliorent la précision de la traduction pour des termes spécifiques.
  • Clonage vocal : clonage de la voix du locuteur pour la sortie traduite. Prise en charge du clonage en temps réel et des profils vocaux pré-clonés.

Procédure

1. Configurer la connexion

Pour une connexion via WebSocket, utilisez les paramètres suivants : Les connexions AOQ, WebRTC et WebSocket sont prises en charge. Pour une intégration côté client donnant la priorité à une latence stable, aux interactions sur réseau dégradé et à la réduction du bruit et de l’écho en communication duplex intégral en temps réel, envisagez d’abord AOQ. Pour comparer les protocoles et choisir, consultez la Référence de l’API.
ParamètreDescription
endpointRégion Chine (Pékin) : wss://WorkspaceId.cn-beijing.maas.aliyuncs.com/api-ws/v1/realtime. Remplacez WorkspaceId par votre ID d'espace de travail réel.Région Singapour : wss://WorkspaceId.ap-southeast-1.maas.aliyuncs.com/api-ws/v1/realtime.Remplacez WorkspaceId par votre ID d'espace de travail réel.
query parameterDéfinissez le paramètre de requête du modèle sur le nom du modèle. Exemple : ?model=qwen3.8-livetranslate-flash-realtime
message headerUtilisez un Bearer Token pour l'authentification : Authorization: Bearer DASHSCOPE_API_KEY
DASHSCOPE_API_KEY correspond à votre clé API obtenue auprès de Model Studio.
Exemple de code de connexion (Python) :
# pip install websocket-client
import json
import websocket
import os

API_KEY=os.getenv("DASHSCOPE_API_KEY")
API_URL = "wss://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/api-ws/v1/realtime?model=qwen3.8-livetranslate-flash-realtime"

headers = [
    "Authorization: Bearer " + API_KEY
]

def on_open(ws):
    print(f"Connected to server: {API_URL}")
def on_message(ws, message):
    data = json.loads(message)
    print("Received event:", json.dumps(data, indent=2))
def on_error(ws, error):
    print("Error:", error)

ws = websocket.WebSocketApp(
    API_URL,
    header=headers,
    on_open=on_open,
    on_message=on_message,
    on_error=on_error
)

ws.run_forever()

2. Configurer la langue, la modalité et la voix

Envoyez session.update, puis attendez session.updated avant l’audio.
  • Langue cible : configurez session.translation.language, avec en (anglais) par défaut. Voir les langues. Avec qwen3.8-livetranslate-flash-realtime, la langue source est détectée automatiquement.
    Avec qwen3.5-livetranslate-flash-realtime, définissez session.input_audio_transcription.language pour indiquer la langue source, ou omettez ce champ pour la détection automatique.
  • Sortie : avec qwen3.8-livetranslate-flash-realtime, configurez session.output_modalities sur ["text"] pour le texte uniquement ou ["text", "audio"] pour le texte et la parole (par défaut). Une langue cible en texte uniquement exige ["text"].
    Avec qwen3.5-livetranslate-flash-realtime, utilisez session.modalities. Les valeurs possibles et la valeur par défaut sont identiques.
  • Transcription source : avec qwen3.8-livetranslate-flash-realtime, elle est toujours activée et ne peut pas être désactivée. La transcription dans la langue source est générée par le modèle LiveTranslate lui-même. Les informations pertinentes dans les images peuvent aider à lever les ambiguïtés de la parole source. Recevez les incréments via conversation.item.input_audio_transcription.delta et le résultat complet via conversation.item.input_audio_transcription.completed.
    Avec qwen3.5-livetranslate-flash-realtime, elle est activée par défaut. Un modèle ASR distinct transcrit l'audio d'entrée. Définissez session.input_audio_transcription.model sur qwen3-asr-flash-realtime pour l’activer ou sur null pour la désactiver. Les incréments sont renvoyés par conversation.item.input_audio_transcription.text et le résultat complet par conversation.item.input_audio_transcription.completed.
  • Audio et voix : avec qwen3.8-livetranslate-flash-realtime, les valeurs par défaut sont une entrée PCM à 16000 Hz, une sortie PCM à 24000 Hz et la voix Tina. Pour transmettre de l'audio Opus, définissez session.audio.input.format.type sur opus. Consultez session.audio.output.voice dans session.created pour connaître la voix. Pour conserver celle du locuteur, voir Clonage vocal.
    Avec qwen3.5-livetranslate-flash-realtime, configurez l’audio avec session.sample_rate, session.input_audio_format et session.output_audio_format, et la voix avec session.voice. La voix par défaut est également Tina.
  • Mots-clés : configurez session.translation.corpus.phrases pour les marques et les traductions imposées. Voir la configuration.
    Il est recommandé de ne pas dépasser 1 000 mots-clés.
{"type": "session.update", "session": {"output_modalities": ["text", "audio"], "translation": {"language": "en"}}}

3. Entrée audio et images

Envoyez des données audio et image encodées en Base64 à l'aide des événements input_audio_buffer.append et input_image_buffer.append. L'entrée audio est obligatoire ; l'entrée image est facultative.
Les images peuvent provenir d'un fichier local ou être capturées en temps réel depuis un flux vidéo.
Avec qwen3.8-livetranslate-flash-realtime, la valeur par défaut est session.audio.input.turn_detection.type = speaker_detection. Envoyez l’audio en continu ; le serveur détecte les limites des énoncés et génère les traductions sans validation manuelle de chaque énoncé. Consultez Identifier les locuteurs pour la configuration et les identifiants de locuteur.
La manière dont le modèle détermine qu'un énoncé est terminé dépend du mode VAD ou du mode manuel configuré via le paramètre turn_detection :
  • Mode VAD (par défaut) : le client envoie en continu des événements input_audio_buffer.append. Lorsque le serveur détecte le début ou la fin de la parole, il retourne respectivement les événements input_audio_buffer.speech_started et input_audio_buffer.speech_stopped, valide automatiquement le tampon audio et déclenche la traduction. Les réponses de traduction sont générées de manière synchrone avec le flux audio et commencent généralement pendant l'entrée audio, sans attendre la fin de la parole.
  • Mode manuel : définissez session.turn_detection sur null. Une fois que le client a terminé d'envoyer un énoncé complet, il envoie un événement input_audio_buffer.commit pour valider le tampon audio. Après que le serveur a retourné un événement input_audio_buffer.committed pour confirmation, il commence automatiquement à générer la réponse de traduction ; le client n'a pas besoin d'envoyer d'autre événement pour déclencher la réponse. Pour effacer l'audio non validé avant la validation, envoyez un événement input_audio_buffer.clear.

4. Recevoir la réponse du modèle

Avec qwen3.8-livetranslate-flash-realtime, recevez les réponses selon les modalités de sortie :
  • Source : cumulez conversation.item.input_audio_transcription.delta ; récupérez le texte complet avec conversation.item.input_audio_transcription.completed.
  • Traduction : utilisez response.text.delta en texte uniquement ou response.audio_transcript.delta en texte et audio. Cumulez les delta de chaque message dans l’ordre reçu, sans écraser le texte précédent.
  • Parole : décodez le champ delta de response.audio.delta depuis Base64, puis lisez ou enregistrez les blocs dans l’ordre.
response.done termine une réponse de traduction ; vérifiez response.status pour connaître le résultat de la génération. La session reste ouverte pour recevoir de l’audio.
  • Sortie des résultats de reconnaissance de la langue source Définissez session.input_audio_transcription.model sur qwen3-asr-flash-realtime. Le serveur retourne alors à la fois la traduction et le résultat de la reconnaissance vocale (texte original) pour l'audio d'entrée. Le serveur retourne les événements suivants :
    • conversation.item.input_audio_transcription.text : diffuse les résultats de reconnaissance en flux continu.
    • conversation.item.input_audio_transcription.completed : retourne le résultat final une fois la reconnaissance terminée.
    • conversation.item.input_audio_transcription.failed : retourne les informations d'erreur en cas d'échec de la reconnaissance.
Les réponses de traduction sont générées de manière synchrone avec le flux audio et ne nécessitent généralement pas d'attendre la fin de la parole (voir la description des modes VAD/Manuel dans la section précédente). Le format de réponse dépend de la modalité de sortie.
  • Sortie texte uniquement Le serveur diffuse le texte traduit incrémentiel (incluant le texte confirmé et le texte prédit provisoire) via des événements response.text.text ; une fois terminé, le texte traduit complet est retourné dans un événement response.text.done. stash contient une traduction provisoire. Il permet d'afficher les sous-titres plus tôt, mais les événements suivants peuvent le réécrire. Selon les besoins de l'application, affichez dans le client la concaténation de text et stash, ou uniquement le texte confirmé de text. Utilisez item_id pour mettre à jour le sous-titre correspondant, puis affichez la traduction complète à la réception de response.text.done.
  • Sortie texte et audio
Le modèle de traduction en temps réel utilise l'événement response.text.text pour la diffusion incrémentielle du texte, ce qui diffère de l'événement response.text.delta utilisé par les modèles Omni (conversation vocale full-duplex). Ces événements ont des structures de champs et des sémantiques différentes — ne les utilisez pas de manière interchangeable.
Associer le texte source à sa traduction Pour afficher les sous-titres source et traduits ensemble, associez-les à l’aide de l’événement conversation.item.created de la traduction. item.id est l’ID de la traduction. Le champ previous_item_id à la racine de l’événement est l’ID du texte source correspondant. Le texte source ou sa traduction peut arriver en premier. Conservez les résultats séparément, associez-les grâce à cette correspondance, puis mettez à jour chaque sous-titre avec son propre item_id. Consultez Association du texte source et de la traduction pour la définition des champs.

5. Terminer la session

Après avoir envoyé tout l'audio, envoyez un événement session.finish, puis attendez que le serveur retourne un événement session.finished avant de fermer la connexion WebSocket. Si vous fermez la connexion WebSocket sans envoyer session.finish, le VAD du serveur ne peut pas détecter la fin du dernier segment de parole. Cela entraîne la perte totale des résultats de traduction pour ce segment, et la connexion peut rester bloquée indéfiniment. Envoyez toujours cet événement avant de vous déconnecter.

Modèles pris en charge

Modèles recommandés

ModèleVersionFenêtre de contexteEntrée max.Sortie max.
(tokens)
qwen3.8-livetranslate-flash-realtimeStable53,24849,1524,096
qwen3.5-livetranslate-flash-realtime
Alias pour qwen3.5-livetranslate-flash-realtime-2026-05-19
Stable53 24849 1524 096
qwen3.5-livetranslate-flash-realtime-2026-05-19Snapshot

Premiers pas

Traduire le microphone en temps réel

  1. Utilisez Python 3.10 ou ultérieur et installez pyaudio :
    • macOS
    • Debian/Ubuntu
    • CentOS
    • Windows
    brew install portaudio && pip install pyaudio
    
    Installez la dépendance WebSocket : pip install websocket-client.
  2. Définissez la variable d’environnement ci-dessous. La clé API et l’espace de travail doivent appartenir à la région de l’URL de connexion : Renseignez WorkspaceId dans le code ci-dessous.
  3. Enregistrez le code ci-dessous dans livetranslate_client.py, exécutez python livetranslate_client.py, puis parlez dans le microphone.
L’exemple utilise qwen3.8-livetranslate-flash-realtime pour traduire le microphone en anglais, afficher le texte et lire la parole traduite en temps réel. L’entrée est du PCM mono, 16 bits, 16000 Hz ; la lecture est du PCM mono, 16 bits, 24000 Hz. Appuyez sur Ctrl+C pour arrêter l’enregistrement. L’exemple envoie session.finish, reçoit et lit les derniers résultats, puis ferme la connexion après session.finished. Utilisez un casque pour éviter que la parole traduite soit enregistrée à nouveau.
import base64
import json
import os
import signal
import threading
import time

import pyaudio
import websocket

model = "qwen3.8-livetranslate-flash-realtime"
api_key = os.environ["DASHSCOPE_API_KEY"]
url = (
    "wss://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com"
    f"/api-ws/v1/realtime?model={model}"
)
stop_recording = False
send_errors = []
ws = None
audio = None
input_stream = None
output_stream = None
sender = None
previous_sigint_handler = None


def receive():
    event = json.loads(ws.recv())
    if event.get("type") == "error" or event.get("code"):
        raise RuntimeError(event)
    return event


def stop_input(signum, frame):
    global stop_recording
    stop_recording = True


def send_audio():
    try:
        while not stop_recording:
            chunk = input_stream.read(1600)
            ws.send(json.dumps({
                "type": "input_audio_buffer.append",
                "audio": base64.b64encode(chunk).decode("ascii"),
            }))
    except Exception as error:
        send_errors.append(error)
    finally:
        try:
            ws.send(json.dumps({"type": "session.finish"}))
        except Exception as error:
            send_errors.append(error)
            ws.close()


def receive_translation():
    while True:
        event = receive()
        event_type = event.get("type")
        if event_type in ("response.text.delta", "response.audio_transcript.delta"):
            print(event["delta"], end="", flush=True)
        elif event_type == "response.audio.delta":
            output_stream.write(base64.b64decode(event["delta"]))
        elif event_type == "response.done":
            if event["response"]["status"] != "completed":
                raise RuntimeError(event["response"])
            print()
        elif event_type == "session.finished":
            return


try:
    ws = websocket.create_connection(
        url, header={"Authorization": f"Bearer {api_key}"}, timeout=30
    )
    while receive().get("type") != "session.created":
        pass
    ws.send(json.dumps({
        "type": "session.update",
        "session": {
            "output_modalities": ["text", "audio"],
            "translation": {"language": "en"},
        },
    }))
    while receive().get("type") != "session.updated":
        pass
    audio = pyaudio.PyAudio()
    input_stream = audio.open(
        format=pyaudio.paInt16, channels=1, rate=16000,
        input=True, frames_per_buffer=1600,
    )
    output_stream = audio.open(
        format=pyaudio.paInt16, channels=1, rate=24000, output=True,
    )
    print("Parlez dans le microphone. Ctrl+C arrête l’enregistrement et attend la fin de la traduction.")
    previous_sigint_handler = signal.signal(signal.SIGINT, stop_input)
    sender = threading.Thread(target=send_audio, daemon=True)
    sender.start()
    receive_translation()
    stop_recording = True
    sender.join()
    if send_errors:
        raise send_errors[0]
except Exception:
    if send_errors:
        raise send_errors[0]
    raise
finally:
    stop_recording = True
    if ws is not None:
        ws.close()
    if sender is not None:
        sender.join()
    for stream in (input_stream, output_stream):
        if stream is not None:
            stream.stop_stream()
            stream.close()
    if audio is not None:
        audio.terminate()
    if previous_sigint_handler is not None:
        signal.signal(signal.SIGINT, previous_sigint_handler)

Configurer les mots-clés prioritaires

L'ajout de mots-clés prioritaires peut améliorer la précision de la traduction lorsqu'une formulation fixe est requise ou qu'il faut distinguer des homophones. Par exemple :
  • Formulation fixe : le slogan d'Alibaba Cloud « Calculer pour une valeur incalculable. » a pour formulation anglaise convenue « Computing, for the value beyond computation. ». Les mots et leur ordre doivent être conservés.
  • Noms de marque homophones : Qoder se prononce comme le mot anglais courant coder. Si l'orateur désigne le produit Qoder, la traduction doit conserver l'orthographe de la marque.
Le tableau suivant compare les sorties de deux tests. Dans chaque paire, l'audio est identique et seule la configuration des mots-clés prioritaires change.
Contenu de l'audio d'entréeSans mots-clés prioritairesAvec mots-clés prioritaires
Calculer pour une valeur incalculable.Calculated for an incalculable value.Computing, for the value beyond computation.
Qoder est une plateforme agentique pour le travail réel.Kode is an agentic platform for real-world work.Qoder is an agentic platform for real-world work.

Configuration

Configurez session.translation.corpus.phrases avec des paires clé-valeur associant les mots ou expressions de la langue source à leur traduction souhaitée. Dans la première requête session.update de la section Premiers pas, intégrez l'objet translation ci-dessous à l'objet session existant. Conservez la modalité de sortie, la voix et les autres réglages de la session.
{
  "event_id": "configure-hotwords",
  "type": "session.update",
  "session": {
    "translation": {
      "language": "en",
      "corpus": {
        "phrases": {
          "Calculer pour une valeur incalculable.": "Computing, for the value beyond computation.",
          "Qoder": "Qoder"
        }
      }
    }
  }
}
Configurez la session avant d'envoyer l'audio. Attendez l'événement session.updated du serveur avant d'envoyer des événements input_audio_buffer.append.

Identifier les locuteurs

qwen3.8-livetranslate-flash-realtime peut identifier les différents locuteurs et les désigner par speaker_id. Associez cet identifiant aux textes source et traduit pour afficher les sous-titres par locuteur. Conservez speaker_detection par défaut ou configurez-le explicitement dans session.update. threshold sert à distinguer le silence de la parole valide. Les sons en dessous du seuil sont filtrés et ne sont pas transmis au modèle. Ce seuil est fixé à 0.5.
{"type": "session.update", "session": {"audio": {"input": {"turn_detection": {"type": "speaker_detection", "threshold": 0.5}}}}}
  1. Enregistrez speaker_id et l’item_id source de input_audio_buffer.speech_started.
  2. Lisez la source du même item_id dans conversation.item.input_audio_transcription.delta.
  3. Dans conversation.item.created de la traduction, associez item.id au previous_item_id situé au niveau supérieur de l’événement.
  4. Avec l’item_id de chaque incrément traduit, retrouvez la source et le locuteur pour actualiser le sous-titre.
Dans l’exemple avec microphone des premiers pas, placez les variables et fonctions ci-dessous avant def receive_translation():. Dans cette fonction, appelez handle_speaker_event(event) juste après event = receive() et remplacez le print(event["delta"], end="", flush=True) d’origine par pass pour confier toute la sortie des sous-titres au fragment ci-dessous. Le fragment affiche l’identifiant, la source et la traduction à chaque mise à jour, pour afficher les sous-titres par locuteur. Conservez le traitement audio et la fin de session.
speaker_by_source = {}
source_by_translation = {}
source_text = {}
translation_text = {}


def show_subtitle(translation_id):
    source_id = source_by_translation.get(translation_id)
    if source_id not in speaker_by_source or translation_id not in translation_text:
        return
    print({
        "speaker_id": speaker_by_source[source_id],
        "source": source_text.get(source_id, ""),
        "translation": translation_text[translation_id],
    })


def handle_speaker_event(event):
    event_type = event.get("type")
    if event_type in ("response.text.delta", "response.audio_transcript.delta"):
        item_id = event["item_id"]
        translation_text[item_id] = translation_text.get(item_id, "") + event["delta"]
        show_subtitle(item_id)
        return
    if event_type == "conversation.item.created":
        item = event["item"]
        if any(part.get("type") == "input_audio" for part in item.get("content", [])):
            return
        source_id = event.get("previous_item_id")
        if item.get("role") == "assistant" and source_id is not None:
            source_by_translation[item["id"]] = source_id
            show_subtitle(item["id"])
        return
    if event_type == "input_audio_buffer.speech_started" and "speaker_id" in event:
        source_id = event["item_id"]
        speaker_by_source[source_id] = event["speaker_id"]
    elif event_type == "conversation.item.input_audio_transcription.delta":
        source_id = event["item_id"]
        source_text[source_id] = source_text.get(source_id, "") + event["delta"]
    elif event_type == "conversation.item.input_audio_transcription.completed":
        source_id = event["item_id"]
        source_text[source_id] = event["transcript"]
    else:
        return
    for translation_id, mapped_source in source_by_translation.items():
        if mapped_source == source_id:
            show_subtitle(translation_id)
Définitions : identifiants de locuteur et association source/traduction.

Améliorer la traduction avec des images

Les modèles Qwen de traduction en temps réel prennent en charge les images pour lever les ambiguïtés des homonymes et reconnaître les noms propres peu courants lors de la traduction. N’envoyez pas plus de 2 images par seconde. Téléchargez les exemples d'images suivants : medical mask.png, masquerade mask.png Réutilisez le microphone et la connexion des premiers pas :
  1. Installez Pillow : pip install Pillow.
  2. Définissez translation.language sur fr, puis dites « What is mask? » dans le microphone lors de l’exécution.
  3. Dans l’exemple avec microphone, placez le chargement d’image ci-dessous avant def send_audio(): et remplacez send_audio() par cette version. Elle réutilise input_stream, stop_recording, ws, send_errors et les imports existants.
import io
from PIL import Image

IMAGE_PATH = "medical-mask.png"
# IMAGE_PATH = "masquerade-mask.png"
with Image.open(IMAGE_PATH) as image:
    buffer = io.BytesIO()
    image.convert("RGB").save(buffer, format="JPEG")
image_bytes = buffer.getvalue()
if len(image_bytes) > 500_000:
    raise ValueError("JPEG > 500 KB")
image_b64 = base64.b64encode(image_bytes).decode("ascii")


def send_audio():
    try:
        last_image_time = None
        while not stop_recording:
            chunk = input_stream.read(1600)
            ws.send(json.dumps({
                "type": "input_audio_buffer.append",
                "audio": base64.b64encode(chunk).decode("ascii"),
            }))
            now = time.monotonic()
            if last_image_time is None or now - last_image_time >= 0.5:
                ws.send(json.dumps({
                    "type": "input_image_buffer.append",
                    "image": image_b64,
                }))
                last_image_time = now
    except Exception as error:
        send_errors.append(error)
    finally:
        try:
            ws.send(json.dumps({"type": "session.finish"}))
        except Exception as error:
            send_errors.append(error)
            ws.close()
L’audio et les images sont entrelacés, avec au plus une image toutes les 0,5 seconde. Essayez chaque image et vérifiez si « mask » est traduit par l’objet correspondant. Après Ctrl+C, l’exemple arrête l’enregistrement, demande la fin de session et reçoit les derniers résultats.

Clonage vocal

Le modèle clone la voix du locuteur à partir de l'audio d'entrée et l'utilise pour la sortie traduite. Utilisez un profil vocal pré-cloné ou laissez le serveur effectuer le clonage en temps réel. Cette fonctionnalité est utile pour l'interprétation de conférence, le streaming en direct et le doublage vidéo. Clonage en temps réel : avec qwen3.8-livetranslate-flash-realtime comme avec qwen3.5-livetranslate-flash-realtime, le clonage de la voix à partir de l’audio pendant la traduction ne comporte aucun frais de clonage supplémentaire. Les appels au modèle restent facturés selon les tokens utilisés. Créer une voix à l’avance : utilisez l’API de clonage de voix pour créer une voix à l’avance. Le coût est de $0.01 par voix. Les demandes de création échouées ne sont pas facturées. Pour les régions, le nombre d’utilisations et la durée de validité du quota gratuit, consultez Facturation. La traduction avec une voix créée reste facturée selon la consommation de tokens du modèle. Définissez les paramètres suivants dans session.update pour activer le clonage vocal :
  • session.enable_voice_clone : définissez sur true pour activer le clonage vocal.
  • session.voice_clone_options.frequency : contrôle le moment où le clonage vocal se produit. Valeurs acceptées :
    • never : utilisez une voix créée au préalable, sans nouvelle extraction pendant cette session. Définissez session.voice sur votre ID de voix clonée.
    • once : extrayez la voix une fois au début de la session, puis réutilisez-la pour les traductions suivantes de cette session. « Une fois » désigne l’extraction, pas une unique sortie audio. Adapté aux présentations avec un seul locuteur ; définissez session.voice sur default.
    • always : extrayez la voix avant chaque réponse audio traduite pour suivre les changements de locuteur. Adapté aux conversations à plusieurs ; définissez session.voice sur default.
  • session.voice : spécifie la voix de sortie. La valeur dépend du paramètre frequency :
    • Définir sur default : à utiliser lorsque frequency est défini sur once ou always. Clone la voix du locuteur à partir de l'audio d'entrée. Une voix par défaut est utilisée jusqu'à la fin du clonage.
      • Définissez un ID de voix clonée personnalisée, par exemple qwen-translate-vc-xxx-yyy-zzz, avec frequency défini sur never. Préparez la voix à l’avance avec l’API de clonage de voix, en définissant target_model sur le modèle de traduction utilisé.
Lorsque frequency est défini sur once ou always , le paramètre voice doit être défini sur default . Toute autre valeur entraîne le retour d'une erreur par le serveur.

Exemples de configuration du clonage vocal

Avec qwen3.8-livetranslate-flash-realtime, remplacez la configuration session.update de l’exemple de ce modèle dans le démarrage rapide par celle adaptée à votre scénario.
Avec qwen3.5-livetranslate-flash-realtime, remplacez session.output_modalities par session.modalities dans les exemples. Les autres paramètres de clonage sont identiques. Indiquez ce modèle dans le paramètre de connexion model et traitez ses événements de réponse comme décrit dans Recevoir les réponses du modèle.
Profil vocal pré-cloné (pour les scénarios nécessitant une voix fixe) :
{
    "type": "session.update",
    "session": {
        "output_modalities": ["text","audio"],
        "voice": "qwen-translate-vc-xxx-yyy-zzz",
        "translation": {
            "language": "en"
        },
        "enable_voice_clone": true,
        "voice_clone_options": {
            "frequency": "never"
        }
    }
}
Réutiliser une voix dans la session actuelle (un seul locuteur) :
{
    "type": "session.update",
    "session": {
        "output_modalities": ["text","audio"],
        "voice": "default",
        "translation": {
            "language": "en"
        },
        "enable_voice_clone": true,
        "voice_clone_options": {
            "frequency": "once"
        }
    }
}
Suivre la voix du locuteur actuel (plusieurs locuteurs) :
{
    "type": "session.update",
    "session": {
        "output_modalities": ["text","audio"],
        "voice": "default",
        "translation": {
            "language": "en"
        },
        "enable_voice_clone": true,
        "voice_clone_options": {
            "frequency": "always"
        }
    }
}

Déploiement en un clic sur Function Compute

Pour déployer l'application :
  1. Ouvrez le modèle Function Compute, saisissez votre clé API, puis cliquez sur Create and Deploy Default Environment pour tester l'application.
  2. Patientez environ une minute. Dans Environment Details > Environment Context, récupérez l'endpoint, changez le protocole de http à https (par exemple, https://qwen-livetranslate-flash-realtime-intl.fcv3.xxx.ap-southeast-1.fc.devsapp.net/), et ouvrez l'URL dans un navigateur pour interagir avec le modèle.
    Cet endpoint utilise un certificat auto-signé et est destiné uniquement à des tests temporaires. Votre navigateur affichera un avertissement de sécurité lors de votre première visite. Ce comportement est normal. N'utilisez pas cet endpoint dans un environnement de production. Pour continuer, suivez les instructions à l'écran (par exemple, cliquez sur Advanced → Proceed to (unsafe)).
Si vous êtes invité à configurer les autorisations Resource Access Management, suivez les instructions à l'écran.
Pour consulter le code source du projet, accédez à Resource Information > Function Resources .
Function Compute et Model Studio offrent tous deux un quota gratuit pour les nouveaux utilisateurs, suffisant pour le débogage de base. Une fois le quota gratuit épuisé, la facturation au paiement à l'utilisation s'applique.

Flux d'interaction

Voici les principales étapes d’interaction avec qwen3.8-livetranslate-flash-realtime :
ÉtapeClientServeur
ConnexionURL et authentificationsession.created
Configurationsession.updatesession.updated, ou error
Entréeinput_audio_buffer.append en continu ; images facultativesIdentifiants de locuteur et transcription source
RéceptionCumuler le texte, décoder l’audioIncréments ; response.done termine une réponse
FinArrêter l’entrée, envoyer session.finish, continuer la réceptionsession.finished ; fermer puis terminer la lecture audio
La traduction repose sur un modèle WebSocket piloté par événements. La détermination des limites de parole dépend du mode VAD ou du mode manuel (voir 3. Entrée audio et images). Le tableau ci-dessous se base sur le mode VAD (par défaut) et indique les différents événements serveur en mode manuel.
Cycle de vieÉvénement clientÉvénement serveur
Initialisation de la sessionsession.update
Configuration de la session
session.created
Session créée
session.updated
Configuration de la session mise à jour
Entrée audio utilisateurinput_audio_buffer.append
Ajout d'audio au tampon
input_image_buffer.append
Ajout d'image au tampon
input_audio_buffer.commit
(Mode manuel uniquement) Validation du tampon audio
Mode VAD :input_audio_buffer.speech_started
Début de parole détecté
input_audio_buffer.speech_stopped
Fin de parole détectée ; le serveur valide automatiquement le tampon audio
Mode manuel :input_audio_buffer.committed
Retourné après l'envoi de input_audio_buffer.commit par le client, confirmant la validation du tampon audio
Sortie audio serveurAucunresponse.created
Signale que le serveur commence à générer une réponse.
response.output_item.added
Signale qu'un nouvel élément de sortie est disponible.
conversation.item.created
Un nouvel élément de message est créé dans la conversation.
response.content_part.added
Signale qu'une nouvelle partie de contenu a été ajoutée au message de l'assistant.
response.text.text
Texte traduit incrémentiel en modalité texte uniquement
response.audio_transcript.text
Texte traduit incrémentiel en modalité audio+texte
response.audio.delta
Contient un fragment incrémentiel de l'audio synthétisé.
response.text.done
Texte de traduction terminé en modalité texte uniquement
response.audio_transcript.done
Texte de traduction terminé en modalité audio+texte
response.audio.done
Signale que l'audio synthétisé est terminé.
response.content_part.done
Signale qu'une partie de contenu texte ou audio du message de l'assistant est terminée.
response.output_item.done
Signale que l'ensemble de l'élément de sortie du message de l'assistant est terminé.
response.done
Signale que l'ensemble de la réponse est terminé.
Clôture de la sessionsession.finish
Notifie au serveur que l'entrée audio est terminée
session.finished
Traitement serveur terminé ; session clôturée
Après avoir envoyé tout l'audio, envoyez un événement session.finish et attendez session.finished avant de fermer la connexion WebSocket. Si vous fermez la connexion sans envoyer session.finish, le serveur ne peut pas savoir que l'entrée audio est terminée, et les résultats de reconnaissance et de traduction du dernier segment de parole seront perdus.

API

Pour le déroulement de la connexion AOQ et les exemples, consultez Connexion AOQ. Pour le choix du protocole et les liens de référence, consultez la Référence de l’API.

Facturation

Qwen3.8-LiveTranslate-Flash-Realtime / Qwen3.5-LiveTranslate-Flash-Realtime
  • Audio : 7 tokens par seconde d'audio d'entrée ; 12,5 tokens par seconde d'audio de sortie. Avec la détection vocale côté serveur, la durée d’audio d’entrée est celle de l’audio transmis au modèle après filtrage. Les silences supprimés par ce filtrage sont exclus de cette durée. Consultez le nombre réel de tokens audio d’entrée dans response.usage.input_tokens_details.audio_tokens de l’événement response.done.
  • Image : chaque bloc de 32×32 pixels consomme 0,5 token.
Tarifs : Liste des modèles. Clonage en temps réel : avec qwen3.8-livetranslate-flash-realtime comme avec qwen3.5-livetranslate-flash-realtime, le clonage de la voix à partir de l’audio pendant la traduction ne comporte aucun frais de clonage supplémentaire. Les appels au modèle restent facturés selon les tokens utilisés. Créer une voix à l’avance : utilisez l’API de clonage de voix pour créer une voix à l’avance. Le coût est de $0.01 par voix. Les demandes de création échouées ne sont pas facturées. Pour les régions, le nombre d’utilisations et la durée de validité du quota gratuit, consultez Facturation. La traduction avec une voix créée reste facturée selon la consommation de tokens du modèle.

Langues prises en charge

Utilisez les codes de langue suivants pour spécifier les langues source et cible.
Certaines langues cibles ne prennent en charge que le texte.

Code de langue

Langue

Sortie

zh

Chinois

Audio + texte

en

Anglais

Audio + texte

ar

Arabe

Audio + texte

de

Allemand

Audio + texte

fr

Français

Audio + texte

es

Espagnol

Audio + texte

pt

Portugais

Audio + texte

id

Indonésien

Audio + texte

it

Italien

Audio + texte

ko

Coréen

Audio + texte

ru

Russe

Audio + texte

th

Thaï

Audio + texte

vi

Vietnamien

Audio + texte

ja

Japonais

Audio + texte

tr

Turc

Audio + texte

hi

Hindi

Audio + texte

ms

Malais

Audio + texte

nl

Néerlandais

Audio + texte

ur

Ourdou

Audio + texte

nb

Norvégien bokmål

Audio + texte

sv

Suédois

Audio + texte

da

Danois

Audio + texte

he

Hébreu

Audio + texte

fi

Finnois

Audio + texte

pl

Polonais

Audio + texte

is

Islandais

Audio + texte

cs

Tchèque

Audio + texte

fil

Filipino

Audio + texte

fa

Persan

Audio + texte

yue

Cantonais

Texte

el

Grec

Texte

af

Afrikaans

Texte

ast

Asturien

Texte

be

Biélorusse

Texte

bg

Bulgare

Texte

bn

Bengali

Texte

bs

Bosniaque

Texte

ca

Catalan

Texte

ceb

Cebuano

Texte

et

Estonien

Texte

gl

Galicien

Texte

gu

Gujarati

Texte

hr

Croate

Texte

hu

Hongrois

Texte

jv

Javanais

Texte

kk

Kazakh

Texte

kn

Kannada

Texte

ky

Kirghize

Texte

lv

Letton

Texte

mk

Macédonien

Texte

ml

Malayalam

Texte

mr

Marathi

Texte

pa

Pendjabi

Texte

ro

Roumain

Texte

sk

Slovaque

Texte

sl

Slovène

Texte

sw

Swahili

Texte

tg

Tadjik

Texte

az

Azerbaïdjanais

Texte

uk

Ukrainien

Texte

Voix prises en charge

Pour consulter les voix prises en charge et les valeurs correspondantes du paramètre voice, reportez-vous à la Liste des voix.

Questions fréquentes

La connexion est-elle facturée si personne ne parle ?

Le fait de garder la connexion ouverte n'est pas facturé. La prise en compte du silence envoyé dans l'entrée audio dépend du mode utilisé :
  • Détection vocale côté serveur : Le silence filtré n'est pas comptabilisé comme entrée audio.
  • Mode Manual : Le silence explicitement validé par le client est comptabilisé comme entrée audio.
Le nombre de jetons d'entrée audio figure dans response.done, sous response → usage → input_tokens_details → audio_tokens. Le modèle est facturé selon les jetons d'entrée et de sortie. Consultez Facturation pour les tarifs et le calcul.

Comment migrer de Gummy vers LiveTranslate ?

gummy-realtime-v1 et qwen3.8-livetranslate-flash-realtime utilisent des protocoles différents. Outre le nom du modèle, modifiez le code qui ouvre la connexion, envoie le son, reçoit les traductions et termine la session. Cet exemple utilise le SDK Python pour afficher des sous-titres en anglais. Conservez votre audio PCM mono 16 bits à 16 kHz et modifiez ces quatre appels.

Étape

Gummy

LiveTranslate

Connexion et configuration

TranslationRecognizerRealtime(..., translation_target_languages=["en"])

start()

client.audio.realtime.connect(model="qwen3.8-livetranslate-flash-realtime")

session.update_session(output_modalities=["text"], translation_params={"language": "en"})

Configurez la session après la connexion. Attendez session.updated avant d’envoyer le son.

Envoi audio

send_audio_frame(data)

session.append_audio(data)

Affichage des sous-titres

on_event(..., translation_result, ...)

translation_result.get_translation("en").text

session.events()

response.text.delta

Ajoutez le contenu de chaque champ delta au sous-titre.

Fin de session

stop()

session.end_session()

Continuez à recevoir les sous-titres et fermez la connexion après session.finished.

Installez DashScope 2.0.2. audioéfinissez DASHSCOPE_API_KEY et DASHSCOPE_WORKSPACE avec la clé API et l’identifiant de l’espace de travail de la région de Pékin. Enregistrez le code dans subtitles.py et exécutez python subtitles.py input.wav avec un fichier WAV PCM mono 16 bits à 16 kHz.
import os
import sys
import time
import wave
from concurrent.futures import ThreadPoolExecutor

import dashscope


def send_audio(session, recording):
    while chunk := recording.readframes(1600):
        session.append_audio(chunk)
        time.sleep(len(chunk) / 32000)
    session.end_session()


def translate(path):
    client = dashscope.Client(api_key=os.environ["DASHSCOPE_API_KEY"],
                              workspace=os.environ["DASHSCOPE_WORKSPACE"],
                              region="cn-beijing")
    with wave.open(path, "rb") as recording:
        if (recording.getframerate(), recording.getnchannels(), recording.getsampwidth()) != (16000, 1, 2):
            raise ValueError("Expected a 16 kHz mono 16-bit PCM WAV file")
        with client.audio.realtime.connect(model="qwen3.8-livetranslate-flash-realtime", timeout=30) as session:
            events = session.events()
            for event in events:
                if event["type"] == "session.created":
                    session.update_session(output_modalities=["text"], translation_params={"language": "en"})
                elif event["type"] == "session.updated":
                    break
                elif event["type"] == "error":
                    raise RuntimeError(event["error"])
            else:
                raise RuntimeError("Session closed before configuration completed")

            with ThreadPoolExecutor(max_workers=1) as pool:
                sender = pool.submit(send_audio, session, recording)
                try:
                    for event in events:
                        kind = event["type"]
                        if kind == "response.text.delta":
                            print(event["delta"], end="", flush=True)
                        elif kind == "response.text.done":
                            print(flush=True)
                        elif kind == "response.done" and event["response"]["status"] != "completed":
                            raise RuntimeError(event["response"].get("status_details"))
                        elif kind == "error":
                            raise RuntimeError(event["error"])
                        elif kind == "session.finished":
                            break
                    else:
                        raise RuntimeError("Session closed before session.finished")
                except BaseException:
                    session.close()
                    raise
                sender.result()


if __name__ == "__main__":
    translate(sys.argv[1])
Pour une connexion WebSocket directe, apportez les trois modifications suivantes. Voir Premiers pas pour un exemple complet.
  • Adresse : remplacez /api-ws/v1/inference par /api-ws/v1/realtime?model=qwen3.8-livetranslate-flash-realtime.
  • Audio : remplacez les trames binaires par des événements JSON input_audio_buffer.append et placez le PCM encodé en Base64 dans le champ audio.
  • Traduction : remplacez result-generated par response.text.delta et ajoutez chaque fragment delta au sous-titre. Après l’envoi de l’audio, envoyez session.finish et attendez session.finished avant de fermer la connexion.

Comment reprendre la traduction après une déconnexion ?

Si vous recevez no semantic result after merged audio exceeded 60s et que la connexion WebSocket se ferme, créez une nouvelle session pour reprendre la traduction :
  1. Arrêtez d'envoyer de l'audio sur l'ancienne connexion.
  2. Reconnectez-vous et envoyez session.update pour rétablir la langue cible, les modalités de sortie et les autres paramètres.
  3. Attendez session.updated, puis reprenez l'envoi de l'audio.
Si une erreur de paramètre survient et que la connexion reste ouverte, corrigez la requête et continuez à utiliser cette connexion. Avec dashscope.Client(), reprenez également la réception des événements.