Alibaba Cloud Model Studio:リアルタイム音声認識 - Qwen

国際 (シンガポール)

中国 (北京)

DashScope SDK の使用

WebSocket API の使用

以下の例は、ローカルの音声ファイルを送信し、WebSocket 接続を介して認識結果を取得する方法を示しています。

1. API キーの作成：API キーを作成して設定します。セキュリティのため、API キーを環境変数としてエクスポートしてください。

2. コードの記述と実行：認証、接続、音声送信、結果受信の完全なプロセスを実装します。詳細については、「対話フロー」をご参照ください。

   Python

   この例を実行する前に、次のコマンドを実行して依存関係がインストールされていることを確認してください：

   pip uninstall websocket-client
   pip uninstall websocket
   pip install websocket-client

   サンプルコードのファイル名を websocket.py にしないでください。そうしないと、次のエラーが発生する可能性があります：AttributeError: module 'websocket' has no attribute 'WebSocketApp'. Did you mean: 'WebSocket'?

   # pip install websocket-client
   import os
   import time
   import json
   import threading
   import base64
   import websocket
   import logging
   import logging.handlers
   from datetime import datetime
   
   logger = logging.getLogger(__name__)
   logger.setLevel(logging.DEBUG)
   
   # シンガポールリージョンと北京リージョンの API キーは異なります。API キーを取得するには、https://www.alibabacloud.com/help/ja/model-studio/get-api-key をご参照ください。
   # 環境変数を設定していない場合は、次の行をご利用の Model Studio API キーに置き換えてください：API_KEY="sk-xxx"
   API_KEY = os.environ.get("DASHSCOPE_API_KEY", "sk-xxx")
   QWEN_MODEL = "qwen3-asr-flash-realtime"
   # 次の URL はシンガポールリージョンのベース URL です。北京リージョンのモデルを使用する場合は、ベース URL を wss://dashscope.aliyuncs.com/api-ws/v1/realtime に置き換えてください。
   baseUrl = "wss://dashscope-intl.aliyuncs.com/api-ws/v1/realtime"
   url = f"{baseUrl}?model={QWEN_MODEL}"
   print(f"Connecting to server: {url}")
   
   # 注：VAD モードを使用しない場合、連続して送信される音声の合計時間は 60 秒を超えてはなりません。
   enableServerVad = True
   is_running = True  # 実行フラグを追加します。
   
   headers = [
       "Authorization: Bearer " + API_KEY,
       "OpenAI-Beta: realtime=v1"
   ]
   
   def init_logger():
       formatter = logging.Formatter('%(asctime)s|%(levelname)s|%(message)s')
       f_handler = logging.handlers.RotatingFileHandler(
           "omni_tester.log", maxBytes=100 * 1024 * 1024, backupCount=3
       )
       f_handler.setLevel(logging.DEBUG)
       f_handler.setFormatter(formatter)
   
       console = logging.StreamHandler()
       console.setLevel(logging.DEBUG)
       console.setFormatter(formatter)
   
       logger.addHandler(f_handler)
       logger.addHandler(console)
   
   def on_open(ws):
       logger.info("Connected to server.")
   
       # セッション更新イベント。
       event_manual = {
           "event_id": "event_123",
           "type": "session.update",
           "session": {
               "modalities": ["text"],
               "input_audio_format": "pcm",
               "sample_rate": 16000,
               "input_audio_transcription": {
                   # 言語識別子、オプション。明確な言語情報がある場合は設定します。
                   "language": "zh"
                   # コーパス、オプション。コーパスがある場合は、認識を強化するために設定します。
                   # "corpus": {
                   #     "text": ""
                   # }
               },
               "turn_detection": None
           }
       }
       event_vad = {
           "event_id": "event_123",
           "type": "session.update",
           "session": {
               "modalities": ["text"],
               "input_audio_format": "pcm",
               "sample_rate": 16000,
               "input_audio_transcription": {
                   "language": "zh"
               },
               "turn_detection": {
                   "type": "server_vad",
                   "threshold": 0.2,
                   "silence_duration_ms": 800
               }
           }
       }
       if enableServerVad:
           logger.info(f"Sending event: {json.dumps(event_vad, indent=2)}")
           ws.send(json.dumps(event_vad))
       else:
           logger.info(f"Sending event: {json.dumps(event_manual, indent=2)}")
           ws.send(json.dumps(event_manual))
   
   def on_message(ws, message):
       global is_running
       try:
           data = json.loads(message)
           logger.info(f"Received event: {json.dumps(data, ensure_ascii=False, indent=2)}")
           if data.get("type") == "conversation.item.input_audio_transcription.completed":
               logger.info(f"Final transcript: {data.get('transcript')}")
               logger.info("Closing WebSocket connection after completion...")
               is_running = False  # 音声送信スレッドを停止します。
               ws.close()
       except json.JSONDecodeError:
           logger.error(f"Failed to parse message: {message}")
   
   def on_error(ws, error):
       logger.error(f"Error: {error}")
   
   def on_close(ws, close_status_code, close_msg):
       logger.info(f"Connection closed: {close_status_code} - {close_msg}")
   
   def send_audio(ws, local_audio_path):
       time.sleep(3)  # セッションの更新が完了するのを待ちます。
       global is_running
   
       with open(local_audio_path, 'rb') as audio_file:
           logger.info(f"Start reading file: {datetime.now().strftime('%Y-%m-%d %H:%M:%S.%f')[:-3]}")
           while is_running:
               audio_data = audio_file.read(3200)  # ~0.1s PCM16/16kHz
               if not audio_data:
                   logger.info(f"Finished reading file: {datetime.now().strftime('%Y-%m-%d %H:%M:%S.%f')[:-3]}")
                   if not enableServerVad and ws.sock and ws.sock.connected:
                       commit_event = {
                           "event_id": "event_789",
                           "type": "input_audio_buffer.commit"
                       }
                       ws.send(json.dumps(commit_event))
                   break
   
               if not ws.sock or not ws.sock.connected:
                   logger.info("WebSocket is closed. Stop sending audio.")
                   break
   
               encoded_data = base64.b64encode(audio_data).decode('utf-8')
               eventd = {
                   "event_id": f"event_{int(time.time() * 1000)}",
                   "type": "input_audio_buffer.append",
                   "audio": encoded_data
               }
               ws.send(json.dumps(eventd))
               logger.info(f"Sending audio event: {eventd['event_id']}")
               time.sleep(0.1)  # リアルタイム収集をシミュレートします。
   
   # ロガーを初期化します。
   init_logger()
   logger.info(f"Connecting to WebSocket server at {url}...")
   
   local_audio_path = "your_audio_file.pcm"
   ws = websocket.WebSocketApp(
       url,
       header=headers,
       on_open=on_open,
       on_message=on_message,
       on_error=on_error,
       on_close=on_close
   )
   
   thread = threading.Thread(target=send_audio, args=(ws, local_audio_path))
   thread.start()
   ws.run_forever()

   Java

   この例を実行する前に、Java-WebSocket 依存関係がインストールされていることを確認してください：

   Maven

   <dependency>
       <groupId>org.java-websocket</groupId>
       <artifactId>Java-WebSocket</artifactId>
       <version>1.5.6</version>
   </dependency>

   Gradle

   implementation 'org.java-websocket:Java-WebSocket:1.5.6'

   import org.java_websocket.client.WebSocketClient;
   import org.java_websocket.handshake.ServerHandshake;
   import org.json.JSONObject;
   
   import java.net.URI;
   import java.nio.file.Files;
   import java.nio.file.Paths;
   import java.util.Base64;
   import java.util.concurrent.atomic.AtomicBoolean;
   import java.util.logging.*;
   
   public class QwenASRRealtimeClient {
   
       private static final Logger logger = Logger.getLogger(QwenASRRealtimeClient.class.getName());
       // シンガポールリージョンと北京リージョンの API キーは異なります。API キーを取得するには、https://www.alibabacloud.com/help/ja/model-studio/get-api-key をご参照ください。
       // 環境変数を設定していない場合は、次の行をご利用の Model Studio API キーに置き換えてください：private static final String API_KEY = "sk-xxx"
       private static final String API_KEY = System.getenv().getOrDefault("DASHSCOPE_API_KEY", "sk-xxx");
       private static final String MODEL = "qwen3-asr-flash-realtime";
   
       // VAD モードを使用するかどうかを制御します。
       private static final boolean enableServerVad = true;
   
       private static final AtomicBoolean isRunning = new AtomicBoolean(true);
       private static WebSocketClient client;
   
       public static void main(String[] args) throws Exception {
           initLogger();
   
           // 次の URL はシンガポールリージョンのベース URL です。北京リージョンのモデルを使用する場合は、ベース URL を wss://dashscope.aliyuncs.com/api-ws/v1/realtime に置き換えてください。
           String baseUrl = "wss://dashscope-intl.aliyuncs.com/api-ws/v1/realtime";
           String url = baseUrl + "?model=" + MODEL;
           logger.info("Connecting to server: " + url);
   
           client = new WebSocketClient(new URI(url)) {
               @Override
               public void onOpen(ServerHandshake handshake) {
                   logger.info("Connected to server.");
                   sendSessionUpdate();
               }
   
               @Override
               public void onMessage(String message) {
                   try {
                       JSONObject data = new JSONObject(message);
                       String eventType = data.optString("type");
   
                       logger.info("Received event: " + data.toString(2));
   
                       // 最終的な認識結果イベントを受信 -> 送信スレッドを停止し、接続を閉じます。
                       if ("conversation.item.input_audio_transcription.completed".equals(eventType)) {
                           logger.info("Final transcript: " + data.optString("transcript"));
                           logger.info("Closing WebSocket connection after completion...");
   
                           isRunning.set(false); // 音声送信スレッドを停止します。
                           if (this.isOpen()) {
                               this.close(1000, "ASR completed");
                           }
                       }
                   } catch (Exception e) {
                       logger.severe("Failed to parse message: " + message);
                   }
               }
   
               @Override
               public void onClose(int code, String reason, boolean remote) {
                   logger.info("Connection closed: " + code + " - " + reason);
               }
   
               @Override
               public void onError(Exception ex) {
                   logger.severe("Error: " + ex.getMessage());
               }
           };
   
           // リクエストヘッダーを追加します。
           client.addHeader("Authorization", "Bearer " + API_KEY);
           client.addHeader("OpenAI-Beta", "realtime=v1");
   
           client.connectBlocking(); // 接続が確立されるまでブロックします。
   
           // 認識する音声ファイルのパスに置き換えます。
           String localAudioPath = "your_audio_file.pcm";
           Thread audioThread = new Thread(() -> {
               try {
                   sendAudio(localAudioPath);
               } catch (Exception e) {
                   logger.severe("Audio sending thread error: " + e.getMessage());
               }
           });
           audioThread.start();
       }
   
       /** セッション更新イベント (VAD の有効化/無効化)。 */
       private static void sendSessionUpdate() {
           JSONObject eventNoVad = new JSONObject()
                   .put("event_id", "event_123")
                   .put("type", "session.update")
                   .put("session", new JSONObject()
                           .put("modalities", new String[]{"text"})
                           .put("input_audio_format", "pcm")
                           .put("sample_rate", 16000)
                           .put("input_audio_transcription", new JSONObject()
                                   .put("language", "zh"))
                           .put("turn_detection", JSONObject.NULL) // 手動モード。
                   );
   
           JSONObject eventVad = new JSONObject()
                   .put("event_id", "event_123")
                   .put("type", "session.update")
                   .put("session", new JSONObject()
                           .put("modalities", new String[]{"text"})
                           .put("input_audio_format", "pcm")
                           .put("sample_rate", 16000)
                           .put("input_audio_transcription", new JSONObject()
                                   .put("language", "zh"))
                           .put("turn_detection", new JSONObject()
                                   .put("type", "server_vad")
                                   .put("threshold", 0.2)
                                   .put("silence_duration_ms", 800))
                   );
   
           if (enableServerVad) {
               logger.info("Sending event (VAD):\n" + eventVad.toString(2));
               client.send(eventVad.toString());
           } else {
               logger.info("Sending event (Manual):\n" + eventNoVad.toString(2));
               client.send(eventNoVad.toString());
           }
       }
   
       /** 音声ファイルストリームを送信します。 */
       private static void sendAudio(String localAudioPath) throws Exception {
           Thread.sleep(3000); // セッションの準備が整うのを待ちます。
           byte[] allBytes = Files.readAllBytes(Paths.get(localAudioPath));
           logger.info("Start reading file.");
   
           int offset = 0;
           while (isRunning.get() && offset < allBytes.length) {
               int chunkSize = Math.min(3200, allBytes.length - offset);
               byte[] chunk = new byte[chunkSize];
               System.arraycopy(allBytes, offset, chunk, 0, chunkSize);
               offset += chunkSize;
   
               if (client != null && client.isOpen()) {
                   String encoded = Base64.getEncoder().encodeToString(chunk);
                   JSONObject eventd = new JSONObject()
                           .put("event_id", "event_" + System.currentTimeMillis())
                           .put("type", "input_audio_buffer.append")
                           .put("audio", encoded);
   
                   client.send(eventd.toString());
                   logger.info("Sending audio event: " + eventd.getString("event_id"));
               } else {
                   break; // 切断後の送信を避けます。
               }
   
               Thread.sleep(100); // リアルタイム送信をシミュレートします。
           }
   
           logger.info("Finished reading file.");
   
           // 非 VAD モードでは commit が必要です。
           if (!enableServerVad && client != null && client.isOpen()) {
               JSONObject commitEvent = new JSONObject()
                       .put("event_id", "event_789")
                       .put("type", "input_audio_buffer.commit");
               client.send(commitEvent.toString());
               logger.info("Sent commit event for manual mode.");
           }
       }
   
       /** ロガーを初期化します。 */
       private static void initLogger() {
           logger.setLevel(Level.ALL);
           Logger rootLogger = Logger.getLogger("");
           for (Handler h : rootLogger.getHandlers()) {
               rootLogger.removeHandler(h);
           }
   
           Handler consoleHandler = new ConsoleHandler();
           consoleHandler.setLevel(Level.ALL);
           consoleHandler.setFormatter(new SimpleFormatter());
           logger.addHandler(consoleHandler);
       }
   }

   Node.js

   この例を実行する前に、次のコマンドを使用して依存関係がインストールされていることを確認してください：

   npm install ws

   /**
    * Qwen-ASR リアルタイム WebSocket クライアント (Node.js 版)
    * 特徴：
    * - VAD モードと手動モードをサポート
    * - session.update を送信してセッションを開始
    * - input_audio_buffer.append オーディオチャンクを継続的に送信
    * - 手動モードで input_audio_buffer.commit を送信
    * - completed イベントを受信後、接続を閉じて送信を停止
    */
   
   const WebSocket = require('ws');
   const fs = require('fs');
   
   // ===== 設定 =====
   // シンガポールリージョンと北京リージョンの API キーは異なります。API キーを取得するには、https://www.alibabacloud.com/help/ja/model-studio/get-api-key をご参照ください。
   // 環境変数を設定していない場合は、次の行をご利用の Model Studio API キーに置き換えてください：const API_KEY = "sk-xxx"
   const API_KEY = process.env.DASHSCOPE_API_KEY || 'sk-xxx';
   const MODEL = 'qwen3-asr-flash-realtime';
   const enableServerVad = true; // VAD モードの場合は true、手動モードの場合は false
   const localAudioPath = 'your_audio_file.pcm'; // PCM16、16 kHz の音声ファイルのパス
   
   // 次の URL はシンガポールリージョンのベース URL です。北京リージョンのモデルを使用する場合は、ベース URL を wss://dashscope.aliyuncs.com/api-ws/v1/realtime に置き換えてください。
   const baseUrl = 'wss://dashscope-intl.aliyuncs.com/api-ws/v1/realtime';
   const url = `${baseUrl}?model=${MODEL}`;
   
   console.log(`Connecting to server: ${url}`);
   
   // ===== 状態制御 =====
   let isRunning = true;
   
   // ===== 接続確立 =====
   const ws = new WebSocket(url, {
       headers: {
           'Authorization': `Bearer ${API_KEY}`,
           'OpenAI-Beta': 'realtime=v1'
       }
   });
   
   // ===== イベントバインディング =====
   ws.on('open', () => {
       console.log('[WebSocket] Connected to server.');
       sendSessionUpdate();
       // 音声送信スレッドを開始します。
       sendAudio(localAudioPath);
   });
   
   ws.on('message', (message) => {
       try {
           const data = JSON.parse(message);
           console.log('[Received Event]:', JSON.stringify(data, null, 2));
   
           // 完了イベントを受信。
           if (data.type === 'conversation.item.input_audio_transcription.completed') {
               console.log(`[Final Transcript] ${data.transcript}`);
               console.log('[Action] Closing WebSocket connection after completion...');
               isRunning = false; // 音声送信を停止します。
               if (ws.readyState === WebSocket.OPEN) {
                   ws.close(1000, 'ASR completed');
               }
           }
       } catch (e) {
           console.error('[Error] Failed to parse message:', message);
       }
   });
   
   ws.on('close', (code, reason) => {
       console.log(`[WebSocket] Connection closed: ${code} - ${reason}`);
   });
   
   ws.on('error', (err) => {
       console.error('[WebSocket Error]', err);
   });
   
   // ===== セッション更新 =====
   function sendSessionUpdate() {
       const eventNoVad = {
           event_id: 'event_123',
           type: 'session.update',
           session: {
               modalities: ['text'],
               input_audio_format: 'pcm',
               sample_rate: 16000,
               input_audio_transcription: {
                   language: 'zh'
               },
               turn_detection: null
           }
       };
   
       const eventVad = {
           event_id: 'event_123',
           type: 'session.update',
           session: {
               modalities: ['text'],
               input_audio_format: 'pcm',
               sample_rate: 16000,
               input_audio_transcription: {
                   language: 'zh'
               },
               turn_detection: {
                   type: 'server_vad',
                   threshold: 0.2,
                   silence_duration_ms: 800
               }
           }
       };
   
       if (enableServerVad) {
           console.log('[Send Event] VAD Mode:\n', JSON.stringify(eventVad, null, 2));
           ws.send(JSON.stringify(eventVad));
       } else {
           console.log('[Send Event] Manual Mode:\n', JSON.stringify(eventNoVad, null, 2));
           ws.send(JSON.stringify(eventNoVad));
       }
   }
   
   // ===== 音声ファイルストリームの送信 =====
   function sendAudio(audioPath) {
       setTimeout(() => {
           console.log(`[File Read Start] ${audioPath}`);
           const buffer = fs.readFileSync(audioPath);
   
           let offset = 0;
           const chunkSize = 3200; // 約 0.1 秒の PCM16 音声
   
           function sendChunk() {
               if (!isRunning) return;
               if (offset >= buffer.length) {
                   console.log('[File Read End]');
                   if (!enableServerVad && ws.readyState === WebSocket.OPEN) {
                       const commitEvent = {
                           event_id: 'event_789',
                           type: 'input_audio_buffer.commit'
                       };
                       ws.send(JSON.stringify(commitEvent));
                       console.log('[Send Commit Event]');
                   }
                   return;
               }
   
               if (ws.readyState !== WebSocket.OPEN) {
                   console.log('[Stop] WebSocket is not open.');
                   return;
               }
   
               const chunk = buffer.slice(offset, offset + chunkSize);
               offset += chunkSize;
   
               const encoded = chunk.toString('base64');
               const appendEvent = {
                   event_id: `event_${Date.now()}`,
                   type: 'input_audio_buffer.append',
                   audio: encoded
               };
   
               ws.send(JSON.stringify(appendEvent));
               console.log(`[Send Audio Event] ${appendEvent.event_id}`);
   
               setTimeout(sendChunk, 100); // リアルタイム送信をシミュレートします。
           }
   
           sendChunk();
       }, 3000); // セッション設定が完了するのを待ちます。
   }