Alibaba Cloud Model Studio:Reconnaissance vocale non temps réel

Les modèles de reconnaissance vocale non temps réel convertissent des enregistrements audio en texte. Ils prennent en charge la reconnaissance multilingue, la reconnaissance du chant, le rejet du bruit et la diarisation des locuteurs, ce qui les rend adaptés à la transcription de réunions, à l'analyse d'appels, à la génération de sous-titres et à des scénarios similaires.

Présentation

Transcrivez par lots vos fichiers audio et vidéo enregistrés via des tâches asynchrones.

• L'amélioration contextuelle accroît la précision de la reconnaissance grâce à un contexte configurable.
• Des mots-clés personnalisés optimisent la reconnaissance des noms propres au moyen d'une liste de mots prédéfinie.
• Parmi les fonctionnalités configurables figurent la diarisation des locuteurs, le filtrage des mots sensibles ainsi que les horodatages au niveau de la phrase ou du mot.
• La transcription asynchrone accepte un fichier audio unique d'une durée maximale de 12 heures et d'une taille pouvant atteindre 2 Go.
• Toutes les fréquences d'échantillonnage sont prises en charge, de même que les formats audio et vidéo courants tels que AAC, WAV et MP3.

Pour les cas d'usage en temps réel comme les sous-titres en direct, les réunions en ligne ou les assistants vocaux, reportez-vous à la rubrique Reconnaissance vocale temps réel. Pour obtenir des conseils sur le choix du modèle, consultez Conversion parole-texte.

Prérequis

• Une clé API a été obtenue et configurée en tant que variable d'environnement.
• Pour appeler l'API via le SDK DashScope, installez la dernière version du SDK.

Démarrage rapide

curl -X POST 'https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/api/v1/services/audio/asr/transcription' \
-H "Authorization: Bearer $DASHSCOPE_API_KEY" \
-H "Content-Type: application/json" \
-H "X-DashScope-Async: enable" \
-d '{
    "model": "qwen-audio-3.0-asr-flash-filetrans",
    "input": {
        "file_urls": [
            "{YOUR_AUDIO_URL}"
        ]
    },
    "parameters": {
        "channel_id": [0],
        "language_hints": ["zh", "en"]
    }
}'

curl -X GET 'https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/api/v1/tasks/{task_id}' \
-H "Authorization: Bearer $DASHSCOPE_API_KEY" \
-H "Content-Type: application/json"

# Replace {transcription_url} with the transcription_url value returned by the query API
curl -sS '{transcription_url}' -o transcription.json
cat transcription.json | jq .

from http import HTTPStatus
from dashscope.audio.asr import Transcription
from urllib import request
import dashscope
import os
import json

# The following is the configuration for the Singapore region. When calling, replace "{WorkspaceId}" with your actual workspace ID. The configuration differs by region.
dashscope.base_http_api_url = 'https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/api/v1'

# The API Key differs between the Singapore and Beijing regions. Get an API Key: https://www.alibabacloud.com/help/zh/model-studio/get-api-key
# If you have not configured the environment variable, replace the following line with your Alibaba Cloud Model Studio API Key: dashscope.api_key = "sk-xxx"
dashscope.api_key = os.getenv("DASHSCOPE_API_KEY")

task_response = Transcription.async_call(
    model='qwen-audio-3.0-asr-flash-filetrans',
    file_urls=['{YOUR_AUDIO_URL}'],
    language_hints=['zh', 'en']  # language_hints is an optional parameter used to specify the language codes of the audio to be recognized. For the value range, see the API reference documentation.
)

transcription_response = Transcription.wait(task=task_response.output.task_id)

if transcription_response.status_code == HTTPStatus.OK:
    for transcription in transcription_response.output['results']:
        if transcription['subtask_status'] == 'SUCCEEDED':
            url = transcription['transcription_url']
            result = json.loads(request.urlopen(url).read().decode('utf8'))
            print(json.dumps(result, indent=4,
                            ensure_ascii=False))
        else:
            print('transcription failed!')
            print(transcription)
else:
    print('Error: ', transcription_response.output.message)

import com.alibaba.dashscope.audio.asr.transcription.*;
import com.alibaba.dashscope.utils.Constants;
import com.google.gson.*;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.Arrays;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        // The following is the configuration for the Singapore region. When calling, replace "{WorkspaceId}" with your actual workspace ID. The configuration differs by region.
        Constants.baseHttpApiUrl = "https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/api/v1";
        // Create the transcription request parameters.
        TranscriptionParam param =
                TranscriptionParam.builder()
                        // The API Key differs between the Singapore and Beijing regions. Get an API Key: https://www.alibabacloud.com/help/fr/model-studio/get-api-key
                        // If you have not configured the environment variable, replace the following line with your Alibaba Cloud Model Studio API Key: .apiKey("sk-xxx")
                        .apiKey(System.getenv("DASHSCOPE_API_KEY"))
                        .model("qwen-audio-3.0-asr-flash-filetrans")
                        // language_hints is an optional parameter used to specify the language codes of the audio to be recognized. For the value range, see the API reference documentation.
                        .parameter("language_hints", new String[]{"zh", "en"})
                        .fileUrls(
                                Arrays.asList(
                                        "{YOUR_AUDIO_URL}"))
                        .build();
        try {
            Transcription transcription = new Transcription();
            // Submit the transcription request
            TranscriptionResult result = transcription.asyncCall(param);
            System.out.println("RequestId: " + result.getRequestId());
            // Check whether the task was submitted successfully
            if (result.getTaskId() == null) {
                System.out.println("Error: " + result.getOutput());
                System.exit(1);
            }
            // Block and wait for the task to complete and get the result
            result = transcription.wait(
                    TranscriptionQueryParam.FromTranscriptionParam(param, result.getTaskId()));
            // Get the transcription result
            List<TranscriptionTaskResult> taskResultList = result.getResults();
            if (taskResultList != null && taskResultList.size() > 0) {
                for (TranscriptionTaskResult taskResult : taskResultList) {
                    String transcriptionUrl = taskResult.getTranscriptionUrl();
                    HttpURLConnection connection =
                            (HttpURLConnection) new URL(transcriptionUrl).openConnection();
                    connection.setRequestMethod("GET");
                    connection.connect();
                    BufferedReader reader =
                            new BufferedReader(new InputStreamReader(connection.getInputStream()));
                    Gson gson = new GsonBuilder().setPrettyPrinting().create();
                    JsonElement jsonResult = gson.fromJson(reader, JsonObject.class);
                    System.out.println(gson.toJson(jsonResult));
                }
            }
        } catch (Exception e) {
            System.out.println("error: " + e);
        }
        System.exit(0);
    }
}

curl --location --request POST 'https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/api/v1/services/aigc/multimodal-generation/generation' \
     --header "Authorization: Bearer $DASHSCOPE_API_KEY" \
     --header "Content-Type: application/json" \
     --header "X-DashScope-SSE: disable" \
     --data '{
    "model": "qwen-audio-3.0-asr-flash",
    "input": {
        "messages": [
            {
                "role": "user",
                "content": [
                    {
                        "type": "input_audio",
                        "input_audio": {
                            "data": "{YOUR_AUDIO_URL}"
                        }
                    }
                ]
            }
        ]
    },
    "parameters": {
        "format": "wav",
        "sample_rate": "16000"
    }
}'

{
  "output": {
    "output": {
      "sentence": {
        "text": "Recognized text content"
      }
    },
    "text": "Hello World, this is the Alibaba Speech Lab."
  },
  "request_id": "..."
}

Fonctionnalités avancées

Utiliser l'API compatible OpenAI

Seuls les modèles de la série Qwen3-ASR-Flash permettent des appels via le mode compatible OpenAI. Ce mode accepte uniquement les URL de fichiers audio accessibles publiquement. Il n'accepte pas le chemin absolu d'un fichier audio local.

Utilisez OpenAI Python SDK version 1.52.0 ou ultérieure, ou Node.js SDK version 4.68.0 ou ultérieure. Pour installer ou mettre à niveau le SDK, exécutez :

# Python
pip install -U "openai>=1.52.0"

# Node.js
npm install openai@^4.68.0

asr_options n'est pas un paramètre standard OpenAI. Avec le SDK Python OpenAI, transmettez-le via extra_body. Avec le SDK Node.js OpenAI, passez asr_options directement comme paramètre de premier niveau dans le corps de la requête.

from openai import OpenAI
import os

try:
    client = OpenAI(
        # The API Key differs between the Singapore/US regions and the Beijing region. Get an API Key: https://www.alibabacloud.com/help/zh/model-studio/get-api-key
        # If you have not configured the environment variable, replace the following line with your Alibaba Cloud Model Studio API Key: api_key = "sk-xxx",
        api_key=os.getenv("DASHSCOPE_API_KEY"),
        # The following is the configuration for the Singapore region. When calling, replace "{WorkspaceId}" with your actual workspace ID. The configuration differs by region.
        base_url="https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1",
    )

    stream_enabled = False  # Whether to enable streaming output
    completion = client.chat.completions.create(
        model="qwen3-asr-flash",
        messages=[
            {
                "content": [
                    {
                        "type": "input_audio",
                        "input_audio": {
                            "data": "{YOUR_AUDIO_URL}"
                        }
                    }
                ],
                "role": "user"
            }
        ],
        stream=stream_enabled,
        # When stream is set to False, the stream_options parameter cannot be set
        # stream_options={"include_usage": True},
        extra_body={
            "asr_options": {
                # "language": "zh",
                "enable_itn": False
            }
        }
    )
    if stream_enabled:
        full_content = ""
        print("The streaming output is:")
        for chunk in completion:
            # If stream_options.include_usage is True, the choices field of the last chunk is an empty list and needs to be skipped (you can get the Token usage via chunk.usage)
            print(chunk)
            if chunk.choices and chunk.choices[0].delta.content:
                full_content += chunk.choices[0].delta.content
        print(f"The complete content is: {full_content}")
    else:
        print(f"The non-streaming output is: {completion.choices[0].message.content}")
except Exception as e:
    print(f"Error message: {e}")

// Preparations before running:
// Common to Windows/Mac/Linux:
// 1. Make sure Node.js is installed (version >= 14 recommended)
// 2. Run the following command to install the required dependencies: npm install openai

import OpenAI from "openai";

const client = new OpenAI({
  // The API Key differs between the Singapore/US regions and the Beijing region. Get an API Key: https://www.alibabacloud.com/help/zh/model-studio/get-api-key
  // If you have not configured the environment variable, replace the following line with your Alibaba Cloud Model Studio API Key: apiKey: "sk-xxx",
  apiKey: process.env.DASHSCOPE_API_KEY,
  // The following is the configuration for the Singapore region. When calling, replace "{WorkspaceId}" with your actual workspace ID. The configuration differs by region.
  baseURL: "https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1",
});

async function main() {
  try {
    const streamEnabled = false; // Whether to enable streaming output
    const completion = await client.chat.completions.create({
      model: "qwen3-asr-flash",
      messages: [
        {
          role: "user",
          content: [
            {
              type: "input_audio",
              input_audio: {
                data: "{YOUR_AUDIO_URL}"
              }
            }
          ]
        }
      ],
      stream: streamEnabled,
      // When stream is set to False, the stream_options parameter cannot be set
      // stream_options: {
      //   "include_usage": true
      // },
      asr_options: {
        // language: "zh",
        enable_itn: false
      }
    });

    if (streamEnabled) {
      let fullContent = "";
      console.log("The streaming output is:");
      for await (const chunk of completion) {
        console.log(JSON.stringify(chunk));
        if (chunk.choices && chunk.choices.length > 0) {
          const delta = chunk.choices[0].delta;
          if (delta && delta.content) {
            fullContent += delta.content;
          }
        }
      }
      console.log(`The complete content is: ${fullContent}`);
    } else {
      console.log(`The non-streaming output is: ${completion.choices[0].message.content}`);
    }
  } catch (err) {
    console.error(`Error message: ${err}`);
  }
}

main();

curl -X POST 'https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1/chat/completions' \
-H "Authorization: Bearer $DASHSCOPE_API_KEY" \
-H "Content-Type: application/json" \
-d '{
    "model": "qwen3-asr-flash",
    "messages": [
        {
            "content": [
                {
                    "type": "input_audio",
                    "input_audio": {
                        "data": "{YOUR_AUDIO_URL}"
                    }
                }
            ],
            "role": "user"
        }
    ],
    "stream":false,
    "asr_options": {
        "enable_itn": false
    }
}'

import base64
from openai import OpenAI
import os
import pathlib

try:
    # Replace with the actual audio file path
    file_path = "{YOUR_AUDIO_FILE}"
    # Replace with the actual MIME type of the audio file
    audio_mime_type = "audio/mpeg"

    file_path_obj = pathlib.Path(file_path)
    if not file_path_obj.exists():
        raise FileNotFoundError(f"Audio file does not exist: {file_path}")

    base64_str = base64.b64encode(file_path_obj.read_bytes()).decode()
    data_uri = f"data:{audio_mime_type};base64,{base64_str}"

    client = OpenAI(
        # The API Key differs between the Singapore/US regions and the Beijing region. Get an API Key: https://www.alibabacloud.com/help/zh/model-studio/get-api-key
        # If you have not configured the environment variable, replace the following line with your Alibaba Cloud Model Studio API Key: api_key = "sk-xxx",
        api_key=os.getenv("DASHSCOPE_API_KEY"),
        # The following is the configuration for the Singapore region. When calling, replace "{WorkspaceId}" with your actual workspace ID. The configuration differs by region.
        base_url="https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1",
    )

    stream_enabled = False  # Whether to enable streaming output
    completion = client.chat.completions.create(
        model="qwen3-asr-flash",
        messages=[
            {
                "content": [
                    {
                        "type": "input_audio",
                        "input_audio": {
                            "data": data_uri
                        }
                    }
                ],
                "role": "user"
            }
        ],
        stream=stream_enabled,
        # When stream is set to False, the stream_options parameter cannot be set
        # stream_options={"include_usage": True},
        extra_body={
            "asr_options": {
                # "language": "zh",
                "enable_itn": False
            }
        }
    )
    if stream_enabled:
        full_content = ""
        print("The streaming output is:")
        for chunk in completion:
            # If stream_options.include_usage is True, the choices field of the last chunk is an empty list and needs to be skipped (you can get the Token usage via chunk.usage)
            print(chunk)
            if chunk.choices and chunk.choices[0].delta.content:
                full_content += chunk.choices[0].delta.content
        print(f"The complete content is: {full_content}")
    else:
        print(f"The non-streaming output is: {completion.choices[0].message.content}")
except Exception as e:
    print(f"Error message: {e}")

// Preparations before running:
// Common to Windows/Mac/Linux:
// 1. Make sure Node.js is installed (version >= 14 recommended)
// 2. Run the following command to install the required dependencies: npm install openai

import OpenAI from "openai";
import { readFileSync } from 'fs';

const client = new OpenAI({
  // The API Key differs between the Singapore/US regions and the Beijing region. Get an API Key: https://www.alibabacloud.com/help/zh/model-studio/get-api-key
  // If you have not configured the environment variable, replace the following line with your Alibaba Cloud Model Studio API Key: apiKey: "sk-xxx",
  apiKey: process.env.DASHSCOPE_API_KEY,
  // The following is the configuration for the Singapore region. When calling, replace "{WorkspaceId}" with your actual workspace ID. The configuration differs by region.
  baseURL: "https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1",
});

const encodeAudioFile = (audioFilePath) => {
    const audioFile = readFileSync(audioFilePath);
    return audioFile.toString('base64');
};

// Replace with the actual audio file path
const dataUri = `data:audio/mpeg;base64,${encodeAudioFile("{YOUR_AUDIO_FILE}")}`;

async function main() {
  try {
    const streamEnabled = false; // Whether to enable streaming output
    const completion = await client.chat.completions.create({
      model: "qwen3-asr-flash",
      messages: [
        {
          role: "user",
          content: [
            {
              type: "input_audio",
              input_audio: {
                data: dataUri
              }
            }
          ]
        }
      ],
      stream: streamEnabled,
      // When stream is set to False, the stream_options parameter cannot be set
      // stream_options: {
      //   "include_usage": true
      // },
      asr_options: {
        // language: "zh",
        enable_itn: false
      }
    });

    if (streamEnabled) {
      let fullContent = "";
      console.log("The streaming output is:");
      for await (const chunk of completion) {
        console.log(JSON.stringify(chunk));
        if (chunk.choices && chunk.choices.length > 0) {
          const delta = chunk.choices[0].delta;
          if (delta && delta.content) {
            fullContent += delta.content;
          }
        }
      }
      console.log(`The complete content is: ${fullContent}`);
    } else {
      console.log(`The non-streaming output is: ${completion.choices[0].message.content}`);
    }
  } catch (err) {
    console.error(`Error message: ${err}`);
  }
}

main();

Traitement des fichiers audio longs

La reconnaissance vocale non temps réel permet la transcription asynchrone de fichiers audio longs. Cette fonctionnalité est idéale pour les comptes rendus de réunions, les transcriptions d'interviews ou la réécoute d'appels téléphoniques.

• Qwen-Audio-3.0-ASR-Flash-Filetrans/Fun-ASR / Qwen3-ASR-Flash-Filetrans / Paraformer : un fichier audio unique peut atteindre 2 Go et durer jusqu'à 12 heures.
• Qwen-Audio-3.0-ASR-Flash/Fun-ASR-Flash/Qwen3-ASR-Flash : la taille maximale d'un fichier audio est de 10 Mo pour une durée limitée à 5 minutes. Pour des durées plus longues, utilisez Qwen-Audio-3.0-ASR-Flash-Filetrans, Fun-ASR ou Qwen3-ASR-Flash-Filetrans.
• Avec segmentation des locuteurs activée : limitez la durée audio à 2 heures maximum. Au-delà, vous risquez des échecs de reconnaissance ou des délais d'attente dépassés. Consultez la section Segmentation des locuteurs pour plus de détails.

Flux d'appel : la transcription d'audio long repose sur un modèle de tâche asynchrone comportant trois étapes :

1. Soumettez la tâche de transcription et récupérez un task_id.
2. Interrogez régulièrement l'API pour connaître l'état de la tâche, ou utilisez la méthode d'attente du SDK pour bloquer l'exécution jusqu'à son achèvement.
3. Une fois la tâche terminée, téléchargez le résultat de reconnaissance au format JSON depuis l'URL fournie.

Pour consulter des exemples de code, reportez-vous à la section Démarrage rapide relative à la reconnaissance vocale non temps réel.

Sortie en streaming

Les modèles Qwen-Audio-3.0-ASR-Flash, Fun-ASR-Flash et Qwen3-ASR-Flash prennent en charge la sortie en streaming : ils renvoient des résultats intermédiaires au fur et à mesure de la reconnaissance. Ce mode convient aux scénarios nécessitant un retour visuel en temps réel.

Les modèles de transcription asynchrone tels que Qwen-Audio-3.0-ASR-Flash-Filetrans, Fun-ASR, Qwen3-ASR-Flash-Filetrans et Paraformer ne gèrent pas la sortie en streaming. Pour obtenir le résultat final, interrogez la tâche périodiquement (voir Traitement des fichiers audio longs).

• DashScope Python SDK : définissez le paramètre stream sur True.
• DashScope Java SDK : appelez l'API streamCall.
• DashScope HTTP : attribuez la valeur enable à l'en-tête X-DashScope-SSE.
• SDK compatible OpenAI : passez le paramètre stream à True.

Pour les exemples de sortie en streaming de Qwen3-ASR-Flash, consultez Exemples de requêtes et sélectionnez l’onglet Sortie en streaming.

Amélioration de la précision grâce aux mots-clés

Les mots-clés optimisent la précision de la reconnaissance pour les noms propres spécifiques à un domaine (noms de personnes, lieux, produits, etc.). Pour savoir comment créer et utiliser ces mots-clés, consultez Améliorer la précision de la reconnaissance.

Chaque SDK applique ses propres conventions de nommage pour ces paramètres (clés de dictionnaire, propriétés d'objet ou méthodes). Reportez-vous à la référence API de chaque SDK pour obtenir la correspondance complète des champs.

Amélioration de la précision par enrichissement contextuel

L'enrichissement contextuel transmet l'historique de conversation au modèle ASR, ce qui améliore considérablement la transcription des noms propres. Pour plus d'informations sur cette fonctionnalité et voir des exemples de résultats, consultez Enrichissement contextuel.

Segmentation des locuteurs

La segmentation des locuteurs identifie automatiquement les différents intervenants dans un flux audio et associe une étiquette à chaque phrase transcrite. Cette option s'avère particulièrement utile pour les réunions multipartites et les enregistrements d'interviews.

Modèles pris en charge : séries Qwen-Audio-3.0-ASR-Flash-Filetrans, Fun-ASR et Paraformer.

Activation : définissez le paramètre diarization_enabled sur true dans votre requête API. Le résultat inclut alors un champ speaker_id pour chaque phrase, permettant d'identifier l'interlocuteur.

Extrait d'une structure de réponse type :

{
  "transcripts": [
    {
      "sentences": [
        { "begin_time": 100, "end_time": 3820, "text": "Hello, let's discuss the project progress today.", "speaker_id": 0 },
        { "begin_time": 3820, "end_time": 6500, "text": "Sure, let me give a quick report first.", "speaker_id": 1 }
      ]
    }
  ]
}

Les conventions de nommage de ces champs varient selon les SDK (clés de dictionnaire, propriétés d'objet ou méthodes). Consultez la référence API correspondante pour obtenir la cartographie complète.

Pour la définition exhaustive des champs, référez-vous à la documentation API.

Filtrage des mots sensibles

Le filtrage des mots sensibles remplace ou supprime certains termes inappropriés dans le résultat de reconnaissance. Il est notamment utilisé pour le contrôle qualité en service client, la conformité des contenus ou la modération des sous-titres.

Modèles compatibles : séries Qwen-Audio-3.0-ASR-Flash-Filetrans, Fun-ASR et Paraformer.

Comportement par défaut : si le paramètre special_word_filter n'est pas spécifié, le système applique automatiquement la liste de mots sensibles intégrée à Model Studio. Les termes détectés sont remplacés par une chaîne d'astérisques * de longueur équivalente.

Configuration personnalisée : le paramètre special_word_filter est un objet JSON composé de trois sous-champs :

• filter_with_signed.word_list : tableau de chaînes contenant les mots sensibles à masquer par des astérisques * de même longueur. Ainsi, avec ["test"], la phrase « Please help me test this » devient « Please help me **** this ».
• filter_with_empty.word_list : tableau de chaînes listant les mots à supprimer intégralement du résultat. Par exemple, avec ["start"], « Is the game about to start now » devient « Is the game about to now ».
• system_reserved_filter : valeur booléenne dont la valeur par défaut est true. Elle détermine si la liste système intégrée doit s'appliquer conjointement à votre liste personnalisée.

Exemple de configuration :

{
  "special_word_filter": {
    "filter_with_signed": {
      "word_list": ["test"]
    },
    "filter_with_empty": {
      "word_list": ["start", "happen"]
    },
    "system_reserved_filter": true
  }
}

Les conventions de nommage de ces paramètres diffèrent selon les SDK (clés de dictionnaire, propriétés d'objet ou méthodes). La référence API fournit la correspondance exacte des champs.

Reconnaissance des émotions

La reconnaissance des émotions est activée en permanence sur les modèles des séries Qwen3-ASR-Flash-Filetrans et Qwen3-ASR-Flash, sans configuration supplémentaire. Le résultat comporte une balise émotionnelle associée au locuteur, choisie parmi sept catégories fines : surprised, neutral, happy, sad, disgusted, angry et fearful.

Chemins d'accès aux champs (variables selon l'API) :

• API compatible OpenAI (transcription temps réel Qwen3-ASR-Flash) : information imbriquée dans choices[].delta.annotations[].emotion (mode streaming) ou choices[].message.annotations[].emotion (mode non streaming).
• API synchrone DashScope (Qwen3-ASR-Flash) : accessible via output.choices[].message.annotations[].emotion.
• API de tâche asynchrone DashScope (transcription de fichiers enregistrés Qwen3-ASR-Flash-Filetrans) : située dans transcripts[].sentences[].emotion, aux côtés des horodatages et identifiants de locuteur de chaque objet phrase.

Extrait d'une structure de réponse type (API de tâche asynchrone DashScope) :

{
  "transcripts": [{
    "sentences": [{
      "begin_time": 0,
      "end_time": 1440,
      "text": "Welcome to Alibaba Cloud.",
      "emotion": "neutral",
      "language": "en"
    }]
  }]
}

Chaque SDK utilise ses propres conventions pour nommer ces champs (clés de dictionnaire, propriétés d'objet ou méthodes). Consultez la référence API pour obtenir la correspondance complète.

Obtention des horodatages

La reconnaissance vocale non temps réel peut intégrer des horodatages dans la transcription, facilitant ainsi la génération de sous-titres, la mise en évidence de mots-clés ou le montage audiovisuel. Les modèles Qwen-Audio-3.0-ASR-Flash-Filetrans, Qwen-Audio-3.0-ASR-Flash, Fun-ASR, Fun-ASR-Flash, Qwen3-ASR-Flash-Filetrans et Paraformer gèrent tous les horodatages, mais leur comportement par défaut et leur méthode de contrôle varient :

• Qwen-Audio-3.0-ASR-Flash-Filetrans/Qwen-Audio-3.0-ASR-Flash/Fun-ASR/Fun-ASR-Flash/Paraformer : les horodatages sont toujours actifs et ne peuvent pas être désactivés.
• Qwen3-ASR-Flash-Filetrans : seuls les appels asynchrones via DashScope fournissent des horodatages (activés par défaut). Utilisez le paramètre de requête enable_words pour ajuster la granularité : laissez-le sur false (défaut) pour un horodatage au niveau de la phrase, ou passez-le à true pour un découpage mot à mot. L'horodatage par mot fonctionne uniquement pour les langues suivantes : chinois, anglais, japonais, coréen, allemand, français, espagnol, italien, portugais et russe. La précision n'est pas garantie pour les autres langues.

Exprimés en millisecondes, les horodatages se déclinent à deux niveaux :

• Niveau phrase : sentences[].begin_time et sentences[].end_time indiquent respectivement le début et la fin de chaque phrase dans le flux audio.
• Niveau mot : tableau sentences[].words[] dont chaque élément comprend begin_time, end_time ainsi que le texte du mot concerné (text).

Extrait d'une structure de réponse type (API de tâche asynchrone DashScope) :

{
  "transcripts": [{
    "sentences": [{
      "begin_time": 100,
      "end_time": 3820,
      "text": "Hello, let's discuss the project progress today.",
      "words": [
        { "begin_time": 100, "end_time": 596, "text": "Hello," },
        { "begin_time": 596, "end_time": 844, "text": "let's" }
      ]
    }]
  }]
}

Les conventions de nommage de ces champs varient selon les SDK (clés de dictionnaire, propriétés d'objet ou méthodes). La référence API détaille la correspondance complète.

Mise en production

Lors du déploiement en production de la reconnaissance vocale non temps réel, adoptez les bonnes pratiques suivantes afin d'optimiser la qualité de reconnaissance et la stabilité du système.

Scénarios à forte concurrence : privilégiez les callbacks au polling

Dans le cadre des tâches de transcription asynchrone (Qwen-Audio-3.0-ASR-Flash-Filetrans, Fun-ASR, Qwen3-ASR-Flash-Filetrans et Paraformer), vous soumettez la requête via POST /api/v1/services/audio/asr/transcription puis récupérez généralement le résultat en interrogeant périodiquement l'API GET /api/v1/tasks/{task_id}. Cette API de requête est limitée à 20 QPS par défaut, extensible jusqu'à 100 QPS. Dans des contextes de traitement par lots à haute concurrence, un polling intensif déclenche rapidement des limitations de débit.

Configurez plutôt des notifications par callback via EventBridge. Dès qu'une tâche s'achève, Model Studio émet automatiquement un événement dashscope:System:AsyncTaskFinish vers la cible définie (endpoint HTTP/HTTPS ou topic RocketMQ). Une fois l'événement reçu, le consommateur n'a plus besoin de solliciter l'API de requête, évitant ainsi tout risque de throttling lié au polling. Pour plus de détails, consultez Configurer les notifications de callback EventBridge.

Modèles pris en charge

• Pris en charge : Qwen-Audio-3.0-ASR-Flash-Filetrans, Fun-ASR, Qwen3-ASR-Flash-Filetrans et Paraformer (toutes tâches de transcription asynchrone).
• Non pris en charge : Qwen3-ASR-Flash (appels synchrones ou en streaming, car il ne s'agit pas de tâches asynchrones).

Contenu du message de callback

Pour ces trois modèles, le corps du message de callback positionne data.contain_result sur true, et data.output_result contient directement transcription_url. Ainsi, dès réception du callback, le consommateur obtient le résultat de reconnaissance sans devoir rappeler GET /api/v1/tasks/{task_id}. Toutefois, le chemin et la structure du champ de résultat diffèrent selon le modèle utilisé. Référez-vous au tableau suivant.

Remarques importantes

Sécurité (livraison HTTP/HTTPS) : en environnement de production, validez systématiquement les en-têtes X-Eventbridge-Signature* de la requête de callback avant de la traiter. À défaut, n'importe quelle IP externe pourrait simuler un événement AsyncTaskFinish et injecter de faux résultats. Définissez également un timeout de réception d'au moins 5 secondes côté destinataire. Le mode RocketMQ, quant à lui, ne comporte pas de signature au niveau du message ; sa sécurité repose entièrement sur le mécanisme d'authentification RocketMQ.

Latence de livraison : le délai entre la fin de la tâche (end_time) et la réception du message par la cible (endpoint HTTP/HTTPS ou topic RocketMQ) varie généralement de 1 à 90 secondes, selon la charge instantanée d'EventBridge.

Idempotence : des tentatives de renvoi peuvent entraîner la livraison multiple du même événement. Implémentez donc un traitement idempotent côté consommateur, en utilisant data.id ou data.task_id du format CloudEvents comme clé de déduplication.

Recommandations pour la production

• Hébergement des fichiers : stockez vos fichiers audio sur Alibaba Cloud OSS et appelez l'API via URL. Évitez les uploads locaux (les appels depuis des fichiers locaux sont plafonnés à 100 QPS et ne peuvent pas monter en charge).
• Polling asynchrone : la transcription d'audio long fonctionne de manière asynchrone. Adoptez un intervalle de polling raisonnable (entre 2 et 5 secondes) pour éviter de saturer votre quota avec des requêtes trop fréquentes. Si vous devez dépasser la limite de 20 à 100 QPS, optez pour les notifications par callback d'événements. Voir Scénarios à forte concurrence : privilégiez les callbacks au polling.
• Gestion des erreurs : mettez en place un mécanisme de retry robuste. Face à des timeouts réseau ou des erreurs serveur temporaires (5xx), appliquez une stratégie de backoff exponentiel.
• Réduction du bruit : prétraitez les enregistrements bruités à l'aide d'un outil comme FFmpeg avant de les soumettre à la reconnaissance.
• Choix du modèle : adaptez le modèle à la durée de l'audio. Pour des extraits courts (< 5 min), utilisez Qwen3-ASR-Flash. Pour des fichiers plus longs (> 5 min), tournez-vous vers Qwen-Audio-3.0-ASR-Flash-Filetrans, Fun-ASR ou Qwen3-ASR-Flash-Filetrans.

Modèles et régions pris en charge

Référence de l'API

• Reconnaissance vocale non temps réel - Référence de l'API Qwen-Audio-3.0-ASR-Flash-Filetrans/Fun-ASR
• Reconnaissance vocale non temps réel - Référence de l'API Qwen-Audio-3.0-ASR-Flash/Fun-ASR-Flash
• Reconnaissance vocale non temps réel - Référence de l'API Qwen-ASR
• Reconnaissance vocale non temps réel - Référence de l'API Paraformer

FAQ

Q : Comment fournir une URL audio accessible publiquement à l'API ?

Utilisez Alibaba Cloud Object Storage Service (OSS). OSS offre un stockage hautement disponible et fiable, et permet de générer une URL d'accès public.

Vérifiez que l'URL générée est accessible sur le réseau public : ouvrez l'URL dans un navigateur ou avec la commande curl pour confirmer que le fichier audio se télécharge ou se lit (code d'état HTTP 200).

Q : Comment vérifier si le format audio respecte les exigences ?

Utilisez l'outil open source ffprobe pour obtenir rapidement des informations détaillées sur l'audio :

# Query the container format (format_name), codec (codec_name), sample rate (sample_rate), and number of channels (channels) of the audio
ffprobe -v error -show_entries format=format_name -show_entries stream=codec_name,sample_rate,channels -of default=noprint_wrappers=1 your_audio_file.mp3

Q : Comment traiter l'audio pour répondre aux exigences du modèle ?

Utilisez l'outil open source FFmpeg pour découper ou convertir l'audio :

• Découper l'audio : extraire un extrait d'un long fichier audio

  # -i: input file
  # -ss 00:01:30: set the trim start time (start at 1 minute 30 seconds)
  # -t 00:02:00: set the trim duration (trim 2 minutes)
  # -c copy: copy the audio stream directly without re-encoding, which is fast
  # output_clip.wav: output file
  ffmpeg -i long_audio.wav -ss 00:01:30 -t 00:02:00 -c copy output_clip.wav
  

• Convertir le format

  Par exemple, convertissez n'importe quel audio en un fichier WAV mono, 16 kHz, 16 bits :

  # -i: input file
  # -ac 1: set the number of channels to 1 (mono)
  # -ar 16000: set the sample rate to 16000 Hz (16 kHz)
  # -sample_fmt s16: set the sample format to 16-bit signed integer PCM
  # output.wav: output file
  ffmpeg -i input.mp3 -ac 1 -ar 16000 -sample_fmt s16 output.wav
  

Q : Comment améliorer la précision de la reconnaissance ?

Les facteurs suivants influencent la précision de la reconnaissance. Vérifiez chacun d'eux et optimisez-les en conséquence.

Facteurs principaux :

1. Qualité audio : la qualité du périphérique d'enregistrement, la fréquence d'échantillonnage et le bruit ambiant affectent directement la clarté de l'audio. Une entrée audio de haute qualité constitue la base d'une reconnaissance précise.
2. Caractéristiques du locuteur : la hauteur de la voix, le débit de parole, l'accent et les différences dialectales (en particulier les dialectes rares ou les accents prononcés) augmentent la difficulté de reconnaissance.
3. Langue et vocabulaire : les mélanges de langues, les termes techniques ou l'argot compliquent la reconnaissance. Configurez des mots-clés pour améliorer la précision des termes spécifiques au domaine.

Méthodes d'optimisation :

1. Améliorez la qualité audio : utilisez un microphone performant, enregistrez à la fréquence d'échantillonnage recommandée et minimisez le bruit ambiant ainsi que l'écho.
2. Adaptez-vous au locuteur : pour les audios avec des accents prononcés ou des dialectes marqués, choisissez un modèle prenant en charge le dialecte correspondant.
3. Configurez des mots-clés : définissez des mots-clés pour les termes techniques, les noms propres et les mots similaires.