Skip to main content

Paraformer non-real-time speech recognition Java SDK

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

Alibaba 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.
Ce 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.
Lorsque 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.
    • 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).
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.
    • 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).
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.
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
modelString
OuiSpécifie le nom du modèle Paraformer pour la transcription de fichiers audio/vidéo. Consultez la liste des modèles pris en charge.
fileUrlsList<String>
OuiListe 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://.
vocabularyIdString
NonIdentifiant 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.
channelIdList<Integer>[0]NonDé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.
Chaque 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.
disfluencyRemovalEnabledBooleanfalseNonFiltre les tics de langage. Désactivé par défaut.
timestampAlignmentEnabledBooleanfalseNonActive ou désactive la fonctionnalité d'alignement des horodatages. Désactivée par défaut.
specialWordFilterString
NonDé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_hintsString[]["zh", "en"]NonSpé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
language_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();
diarizationEnabledBooleanfalseNonDiarisation 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.
Si 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.
speakerCountInteger
NonValeur 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.
apiKeyString
NonClé 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()
AucunrequestIdRetourne le requestId.
public String getTaskId()
AucuntaskIdRetourne le taskId.
public TaskStatus getTaskStatus()
AucunTaskStatus, l'état de la tâcheRetourne 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.
Si 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()
AucunRé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()
AucunRésultat de la tâche au format JSONRetourne 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.
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()
AucunURL du fichier audio reconnuRetourne l'URL du fichier audio reconnu.
public String getTranscriptionUrl()
AucunURL du résultat de reconnaissanceRetourne 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()
AucunTaskStatus, l'état de la sous-tâcheRetourne 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()
AucunInformations 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.
{
    "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.
// 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 TranscriptionQueryParamCré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 TranscriptionParamRé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 TranscriptionQueryParamRé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 TranscriptionQueryParamRé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) :
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.
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.
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).
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.