Alibaba Cloud Model Studio:Améliorer la précision de la reconnaissance

La reconnaissance vocale de Model Studio propose deux méthodes pour accroître la précision des termes spécialisés, des noms de produits et d'autres vocabulaires métier : les mots clés personnalisés et l'amélioration contextuelle. Cette rubrique détaille le périmètre et l'utilisation de chaque approche.

Présentation

Certains termes métier, tels que les noms de produits, les noms propres et le jargon industriel, sont absents du vocabulaire général d'un modèle et sont donc reconnus avec moins de précision. La reconnaissance vocale de Model Studio offre trois moyens d'améliorer la reconnaissance de ces termes : les mots clés précompilés, les mots clés instantanés et l'amélioration contextuelle.

Mots clés précompilés contre mots clés instantanés contre amélioration contextuelle

Les mots clés personnalisés se présentent sous deux formes : les mots clés précompilés et les mots clés instantanés. Le tableau suivant compare ces trois approches, qui s'appliquent à différents modèles et API :

Prérequis

• Vous avez obtenu une clé API et l'avez configurée comme variable d'environnement.
• Pour appeler le service via le SDK DashScope, installez la dernière version du SDK.

Mots clés précompilés

Créez une liste de mots clés à l'avance, obtenez son ID de liste et transmettez cet ID lors de la reconnaissance. Cette approche convient aux scénarios où le vocabulaire est connu et relativement stable, et où vous devez réutiliser la même liste de mots entre les requêtes, comme pour les noms de produits ou les termes médicaux.

Modèles et régions pris en charge

Démarrage rapide

Flux de travail

Créez d'abord une liste de mots clés, puis référencez son ID lors de la reconnaissance vocale :

1. Créez une liste de mots clés.

   Appelez l'API create-hotword-list. Vous devez spécifier target_model (targetModel en Java) pour indiquer à quel modèle de reconnaissance vocale la liste appartient.

   Si vous possédez déjà une liste de mots clés (vérifiable via l'API list-all-hotword-lists), ignorez cette étape.

2. Appelez l'API de reconnaissance vocale et transmettez l'ID de la liste de mots clés.

   Le modèle utilisé pour la reconnaissance doit correspondre au paramètre target_model (targetModel en Java) spécifié lors de la création de la liste. Sinon, les mots clés ne prennent pas effet.

Exemple de code

Exemple de bout en bout : créez une liste de mots clés, exécutez une reconnaissance vocale, puis supprimez la liste.

import dashscope
from dashscope.audio.asr import *
import os

# The API Key differs between the Beijing and Singapore regions. Get an API Key: https://www.alibabacloud.com/help/zh/model-studio/get-api-key
# If the environment variable is not configured, replace the line below with: dashscope.api_key = "sk-xxx"
dashscope.api_key = os.environ.get('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.
dashscope.base_http_api_url = 'https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/api/v1'

# 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_websocket_api_url = 'wss://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/api-ws/v1/inference'
prefix = 'testpfx'
target_model = "qwen-audio-3.0-asr-flash-streaming"

my_vocabulary = [
    {"text": "Speech Lab", "weight": 4}
]

service = VocabularyService()
vocabulary_id = service.create_vocabulary(
      prefix=prefix,
      target_model=target_model,
      vocabulary=my_vocabulary)

try:
    if service.query_vocabulary(vocabulary_id)['status'] == 'OK':
        recognition = Recognition(model=target_model,
                              format='wav',
                              sample_rate=16000,
                              callback=None)
        result = recognition.call('{YOUR_AUDIO_FILE}', phrase_id=vocabulary_id)
        print(result.output)
finally:
    # Delete the hotword list regardless of whether recognition succeeds, to avoid consuming quota
    service.delete_vocabulary(vocabulary_id)

import com.alibaba.dashscope.audio.asr.recognition.Recognition;
import com.alibaba.dashscope.audio.asr.recognition.RecognitionParam;
import com.alibaba.dashscope.audio.asr.vocabulary.Vocabulary;
import com.alibaba.dashscope.audio.asr.vocabulary.VocabularyService;
import com.alibaba.dashscope.exception.InputRequiredException;
import com.alibaba.dashscope.exception.NoApiKeyException;
import com.alibaba.dashscope.utils.Constants;
import com.google.gson.JsonArray;
import com.google.gson.JsonObject;

import java.io.File;
import java.util.ArrayList;
import java.util.List;

public class Main {
    // The API Key differs between the Beijing and Singapore regions. Get an API Key: https://www.alibabacloud.com/help/en/model-studio/get-api-key
    // If the environment variable is not configured, replace the line below with: public static String apiKey = "sk-xxx"
    public static String apiKey = System.getenv("DASHSCOPE_API_KEY");

    public static void main(String[] args) throws NoApiKeyException, InputRequiredException {
        // 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";
        // The following is the configuration for the Singapore region. When calling, replace "{WorkspaceId}" with your actual workspace ID. The configuration differs by region.
        Constants.baseWebsocketApiUrl = "wss://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/api-ws/v1/inference";

        String targetModel = "qwen-audio-3.0-asr-flash-streaming";

        JsonArray vocabularyJson = new JsonArray();
        List<Hotword> wordList = new ArrayList<>();
        wordList.add(new Hotword("Speech Lab", 4));

        for (Hotword word : wordList) {
            JsonObject jsonObject = new JsonObject();
            jsonObject.addProperty("text", word.text);
            jsonObject.addProperty("weight", word.weight);
            vocabularyJson.add(jsonObject);
        }

        VocabularyService service = new VocabularyService(apiKey);
        Vocabulary vocabulary = service.createVocabulary(targetModel, "testpfx", vocabularyJson);

        try {
            if ("OK".equals(service.queryVocabulary(vocabulary.getVocabularyId()).getStatus())) {
                Recognition recognizer = new Recognition();
                RecognitionParam param =
                        RecognitionParam.builder()
                                .model(targetModel)
                                .apiKey(apiKey)
                                .format("wav")
                                .sampleRate(16000)
                                .vocabularyId(vocabulary.getVocabularyId())
                                .build();

                try {
                    System.out.println("Recognition result: " + recognizer.call(param, new File("{YOUR_AUDIO_FILE}")));
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    // Close the WebSocket connection
                    recognizer.getDuplexApi().close(1000, "bye");
                }
            }
        } finally {
            // Delete the hotword list regardless of whether recognition succeeds, to avoid consuming quota
            service.deleteVocabulary(vocabulary.getVocabularyId());
        }
        System.exit(0);
    }
}

class Hotword {
    String text;
    int weight;

    public Hotword(String text, int weight) {
        this.text = text;
        this.weight = weight;
    }
}

Format des mots clés

Soumettez les mots clés sous forme de tableau JSON, où chaque élément définit un mot clé unique et ses attributs.

Exemple : Améliorer la précision de reconnaissance des titres de films.

[
    {"text": "Warriors of the Rainbow: Seediq Bale", "weight": 4, "lang": "en"},
    {"text": "Seediq Bale", "weight": 4, "lang": "en"},
    {"text": "Goodbye Mr. Loser", "weight": 4, "lang": "en"},
    {"text": "Never Say Die", "weight": 4, "lang": "en"},
    {"text": "Confucius Family", "weight": 4, "lang": "en"},
    {"text": "Confucius' Family", "weight": 4, "lang": "en"}
]

Description des champs :

Mots clés instantanés

Les mots clés instantanés sont transmis sous forme de paires clé-valeur vocabulary directement dans la requête de reconnaissance. Ils constituent essentiellement un ensemble de mots clés pondérés, identiques à la liste utilisée par les mots clés précompilés, sauf qu'ils sont transmis en ligne avec la requête et ne nécessitent aucune liste précréée. Cela convient à l'ajustement temporaire de mots clés au niveau de la session. Lorsque des mots clés instantanés et des mots clés précompilés (vocabulary_id) sont configurés simultanément, seuls les mots clés instantanés prennent effet.

Modèles et régions pris en charge

Démarrage rapide

Transmettez vocabulary dans les parameters de la requête de reconnaissance. Aucune liste de mots clés n'est requise. Pour l'utilisation détaillée de chaque API, consultez la référence API sous Speech-to-text.

Exemple (reconnaissance vocale non temps réel) :

curl --location --request POST 'https://dashscope.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": "https://dashscope.oss-cn-beijing.aliyuncs.com/samples/audio/paraformer/hello_world_female2.wav"
                        }
                    }
                ]
            }
        ]
    },
    "parameters": {
        "format": "wav",
        "sample_rate": "16000",
        "vocabulary": {"John": 5, "Jane": 5}
    }
}'

Format des mots clés

Transmettez les mots clés instantanés sous forme d'objet JSON (paires clé-valeur) : la clé est le texte du mot clé (string), et la valeur est le poids du mot clé (integer). Pour les règles relatives au texte des mots clés, consultez Règles relatives au texte des mots clés.

Exemple :

{"Michael": 5, "Jennifer": 5, "Speech Lab": 50}

Le poids varie sur [1, 5] ou 50 : les valeurs dans [1, 5] définissent des mots clés standard, où une valeur plus élevée indique une préférence plus forte ; 50 définit un super mot clé, qui améliore considérablement le rappel. Vous pouvez avoir au maximum 50 super mots clés. Pour l'ajustement des poids, consultez Ajuster les poids des mots clés.

Ajustement et règles des mots clés

Les règles de texte et les conseils d'ajustement suivants s'appliquent aux mots clés précompilés et instantanés.

Règles relatives au texte des mots clés

Un mot clé doit être un mot réel. Les limites de longueur suivantes s'appliquent :

• Avec des caractères non ASCII : Le nombre total de caractères (la somme des caractères non ASCII tels que les caractères chinois, les kana japonais, le hangul coréen et les lettres cyrilliques, plus tous les caractères ASCII) ne doit pas dépasser 15.

  Exemples :

  • Valide : "厄洛替尼盐酸盐" (7 caractères)
  • Valide : "EGFR抑制剂" (7 caractères, où EGFR compte pour 4 caractères ASCII)
  • Valide : "こんにちは" (5 caractères)
  • Valide : "Фенибут Белфарм" (15 caractères, y compris l'espace au milieu)
  • Invalide : "Клофелин Белмедпрепараты" (24 caractères)

• Avec uniquement des caractères ASCII : Après division sur les espaces, le nombre de segments ne doit pas dépasser 7.

  Exemples :

  • Valide : "Exothermic reaction" → 2 segments
  • Valide : "Human immunodeficiency virus type 1" → 5 segments
  • Invalide : "The effect of temperature variations on enzyme activity in biochemical reactions" → 11 segments

Ajuster les poids des mots clés

Le poids contrôle la force avec laquelle le modèle privilégie un mot clé. Un réglage approprié améliore la précision de reconnaissance des mots cibles tout en évitant les erreurs de reconnaissance.

Commencez les tests avec weight=4 et ajustez en fonction des résultats.

Super mots clés (weight=50) : Les mots clés précompilés et instantanés prennent en charge les super mots clés, mais uniquement les séries de modèles Qwen-Audio-ASR-Message, Qwen-Audio-ASR-Streaming, Qwen-Audio-ASR-Filetrans et Qwen-Audio-ASR. Un poids de 50 améliore considérablement le rappel. Vous pouvez avoir au maximum 50 super mots clés.

Recommandations de conception

• Regrouper par scénario : Organisez les mots clés séparément pour différents scénarios métier (par exemple, un groupe pour les termes médicaux et un autre pour les noms de produits) afin de simplifier la maintenance et la réutilisation. Pour les mots clés précompilés, créez une liste distincte pour chaque scénario.
• Mélanger les langues (mots clés précompilés) : Une seule liste peut contenir des mots clés dans différentes langues, distingués par le champ lang. Lorsque vous spécifiez language_hints lors de la reconnaissance, seuls les mots clés dans cette langue prennent effet.
• Nettoyer régulièrement (mots clés précompilés) : Supprimez les listes de mots clés inutilisées pour libérer votre quota (jusqu'à 10 par compte).

Limites et facturation des mots clés

Amélioration contextuelle

Modèles et régions pris en charge

Démarrage rapide

L'amélioration contextuelle ne nécessite aucune ressource précréée. Transmettez les paramètres de contexte directement dans la requête de reconnaissance :

• Reconnaissance vocale non temps réel : Transmettez les messages de contexte dans input.messages de la requête HTTP, placés avant le message audio.
• Reconnaissance vocale temps réel : Transmettez les messages de contexte dans input.context de l'événement WebSocket run-task. Le SDK DashScope encapsule ce protocole, vous pouvez donc transmettre le contexte directement via un paramètre.

Cas d'utilisation : Transmettre l'historique des conversations ou des termes métier comme contexte améliore considérablement la précision de transcription des noms propres tels que les noms de personnes, les noms de lieux et les termes produits. Le contexte peut être un historique de conversation multi-tours (les résultats de reconnaissance et les réponses du modèle des tours précédents) ou simplement un ensemble de termes métier ou une liste de mots.

{
    "model": "qwen-audio-3.0-asr-flash",
    "input": {
        "messages": [
            {
                "role": "user",
                "content": [
                    {
                        "type": "input_text",
                        "text": "Recognition result of the user's speech in the previous turn"
                    }
                ]
            },
            {
                "role": "assistant",
                "content": [
                    {
                        "type": "text",
                        "text": "Response content of the large model in the previous turn"
                    }
                ]
            },
            {
                "role": "user",
                "content": [
                    {
                        "type": "input_audio",
                        "input_audio": {
                            "data": "URL or Base64 of the audio to be recognized in the current turn"
                        }
                    }
                ]
            }
        ]
    },
    "parameters": {}
}

{
    "header": {
        "action": "run-task",
        "task_id": "2bf83b9a-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
        "streaming": "duplex"
    },
    "payload": {
        "task_group": "audio",
        "task": "asr",
        "function": "recognition",
        "model": "qwen-audio-3.0-asr-flash-streaming",
        "parameters": {
            "format": "pcm",
            "sample_rate": 16000
        },
        "input": {
            "context": [
                {
                    "role": "user",
                    "content": [
                        {
                            "type": "input_text",
                            "text": "Recognition result of the user's speech in the previous turn"
                        }
                    ]
                },
                {
                    "role": "assistant",
                    "content": [
                        {
                            "type": "text",
                            "text": "Response content of the large model in the previous turn"
                        }
                    ]
                }
            ]
        }
    }
}

from dashscope.audio.asr import Recognition

recognition = Recognition(
    model='qwen-audio-3.0-asr-flash-streaming',
    format='wav',
    sample_rate=16000,
    callback=None)

context = {
    "context": [
        {
            "role": "user",
            "content": [
                {
                    "type": "input_text",
                    "text": "Recognition result of the user's speech in the previous turn"
                }
            ]
        },
        {
            "role": "assistant",
            "content": [
                {
                    "type": "text",
                    "text": "Response content of the large model in the previous turn"
                }
            ]
        }
    ]
}

result = recognition.call('audio.wav', raw_input=context)
print(result.output)

Map<String, Object> userContent = new HashMap<>();
userContent.put("type", "input_text");
userContent.put("text", "Recognition result of the user's speech in the previous turn");

Map<String, Object> assistantContent = new HashMap<>();
assistantContent.put("type", "text");
assistantContent.put("text", "Response content of the large model in the previous turn");

Map<String, Object> userMessage = new HashMap<>();
userMessage.put("role", "user");
userMessage.put("content", Arrays.asList(userContent));

Map<String, Object> assistantMessage = new HashMap<>();
assistantMessage.put("role", "assistant");
assistantMessage.put("content", Arrays.asList(assistantContent));

Map<String, Object> input = new HashMap<>();
input.put("context", Arrays.asList(userMessage, assistantMessage));

RecognitionParam param = RecognitionParam.builder()
        .model("qwen-audio-3.0-asr-flash-streaming")
        .format("wav")
        .sampleRate(16000)
        .input(input)
        .build();

Recognition recognizer = new Recognition();
System.out.println(recognizer.call(param, new File("audio.wav")));
recognizer.getDuplexApi().close(1000, "bye");

Exemple

Le champ text du contexte accepte un format flexible — une liste de mots, un paragraphe en langage naturel ou un mélange des deux — et tolère largement le texte non pertinent.

Le résultat de reconnaissance correct pour un extrait audio devrait être : « Combien de termes du jargon interne du monde de la banque d'investissement connaissez-vous ? D'abord, les neuf grandes banques d'investissement étrangères — Bulge Bracket, BB... ».

Pour obtenir cette amélioration, ajoutez une liste de mots ou un paragraphe en langage naturel incluant des termes spécialisés tels que « Bulge Bracket » au champ text du contexte.

Référence API

• Référence API des mots clés précompilés
• Reconnaissance vocale temps réel - Référence API Qwen-Audio-ASR-Streaming
• Reconnaissance vocale temps réel - Référence API Fun-ASR-Realtime
• Reconnaissance vocale temps réel - Référence API Qwen-ASR
• Reconnaissance vocale temps réel - Référence API Paraformer
• Reconnaissance vocale non temps réel - Référence API Qwen-Audio-ASR-Filetrans/Fun-ASR
• Reconnaissance vocale non temps réel - Référence API Qwen-Audio-ASR/Fun-ASR-Flash
• Reconnaissance vocale non temps réel - Référence API Qwen-ASR
• Reconnaissance vocale non temps réel - Référence API Paraformer

FAQ

Q : La reconnaissance ne s'améliore pas après la configuration des mots clés ?

Vérifiez les points suivants dans l'ordre :

1. Correspondance du modèle (mots clés précompilés) : Le target_model spécifié lors de la création de la liste de mots clés doit correspondre au modèle utilisé par l'API de reconnaissance vocale. Si les deux ne correspondent pas, l'API ne renvoie pas d'erreur et la reconnaissance produit toujours des résultats, mais les mots clés ne prennent pas effet. Si les résultats ne contiennent pas les mots clés attendus, vérifiez ce point en premier.
2. Prise en charge par le modèle
3. Poids : Augmentez le poids de 4 à 5 et observez l'effet. Si des mots à la sonorité similaire sont reconnus à tort comme le mot clé, revenez à 4.
4. État de la liste de mots clés (mots clés précompilés) : Utilisez l'API de requête pour confirmer que le status est OK.

Q : Les mots clés précompilés s'utilisent-ils de la même manière en reconnaissance vocale temps réel et non temps réel ?

Ils sont créés de la même manière mais appelés différemment :

• Reconnaissance vocale temps réel : Transmettez vocabulary_id dans les paramètres de connexion Recognition ou WebSocket.
• Transcription de fichiers audio : Transmettez vocabulary_id dans les paramètres de la requête Transcription.

Dans les deux cas, le target_model doit correspondre au modèle de reconnaissance vocale réellement appelé. Les mots clés instantanés ne nécessitent ni liste ni target_model ; transmettez simplement des paires clé-valeur vocabulary dans les paramètres de la requête.

Q : Outre les mots clés et l'amélioration contextuelle, quels autres moyens permettent d'améliorer la précision de la reconnaissance ?

Vous pouvez également optimiser la reconnaissance des manières suivantes :

• Qualité audio : Adaptez le taux d'échantillonnage aux exigences du modèle (16 kHz ou 8 kHz) et réduisez le bruit de fond.
• Choix du modèle adapté : Différents scénarios requièrent différents modèles. Pour plus de détails, consultez le guide de sélection Speech-to-text.
• Spécification de la langue : Déclarez la langue de l'audio via language_hints pour améliorer la précision dans les scénarios monolingues.