Skip to main content

Qwen-Audio-ASR-Message Guide de connexion WebSocket

Cette rubrique décrit l'endpoint du service, les en-têtes de requête et le flux d'interaction pour accéder au service de reconnaissance vocale en temps réel Qwen-Audio-ASR-Message via une connexion WebSocket.

Endpoint du service

L'URL WebSocket est fixe :
  • Singapore
  • China (Beijing)
wss://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/api-ws/v1/inferenceRemplacez {WorkspaceId} par votre Workspace ID réel.
Alibaba Cloud Model Studio a publié des domaines spécifiques aux espaces de travail pour les régions China (Beijing) et Singapore. Ces nouveaux domaines dédiés offrent de meilleures performances et une stabilité accrue pour les requêtes d'inférence. Nous vous recommandons de migrer vers ces nouveaux domaines :
  • China (Beijing) : passez de dashscope.aliyuncs.com à {WorkspaceId}.cn-beijing.maas.aliyuncs.com
  • Singapore : passez de dashscope-intl.aliyuncs.com à {WorkspaceId}.ap-southeast-1.maas.aliyuncs.com

En-têtes de requête

Ajoutez les informations suivantes à l'en-tête de la requête :
ParamètreTypeObligatoireDescription
AuthorizationstringOuiJeton d'authentification au format Bearer <your_api_key>. Remplacez <your_api_key> par votre clé API réelle.
user-agentstringNonIdentifiant client permettant au serveur de tracer l'origine de la requête.
X-DashScope-WorkSpacestringNonworkspace ID Model Studio.
X-DashScope-DataInspectionstringNonActive ou désactive l'inspection de conformité des données. Ce paramètre est omis ou défini sur enable par défaut. N'activez ce paramètre qu'en cas de nécessité absolue.
L'autorisation est vérifiée lors du handshake WebSocket. Si la clé API est invalide ou manquante, le handshake échoue et renvoie une erreur HTTP 401 ou 403.

Flux d'interaction

Pour plus de détails sur les événements client et serveur, consultez Événements client et Événements serveur.
WebSocket speech recognition sequence
Le client et le serveur interagissent selon l'ordre suivant :
  1. Établir la connexion : le client ouvre une connexion WebSocket vers le serveur.
  2. Démarrer la tâche : le client envoie une instruction run-task pour lancer la tâche, puis reçoit un événement task-started du serveur. Cet événement confirme le démarrage effectif de la tâche et autorise la poursuite des étapes suivantes.
  3. Transmettre le flux audio : le client commence à envoyer des données audio binaires (obligatoirement en mono) tout en recevant simultanément un flux d'événements result-generated du serveur. Chaque événement contient un résultat de reconnaissance vocale.
  4. Signaler la fin de la tâche au serveur : le client envoie une instruction finish-task pour demander au serveur de terminer la tâche, tout en continuant à recevoir des événements result-generated.
  5. Terminer la tâche : le client reçoit un événement task-finished du serveur, indiquant que la tâche est achevée.
  6. Fermer la connexion : le client clôture la connexion WebSocket.

Exemples

Ces exemples utilisent qwen-audio-3.1-asr-flash-message. Obtenez votre clé API et votre Base URL dans la console, puis définissez DASHSCOPE_API_KEY et DASHSCOPE_BASE_URL. Téléchargez l’audio d’exemple sous le nom asr_example.wav : un fichier WAV mono à 16 kHz, encodé en PCM 16 bits.
  • Java
  • Python
  • Go
  • Node.js
  • C#
  • PHP
Avant d'exécuter l'exemple, installez la dépendance Java-WebSocket :
Maven
<dependency>
    <groupId>org.java-websocket</groupId>
    <artifactId>Java-WebSocket</artifactId>
    <version>1.5.6</version>
</dependency>
<dependency>
    <groupId>org.json</groupId>
    <artifactId>json</artifactId>
    <version>20240303</version>
</dependency>
import org.java_websocket.client.WebSocketClient;
import org.java_websocket.handshake.ServerHandshake;
import org.json.JSONObject;

import java.net.URI;
import java.nio.ByteBuffer;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.UUID;
import java.util.concurrent.atomic.AtomicBoolean;

public class FunASRRealtimeClient {

    private static final String API_KEY = System.getenv("DASHSCOPE_API_KEY");
    private static final String URL = "wss://" + URI.create(System.getenv("DASHSCOPE_BASE_URL")).getHost() + "/api-ws/v1/inference";
    private static final String AUDIO_FILE = "asr_example.wav"; // Replace with the path to your audio file
    private static final String MODEL = "qwen-audio-3.1-asr-flash-message";

    // Generate a 32-character random ID
    private static final String TASK_ID = UUID.randomUUID().toString().replace("-", "").substring(0, 32);

    private static final AtomicBoolean taskStarted = new AtomicBoolean(false);
    private static WebSocketClient client;

    public static void main(String[] args) throws Exception {
        client = new WebSocketClient(new URI(URL)) {
            @Override
            public void onOpen(ServerHandshake handshake) {
                System.out.println("Connected to server");
                sendRunTask();
            }

            @Override
            public void onMessage(String data) {
                JSONObject message = new JSONObject(data);
                String event = message.getJSONObject("header").getString("event");
                switch (event) {
                    case "task-started":
                        System.out.println("Task started");
                        taskStarted.set(true);
                        new Thread(FunASRRealtimeClient::sendAudioStream).start();
                        break;
                    case "result-generated":
                        JSONObject payload = message.getJSONObject("payload");
                        String text = payload.getJSONObject("output").getJSONObject("sentence").getString("text");
                        System.out.println("Recognition result: " + text);
                        if (payload.has("usage")) {
                            System.out.println("Audio duration (seconds): " + payload.getJSONObject("usage").get("duration"));
                        }
                        break;
                    case "task-finished":
                        System.out.println("Task finished");
                        close();
                        break;
                    case "task-failed":
                        String errMsg = message.getJSONObject("header").optString("error_message");
                        System.err.println("Task failed: " + errMsg);
                        close();
                        break;
                    default:
                        System.out.println("Unknown event: " + event);
                }
            }

            @Override
            public void onClose(int code, String reason, boolean remote) {
                if (!taskStarted.get()) {
                    System.err.println("Task not started, closing connection");
                }
            }

            @Override
            public void onError(Exception ex) {
                System.err.println("WebSocket error: " + ex.getMessage());
            }
        };
        client.addHeader("Authorization", "bearer " + API_KEY);
        client.connectBlocking();
    }

    // Send the run-task instruction
    private static void sendRunTask() {
        JSONObject runTask = new JSONObject()
                .put("header", new JSONObject()
                        .put("action", "run-task")
                        .put("task_id", TASK_ID)
                        .put("streaming", "duplex"))
                .put("payload", new JSONObject()
                        .put("task_group", "audio")
                        .put("task", "asr")
                        .put("function", "recognition")
                        .put("model", MODEL)
                        .put("parameters", new JSONObject()
                                .put("sample_rate", 16000)
                                .put("format", "wav"))
                        .put("input", new JSONObject()));
        client.send(runTask.toString());
    }

    // Send the audio stream (send one binary chunk every 100ms)
    private static void sendAudioStream() {
        int chunkSize = 3200; // 100ms @ 16kHz 16bit mono
        try {
            byte[] audio = Files.readAllBytes(Paths.get(AUDIO_FILE));
            int offset = 0;
            while (offset < audio.length) {
                int end = Math.min(offset + chunkSize, audio.length);
                byte[] chunk = new byte[end - offset];
                System.arraycopy(audio, offset, chunk, 0, end - offset);
                client.send(ByteBuffer.wrap(chunk));
                offset = end;
                Thread.sleep(100);
            }
            System.out.println("Audio stream ended");
            sendFinishTask();
        } catch (Exception e) {
            System.err.println("Error reading audio file: " + e.getMessage());
            client.close();
        }
    }

    // Send the finish-task instruction
    private static void sendFinishTask() {
        JSONObject finishTask = new JSONObject()
                .put("header", new JSONObject()
                        .put("action", "finish-task")
                        .put("task_id", TASK_ID)
                        .put("streaming", "duplex"))
                .put("payload", new JSONObject()
                        .put("input", new JSONObject()));
        client.send(finishTask.toString());
    }
}

SDK disponibles