Tous les produits
Search
Centre de documentation

Alibaba Cloud Model Studio:Paraformer non-real-time speech recognition Java SDK

Dernière mise à jour :Sep 07, 2026

Cette rubrique détaille les paramètres et les interfaces du SDK Java pour la reconnaissance vocale non temps réel Paraformer.

ImportantAlibaba Cloud Model Studio a publié un domaine spécifique à l'espace de travail pour la région Chine (Pékin). Ce nouveau domaine dédié offre des performances supérieures et une stabilité accrue pour les requêtes d'inférence. Nous vous recommandons de migrer de dashscope.aliyuncs.com vers {WorkspaceId}.cn-beijing.maas.aliyuncs.com.

Remplacez {WorkspaceId} par votre véritable ID d'espace de travail. Le domaine existant reste pleinement fonctionnel.

ImportantCe document s'applique uniquement à la région Chine (Pékin). Pour utiliser les modèles, vous devez disposer d'une clé API provenant de la région Chine (Pékin).

Guide d'utilisation :Reconnaissance vocale non temps réel

Prérequis

Vous avez activé le service et obtenu une clé API. Veuillez configurer la clé API comme variable d'environnement plutôt que de la coder en dur dans votre code afin d'éviter les risques de sécurité liés à une fuite de code.

RemarqueLorsque vous devez accorder un accès temporaire à des applications tierces ou à des utilisateurs, ou lorsque vous souhaitez contrôler strictement des opérations sensibles telles que l'accès ou la suppression de données critiques, nous recommandons l'utilisation de jetons d'authentification temporaires.

Contrairement aux clés API permanentes, les jetons d'authentification temporaires ont une durée de validité courte (60 secondes) et offrent une sécurité renforcée. Ils conviennent parfaitement aux scénarios d'appels temporaires et réduisent efficacement le risque de fuite de clé API.

Utilisation : Dans votre code, remplacez la clé API initialement utilisée pour l'authentification par le jeton d'authentification temporaire obtenu.

Démarrage rapide

La classe principale (Transcription) fournit des interfaces pour soumettre des tâches de manière asynchrone, attendre leur achèvement de façon synchrone et interroger les résultats de manière asynchrone. Deux modes d'appel sont disponibles pour la reconnaissance vocale non temps réel :

  • Soumission asynchrone + attente synchrone : Après la soumission d'une tâche, le thread courant est bloqué jusqu'à ce que la tâche se termine et que le résultat de reconnaissance soit obtenu.
  • Soumission asynchrone + requête asynchrone : Une fois la tâche soumise, vous pouvez interroger son résultat à tout moment via l'interface de requête.

Soumission asynchrone + attente synchrone

image
  1. Configurez les paramètres de requête.

  2. Instanciez la classe principale (Transcription).

  3. Appelez la méthode asyncCall de la classe principale (Transcription) pour soumettre une tâche de manière asynchrone.

    Remarque

    • Le service de transcription de fichiers traite les tâches soumises via l'API selon le principe du « best-effort ». Après soumission, une tâche passe à l'état en file d'attente (PENDING). La durée d'attente dépend de la longueur de la file et de la durée du fichier ; elle ne peut être estimée avec précision, mais se termine généralement en quelques minutes. Une fois le traitement lancé, la reconnaissance vocale s'effectue à une vitesse plusieurs centaines de fois supérieure au temps réel.
    • Une fois chaque tâche terminée, le résultat de reconnaissance et le lien de téléchargement URL restent valides pendant 24 heures. Passé ce délai, il n'est plus possible d'interroger la tâche ni de télécharger les résultats via l'URL précédemment fournie.
  4. Appelez la méthode wait de la classe principale (Transcription) pour attendre de manière synchrone la fin de la tâche.

    Les états possibles d'une tâche sont PENDING, RUNNING, SUCCEEDED et FAILED. Tant que la tâche est à l'état PENDING ou RUNNING, l'interface wait reste bloquante. Dès que la tâche atteint l'état SUCCEEDED ou FAILED, l'interface wait se débloque et retourne le résultat.

    La méthode wait retourne le résultat de la tâche (TranscriptionResult).

Cliquez pour voir l'exemple complet

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

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        // The following configuration is for the China (Beijing) region. Replace "{WorkspaceId}" with your actual workspace ID. The configuration varies by region.
        Constants.baseHttpApiUrl = "https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/api/v1";
        // Create transcription request parameters
        TranscriptionParam param =
                TranscriptionParam.builder()
                        // If the API Key is not configured in an environment variable, replace apiKey with your own API Key
                        //.apiKey("apikey")
                        .model("paraformer-v2")
                        // "language_hints" is only supported by the paraformer-v2 model
                        .parameter("language_hints", new String[]{"zh", "en"})
                        .fileUrls(
                                Arrays.asList(
                                        "{YOUR_AUDIO_URL}"))
                        .build();
        try {
            Transcription transcription = new Transcription();
            // Submit transcription request
            TranscriptionResult result = transcription.asyncCall(param);
            System.out.println("RequestId: " + result.getRequestId());
            // Block and wait for the task to complete and get the result
            result = transcription.wait(
                    TranscriptionQueryParam.FromTranscriptionParam(param, result.getTaskId()));
            // Print result
            System.out.println(result.getOutput());
        } catch (Exception e) {
            System.out.println("error: " + e);
        }
        System.exit(0);
    }
}

Soumission asynchrone + requête asynchrone

image
  1. Configurez les paramètres de requête.

  2. Instanciez la classe principale (Transcription).

  3. Appelez la méthode asyncCall de la classe principale (Transcription) pour soumettre une tâche de manière asynchrone.

    Remarque

    • Le service de transcription de fichiers traite les tâches soumises via l'API selon le principe du « best-effort ». Après soumission, une tâche passe à l'état en file d'attente (PENDING). La durée d'attente dépend de la longueur de la file et de la durée du fichier ; elle ne peut être estimée avec précision, mais se termine généralement en quelques minutes. Une fois le traitement lancé, la reconnaissance vocale s'effectue à une vitesse plusieurs centaines de fois supérieure au temps réel.
    • Une fois chaque tâche terminée, le résultat de reconnaissance et le lien de téléchargement URL restent valides pendant 24 heures. Passé ce délai, il n'est plus possible d'interroger la tâche ni de télécharger les résultats via l'URL précédemment fournie.
  4. Appelez en boucle la méthode fetch de la classe principale (Transcription) jusqu'à l'obtention du résultat final.

    Lorsque l'état de la tâche devient SUCCEEDED ou FAILED, arrêtez l'interrogation et traitez le résultat.

    La méthode fetch retourne le résultat de la tâche (TranscriptionResult).

Cliquez pour voir l'exemple complet

import com.alibaba.dashscope.audio.asr.transcription.*;
import com.alibaba.dashscope.common.TaskStatus;
import com.google.gson.*;

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        // The following configuration is for the China (Beijing) region. Replace "{WorkspaceId}" with your actual workspace ID. The configuration varies by region.
        Constants.baseHttpApiUrl = "https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/api/v1";
        // Create transcription request parameters
        TranscriptionParam param =
                TranscriptionParam.builder()
                        // If the API Key is not configured in an environment variable, replace apiKey with your own API Key
                        //.apiKey("apikey")
                        .model("paraformer-v2")
                        // "language_hints" is only supported by the paraformer-v2 model
                        .parameter("language_hints", new String[]{"zh", "en"})
                        .fileUrls(
                                Arrays.asList(
                                        "{YOUR_AUDIO_URL}"))
                        .build();
        try {
            Transcription transcription = new Transcription();
            // Submit transcription request
            TranscriptionResult result = transcription.asyncCall(param);
            System.out.println("RequestId: " + result.getRequestId());
            // Loop to get the task result until the task finishes
            while (true) {
                result = transcription.fetch(TranscriptionQueryParam.FromTranscriptionParam(param, result.getTaskId()));
                if (result.getTaskStatus() == TaskStatus.SUCCEEDED || result.getTaskStatus() == TaskStatus.FAILED) {
                    break;
                }
                Thread.sleep(1000);
            }
            // Print result
            System.out.println(result.getOutput());
        } catch (Exception e) {
            System.out.println("error: " + e);
        }
        System.exit(0);
    }
}

Paramètres de requête

Les paramètres de requête se configurent via les méthodes chaînées de TranscriptionParam.

Cliquez pour voir l'exemple

TranscriptionParam param = TranscriptionParam.builder()
  .model("paraformer-v2")
  // "language_hints" is only supported by the paraformer-v2 model
  .parameter("language_hints", new String[]{"zh", "en"})
  .fileUrls(
          Arrays.asList(
                  "{YOUR_AUDIO_URL}"))
  .build();
ParamètreTypeValeur par défautObligatoireDescription

model

String

Oui

Spécifie le nom du modèle Paraformer pour la transcription de fichiers audio/vidéo. Consultez la liste des modèles pris en charge.

fileUrls

List<String>

Oui

Liste des URL des fichiers audio/vidéo à transcrire. Les protocoles HTTP et HTTPS sont pris en charge. Une seule URL est autorisée par requête.

Si les fichiers audio sont stockés dans Alibaba Cloud OSS, le SDK ne prend pas en charge les URL temporaires avec le préfixe oss://.

vocabularyId

String

Non

Identifiant des mots-clés personnalisés les plus récents. Compatible avec les derniers modèles de la série v2 incluant la configuration linguistique. Les mots-clés associés à cet identifiant s'appliquent à cette reconnaissance vocale. Désactivé par défaut. Pour les instructions d'utilisation, consultez la rubrique Mots-clés personnalisés.

channelId

List<Integer>

[0]

Non

Définit les index des pistes audio à reconnaître dans un fichier multipiste. Les index commencent à 0. Par exemple, [0] correspond à la première piste, tandis que [0, 1] reconnaît simultanément les deux premières pistes. Si ce paramètre est omis, seule la première piste est traitée par défaut.

ImportantChaque piste spécifiée fait l'objet d'une facturation indépendante. Ainsi, demander [0, 1] pour un seul fichier entraîne deux frais distincts.

disfluencyRemovalEnabled

Boolean

false

Non

Filtre les tics de langage. Désactivé par défaut.

timestampAlignmentEnabled

Boolean

false

Non

Active ou désactive la fonctionnalité d'alignement des horodatages. Désactivée par défaut.

specialWordFilter

String

Non

Définit les mots sensibles à traiter lors de la reconnaissance vocale et permet d'appliquer différentes stratégies de traitement selon le mot concerné.

En l'absence de ce paramètre, le système applique sa logique intégrée de filtrage des mots sensibles. Les mots correspondant à la liste des mots sensibles d'Alibaba Cloud Model Studio présents dans les résultats seront remplacés par des astérisques (*) de même longueur.

Si ce paramètre est fourni, les stratégies suivantes peuvent être mises en œuvre :

  • Remplacement par : Les mots sensibles correspondants sont remplacés par des astérisques () de même longueur.
  • Filtrage direct : Suppression complète des mots sensibles correspondants des résultats de reconnaissance.

La valeur de ce paramètre doit être une chaîne JSON respectant la structure suivante :

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

Description des champs JSON :

  • filter_with_signed

    • Type : Object.

    • Obligatoire : Non.

    • Description : Configure la liste des mots sensibles à remplacer par . Les mots correspondants dans les résultats seront remplacés par des astérisques () de même longueur.

    • Exemple : Avec le JSON ci-dessus, le résultat de reconnaissance pour « Aide-moi à tester ce code » deviendrait « Aide-moi à **** ce code ».

    • Champs internes :

      • word_list : Tableau de chaînes listant les mots sensibles à remplacer.
  • filter_with_empty

    • Type : Object.

    • Obligatoire : Non.

    • Description : Configure la liste des mots sensibles à supprimer (filtrer) des résultats de reconnaissance. Les mots correspondants seront entièrement effacés.

    • Exemple : Avec le JSON ci-dessus, le résultat pour « La partie va bientôt commencer, n'est-ce pas ? » deviendrait « La partie va bientôt, n'est-ce pas ? ».

    • Champs internes :

      • word_list : Tableau de chaînes listant les mots sensibles à supprimer complètement (filtrer).
  • system_reserved_filter

    • Type : Boolean.
    • Obligatoire : Non.
    • Valeur par défaut : true.
    • Description : Active ou non les règles intégrées de mots sensibles du système. Si défini sur true, la logique de filtrage native est également activée, et les mots correspondant à la liste des mots sensibles d'Alibaba Cloud Model Studio seront remplacés par des astérisques (*) de même longueur.

language_hints

String[]

["zh", "en"]

Non

Spécifie les codes de langue de la parole à reconnaître.

Ce paramètre s'applique uniquement au modèle paraformer-v2.

Codes de langue pris en charge :

  • zh : Chinois
  • en : Anglais
  • ja : Japonais
  • yue : Cantonais
  • ko : Coréen
  • de : Allemand
  • fr : Français
  • ru : Russe

Remarquelanguage_hints doit être défini via la méthode parameter ou parameters de l'instance TranscriptionParam :

TranscriptionParam param = TranscriptionParam.builder()
  // "language_hints" is only supported by the paraformer-v2 model
  .model("paraformer-v2")
  .parameter("language_hints", new String[]{"zh", "en"})
  .build();
TranscriptionParam param = TranscriptionParam.builder()
  // "language_hints" is only supported by the paraformer-v2 model
  .model("paraformer-v2")
  .parameters(Collections.singletonMap("language_hints", new String[]{"zh", "en"}))
  .build();

diarizationEnabled

Boolean

false

Non

Diarisation automatique des locuteurs. Désactivée par défaut.

Applicable uniquement à l'audio mono. L'audio multicanal ne prend pas en charge la diarisation des locuteurs.

Lorsque cette fonctionnalité est activée, les résultats incluent un champ speaker_id permettant de distinguer les différents interlocuteurs.

RemarqueSi la diarisation est activée, il est recommandé que la durée audio n'excède pas 2 heures, faute de quoi la reconnaissance pourrait échouer ou expirer.

Pour un exemple de speaker_id, consultez la section Description du résultat de reconnaissance.

speakerCount

Integer

Non

Valeur indicative du nombre de locuteurs. Valeurs valides : entiers de 2 à 100 inclus.

Prend effet lorsque la diarisation est activée (diarizationEnabled défini sur true).

Par défaut, le système détermine automatiquement le nombre de locuteurs. Si ce paramètre est configuré, il sert uniquement d'indication à l'algorithme pour tenter de produire le nombre spécifié de locuteurs, sans garantie exacte.

apiKey

String

Non

Clé API. Si elle est déjà configurée dans une variable d'environnement, il est inutile de la définir dans le code. Dans le cas contraire, vous devez la spécifier explicitement.

Réponse

Résultat de la tâche (TranscriptionResult)

L'objet TranscriptionResult encapsule le résultat actuel de la tâche.

Interface/MéthodeParamètreValeur de retourDescription
public String getRequestId()

Aucun

requestId

Retourne le requestId.

public String getTaskId()

Aucun

taskId

Retourne le taskId.

public TaskStatus getTaskStatus()

Aucun

TaskStatus, l'état de la tâche

Retourne l'état de la tâche.

TaskStatus est une classe énumérative. Seuls les quatre états suivants nécessitent votre attention : PENDING, RUNNING, SUCCEEDED et FAILED.

RemarqueSi une tâche contient plusieurs sous-tâches, dès qu'une seule réussit, l'état global est marqué comme SUCCEEDED. Il faut alors vérifier le champ subtask_status pour connaître le résultat individuel de chaque sous-tâche.

public List<TranscriptionTaskResult> getResults()

Aucun

Résultat de sous-tâche (TranscriptionTaskResult)

Retourne le résultat de sous-tâche (TranscriptionTaskResult).

Chaque tâche reconnaît un ou plusieurs fichiers audio. Comme chaque fichier est traité séparément, une tâche correspond à une ou plusieurs sous-tâches.

public JsonObject getOutput()

Aucun

Résultat de la tâche au format JSON

Retourne le résultat de la tâche.

Le résultat est au format JSON. Si vous utilisez l'interface getOutput, vous devrez l'analyser vous-même.

Cliquez pour voir l'exemple JSON

Exemple normal
{
    "task_id":"0795ff8c-b666-4e91-bb8b-xxx",
    "task_status":"SUCCEEDED",
    "submit_time":"2025-02-13 16:12:09.109",
    "scheduled_time":"2025-02-13 16:12:09.128",
    "end_time":"2025-02-13 16:12:10.189",
    "results":[
        {
            "file_url":"{YOUR_AUDIO_URL}",
            "transcription_url":"https://dashscope-result-bj.oss-cn-beijing.aliyuncs.com/prod/paraformer-v2/20250213/16%3A12/3baafe5f-d09d-46c6-8b01-724927670edb-1.json?Expires=1739520730&OSSAccessKeyId=YOUR_ACCESS_KEY_ID&Signature=YOUR_SIGNATURE",
            "subtask_status":"SUCCEEDED"
        }
    ],
    "task_metrics":{
        "TOTAL":1,
        "SUCCEEDED":1,
        "FAILED":0
    }
}
Exemple d'erreur

« code » représente le code d'erreur et « message » le message d'erreur. Ces deux champs n'apparaissent qu'en cas d'erreur. Utilisez-les pour diagnostiquer les problèmes en consultant la section Codes d'erreur.

{
        "task_id": "7bac899c-06ec-4a79-8875-xxxxxxxxxxxx",
        "task_status": "SUCCEEDED",
        "submit_time": "2024-12-16 16:30:59.170",
        "scheduled_time": "2024-12-16 16:30:59.204",
        "end_time": "2024-12-16 16:31:02.375",
        "results": [
            {
                "file_url": "{YOUR_AUDIO_URL}",
                "code": "InvalidFile.DownloadFailed",
                "message": "The audio file cannot be downloaded.",
                "subtask_status": "FAILED"
            }
        ],
        "task_metrics": {
            "TOTAL": 1,
            "SUCCEEDED": 0,
            "FAILED": 1
        }
    }

Résultat de sous-tâche (TranscriptionTaskResult)

L'objet TranscriptionTaskResult encapsule le résultat d'une sous-tâche. Chaque sous-tâche correspond à la reconnaissance d'un seul fichier audio.

Interface/MéthodeParamètreValeur de retourDescription
public String getFileUrl()

Aucun

URL du fichier audio reconnu

Retourne l'URL du fichier audio reconnu.

public String getTranscriptionUrl()

Aucun

URL du résultat de reconnaissance

Retourne l'URL du résultat de reconnaissance. Cette URL est valide pendant 24 heures. Passé ce délai, il n'est plus possible d'interroger la tâche ni de télécharger les résultats via cette URL.

Le résultat est enregistré dans un fichier JSON. Vous pouvez le télécharger via l'URL ci-dessus ou lire directement son contenu via une requête HTTP.

Pour la signification de chaque champ JSON, consultez la section Description du résultat de reconnaissance.

public TaskStatus getSubTaskStatus()

Aucun

TaskStatus, l'état de la sous-tâche

Retourne l'état de la sous-tâche.

TaskStatus est une classe énumérative. Seuls les quatre états suivants nécessitent votre attention : PENDING, RUNNING, SUCCEEDED et FAILED.

public String getMessage()

Aucun

Informations clés durant l'exécution de la tâche (peut être vide)

Retourne les informations clés générées pendant l'exécution.

En cas d'échec, examinez ce contenu pour identifier la cause.

Description du résultat de reconnaissance

Le résultat de reconnaissance est enregistré dans un fichier JSON.

Cliquez pour voir l'exemple de résultat

{
    "file_url":"{YOUR_AUDIO_URL}",
    "properties":{
        "audio_format":"pcm_s16le",
        "channels":[
            0
        ],
        "original_sampling_rate":16000,
        "original_duration_in_milliseconds":3834
    },
    "transcripts":[
        {
            "channel_id":0,
            "content_duration_in_milliseconds":3720,
            "text":"Hello world, this is the Alibaba speech laboratory.",
            "sentences":[
                {
                    "begin_time":100,
                    "end_time":3820,
                    "text":"Hello world, this is the Alibaba speech laboratory.",
                    "sentence_id":1,
                    "speaker_id":0, //This field is only displayed when automatic speaker diarization is enabled
                    "words":[
                        {
                            "begin_time":100,
                            "end_time":596,
                            "text":"Hello ",
                            "punctuation":""
                        },
                        {
                            "begin_time":596,
                            "end_time":844,
                            "text":"world",
                            "punctuation":", "
                        }
                        // Other content omitted here
                    ]
                }
            ]
        }
    ]
}

Les paramètres clés sont les suivants :

Paramètre

Type

Description

audio_format

string

Format audio du fichier source.

channels

array[integer]

Index des pistes audio du fichier source. Retourne [0] pour un audio mono, [0, 1] pour un audio bipiste, etc.

original_sampling_rate

integer

Fréquence d'échantillonnage (Hz) de l'audio dans le fichier source.

original_duration

integer

Durée originale (ms) de l'audio dans le fichier source.

channel_id

integer

Index de la piste audio du résultat de transcription, commençant à 0.

content_duration

integer

Durée (ms) du contenu identifié comme parole dans la piste audio.

Le service de reconnaissance vocale Paraformer ne transcrit et ne mesure que le contenu identifié comme parole, qui sert de base à la facturation. Le contenu non verbal n'est ni mesuré ni facturé. Généralement, la durée de parole effective est inférieure à la durée totale de l'audio. Étant donné que la détection de la parole repose sur un modèle d'IA, un léger écart avec la réalité peut subsister.

transcript

string

Résultat de transcription au niveau du paragraphe.

sentences

array

Résultat de transcription au niveau de la phrase.

words

array

Résultat de transcription au niveau du mot.

begin_time

integer

Horodatage de début (ms).

end_time

integer

Horodatage de fin (ms).

text

string

Texte transcrit.

speaker_id

integer

Index du locuteur actuel, commençant à 0, servant à distinguer les différents intervenants.

Ce champ n'apparaît dans les résultats que si la diarisation des locuteurs est activée.

punctuation

string

Ponctuation prédite après le mot (le cas échéant).

Interfaces principales

Classe de paramètres de requête (TranscriptionQueryParam)

La classe TranscriptionQueryParam intervient lors de l'attente de fin de tâche (appel de la méthode wait de Transcription) ou de l'interrogation du résultat (appel de la méthode fetch de Transcription).

Créez une instance TranscriptionQueryParam via la méthode statique FromTranscriptionParam.

Cliquez pour voir l'exemple

// Create transcription request parameters
TranscriptionParam param =
        TranscriptionParam.builder()
                // If the API Key is not configured in an environment variable, replace apiKey with your own API Key
                //.apiKey("apikey")
                .model("paraformer-v2")
                // "language_hints" is only supported by the paraformer-v2 model
                .parameter("language_hints", new String[]{"zh", "en"})
                .fileUrls(
                        Arrays.asList(
                                "{YOUR_AUDIO_URL}"))
                .build();
try {
    Transcription transcription = new Transcription();
    // Submit transcription request
    TranscriptionResult result = transcription.asyncCall(param);
    System.out.println("RequestId: " + result.getRequestId());
    TranscriptionQueryParam queryParam = TranscriptionQueryParam.FromTranscriptionParam(param, result.getTaskId());

} catch (Exception e) {
    System.out.println("error: " + e);
}
Interface/MéthodeParamètreValeur de retourDescription
public static TranscriptionQueryParam FromTranscriptionParam(TranscriptionParam param, String taskId)
  • param : Instance de TranscriptionParam
  • taskId : Identifiant de la tâche

Instance de TranscriptionQueryParam

Crée une instance TranscriptionQueryParam.

Classe principale (Transcription)

Importez Transcription via « import com.alibaba.dashscope.audio.asr.transcription.*; ». Ses interfaces principales sont détaillées ci-après :

Interface/MéthodeParamètreValeur de retourDescription
public TranscriptionResult asyncCall(TranscriptionParam param)

param : Paramètres de reconnaissance vocale, instance de TranscriptionParam

Résultat de la tâche (TranscriptionResult)

Soumet une tâche de reconnaissance vocale de manière asynchrone.

public TranscriptionResult wait(TranscriptionQueryParam queryParam)

queryParam : Instance de TranscriptionQueryParam

Résultat de la tâche (TranscriptionResult)

Bloque le thread courant jusqu'à la fin de la tâche asynchrone (état SUCCEEDED ou FAILED).

public TranscriptionResult fetch(TranscriptionQueryParam queryParam)

queryParam : Instance de TranscriptionQueryParam

Résultat de la tâche (TranscriptionResult)

Interroge le résultat actuel de la tâche de manière asynchrone.

Codes d'erreur

En cas d'erreur, référez-vous à la section Codes d'erreur pour le dépannage.

Si le problème persiste, rejoignez la communauté des développeurs pour signaler l'incident en fournissant le Request ID afin de faciliter l'investigation.

Lorsqu'une tâche comporte plusieurs sous-tâches, dès qu'une seule réussit, l'état global est marqué comme SUCCEEDED. Vérifiez le champ subtask_status pour déterminer le résultat individuel de chaque sous-tâche.

Exemple de réponse d'erreur :

{
    "task_id": "7bac899c-06ec-4a79-8875-xxxxxxxxxxxx",
    "task_status": "SUCCEEDED",
    "submit_time": "2024-12-16 16:30:59.170",
    "scheduled_time": "2024-12-16 16:30:59.204",
    "end_time": "2024-12-16 16:31:02.375",
    "results": [
        {
            "file_url": "{YOUR_AUDIO_URL}",
            "code": "InvalidFile.DownloadFailed",
            "message": "The audio file cannot be downloaded.",
            "subtask_status": "FAILED"
        }
    ],
    "task_metrics": {
        "TOTAL": 1,
        "SUCCEEDED": 0,
        "FAILED": 1
    }
}

Plus d'exemples

Pour davantage d'exemples, consultez le dépôt GitHub.

FAQ

Questions sur les fonctionnalités

Q : L'audio encodé en Base64 est-il pris en charge ?

Non. L'audio encodé en Base64 n'est pas pris en charge. Seul l'audio accessible via des URL publiques est accepté. Les flux binaires et la reconnaissance directe de fichiers locaux ne sont pas pris en charge.

Q : Comment fournir des fichiers audio via des URL accessibles publiquement ?

Suivez généralement ces étapes (cette approche est générique ; les spécificités varient selon le produit de stockage. Nous recommandons de téléverser vos audios vers Alibaba Cloud OSS) :

1. Choisir une méthode de stockage et d'hébergement

Par exemple :

  • Object Storage Service (recommandé) :

    • Utilisez un service de stockage objet cloud (tel que Alibaba Cloud OSS) pour téléverser les fichiers audio dans un bucket et les rendre accessibles publiquement.
    • Avantages : Haute disponibilité, prise en charge de l'accélération CDN, gestion simplifiée.
  • Serveur Web :

    • Placez les fichiers audio sur un serveur web acceptant les accès HTTP/HTTPS (comme Nginx ou Apache).
    • Avantages : Adapté aux petits projets ou aux tests locaux.
  • Content Delivery Network (CDN) :

    • Hébergez les fichiers audio sur un CDN et accédez-y via l'URL fournie par ce dernier.
    • Avantages : Distribution accélérée des fichiers, idéal pour les scénarios à forte concurrence.

2. Téléverser les fichiers audio

Téléversez les fichiers audio selon la méthode choisie, par exemple :

  • Object Storage Service :

    • Connectez-vous à la console du fournisseur cloud et créez un bucket.
    • Téléversez les fichiers audio et définissez les permissions sur « lecture publique » ou générez des liens d'accès temporaires.
  • Serveur Web :

    • Placez les fichiers audio dans le répertoire dédié du serveur (par exemple /var/www/html/audio/).
    • Assurez-vous que les fichiers sont accessibles via HTTP/HTTPS.

3. Générer une URL accessible publiquement

Par exemple :

  • Object Storage Service :

    • Après le téléversement, le système génère automatiquement une URL d'accès public (généralement au format https://<bucket-name>.<region>.aliyuncs.com/<file-name>).
    • Pour un domaine plus convivial, liez un domaine personnalisé et activez HTTPS.
  • Serveur Web :

    • L'URL d'accès correspond généralement à l'adresse du serveur suivie du chemin du fichier (ex. : https://your-domain.com/audio/file.mp3).
  • CDN :

    • Après configuration de l'accélération CDN, utilisez l'URL fournie (ex. : https://cdn.your-domain.com/audio/file.mp3).

4. Vérifier l'accessibilité de l'URL

Dans un environnement réseau public, assurez-vous que l'URL générée est accessible, par exemple :

  • Ouvrez l'URL dans un navigateur et vérifiez si le fichier audio peut être lu.
  • Utilisez des outils (comme curl ou Postman) pour confirmer que l'URL retourne une réponse HTTP correcte (code 200).

Lors de l'utilisation du SDK, si les fichiers audio sont stockés dans Alibaba Cloud OSS, les URL temporaires avec le préfixe oss:// ne sont pas prises en charge.

Lors de l'utilisation de l'API RESTful, si les fichiers audio sont stockés dans Alibaba Cloud OSS, les URL temporaires avec le préfixe oss:// sont acceptées :

  • L'URL temporaire est valide pendant 48 heures et devient inutilisable après expiration. Ne l'utilisez pas en environnement de production.
  • L'API d'obtention des identifiants de téléversement est limitée à 100 QPS et ne permet pas la mise à l'échelle horizontale. Évitez de l'utiliser en production, dans des scénarios à haute concurrence ou lors de tests de charge.
  • Pour les environnements de production, privilégiez un service de stockage stable tel que OSS afin de garantir la disponibilité à long terme des fichiers et d'éviter les limitations de débit.

Q : Quel est le délai pour obtenir les résultats de reconnaissance ?

Après soumission, la tâche passe en file d'attente (état PENDING). La durée d'attente dépend de la longueur de la file et de la durée du fichier ; elle ne peut être estimée précisément mais se termine généralement en quelques minutes. Merci de patienter. Les fichiers audio plus longs nécessitent un temps de traitement accru.

Dépannage

En cas d'erreurs de code, effectuez un diagnostic en vous basant sur les informations de la section Codes d'erreur.

Q : Que faire si le résultat de reconnaissance et la lecture audio sont désynchronisés ?

Définissez le paramètre de requête timestampAlignmentEnabled sur true pour activer l'alignement des horodatages, ce qui synchronisera le résultat avec la lecture audio.

Q : Impossible d'obtenir des résultats malgré une interrogation continue ?

Cela peut provenir d'une limitation de débit. Veuillez patienter. Si vous avez besoin d'une augmentation de capacité, rejoignez la communauté des développeurs pour en faire la demande.

Q : Pourquoi n'y a-t-il aucun résultat de reconnaissance (impossible de reconnaître la parole) ?

  • Vérifiez si l'audio respecte les exigences (format, fréquence d'échantillonnage).
  • Si vous utilisez le modèle paraformer-v2, assurez-vous que le paramètre language_hints est correctement configuré.
  • Si aucune de ces solutions ne résout le problème, personnalisez des mots-clés pour améliorer la reconnaissance de termes spécifiques.

Questions supplémentaires

Consultez la section QA sur GitHub.