Tous les produits
Search
Centre de documentation

Alibaba Cloud Model Studio:SDK Python de reconnaissance vocale non temps réel Paraformer

Dernière mise à jour :Sep 07, 2026

Utilisez le SDK Python Paraformer pour transcrire des fichiers audio et vidéo via l'API DashScope.

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

ImportantAlibaba Cloud Model Studio a publié un domaine spécifique aux espaces 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.

Guide utilisateur :Reconnaissance vocale non temps réel

Prérequis

Vous avez activé le service et obtenu une clé API. Configurez 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.

RemarquePour accorder un accès temporaire à des applications tierces ou à des utilisateurs, ou pour contrôler strictement des opérations sensibles telles que l'accès ou la suppression de données confidentielles, utilisez des 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 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.

Premiers pas

La classe principale (Transcription) prend en charge deux approches de transcription :

  • Soumission asynchrone + attente synchrone : soumettez une tâche et bloquez l'exécution jusqu'à son achèvement et au retour du résultat.
  • Soumission asynchrone + interrogation asynchrone : soumettez une tâche et interrogez les résultats à tout moment.

Soumission asynchrone + attente synchrone

image
  1. Appelez la méthode async_call de la classe principale (Transcription) et définissez les paramètres de requête.

    Remarque

    • Le service de transcription de fichiers traite les tâches soumises via l'API selon le principe du meilleur 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.
  2. Appelez la méthode wait de la classe principale (Transcription) pour attendre de manière synchrone la fin de la tâche.

    États de la tâche : PENDING, RUNNING, SUCCEEDED, FAILED. L'appel à wait bloque l'exécution durant les états PENDING ou RUNNING. Lorsque la tâche atteint l'état SUCCEEDED ou FAILED, wait retourne le résultat.

    La méthode wait retourne un objet TranscriptionResponse.

Cliquez pour afficher l'exemple complet

from http import HTTPStatus
from dashscope.audio.asr import Transcription
import json

# If you have not configured the API Key in an environment variable,
# uncomment the following line and replace "apiKey" with your own API Key.
# import dashscope
# dashscope.api_key = "apiKey"
# China (Beijing): Replace {WorkspaceId} with your actual workspace ID. The configuration varies by region.
dashscope.base_http_api_url = "https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/api/v1"

task_response = Transcription.async_call(
    model='paraformer-v2',
    file_urls=['{YOUR_AUDIO_URL}'],
    language_hints=['zh', 'en']  # The "language_hints" parameter only supports the paraformer-v2 model.
)

transcribe_response = Transcription.wait(task=task_response.output.task_id)
if transcribe_response.status_code == HTTPStatus.OK:
    print(json.dumps(transcribe_response.output, indent=4, ensure_ascii=False))
    print('transcription done!')

Soumission asynchrone + interrogation asynchrone

image
  1. Appelez la méthode async_call de la classe principale Transcription et définissez les paramètres de requête.

    Remarque

    • Le service de transcription de fichiers traite les tâches soumises via l'API selon le principe du meilleur 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.
  2. Interrogez régulièrement la méthode fetch de la classe principale (Transcription) jusqu'à l'achèvement de la tâche.

    Cessez l'interrogation lorsque l'état est SUCCEEDED ou FAILED et traitez le résultat.

    La méthode fetch retourne un objet TranscriptionResponse.

Cliquez pour afficher l'exemple complet

from http import HTTPStatus
from dashscope.audio.asr import Transcription
import json

# If you have not configured the API Key in an environment variable,
# uncomment the following line and replace "apiKey" with your own API Key.
# import dashscope
# dashscope.api_key = "apiKey"
# China (Beijing): Replace {WorkspaceId} with your actual workspace ID. The configuration varies by region.
dashscope.base_http_api_url = "https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/api/v1"

transcribe_response = Transcription.async_call(
    model='paraformer-v2',
    file_urls=['{YOUR_AUDIO_URL}'],
    language_hints=['zh', 'en']  # The "language_hints" parameter only supports the paraformer-v2 model.
)

while True:
    if transcribe_response.output.task_status == 'SUCCEEDED' or transcribe_response.output.task_status == 'FAILED':
        break
    transcribe_response = Transcription.fetch(task=transcribe_response.output.task_id)

if transcribe_response.status_code == HTTPStatus.OK:
    print(json.dumps(transcribe_response.output, indent=4, ensure_ascii=False))
    print('transcription done!')

Paramètres de requête

Transmettez ces paramètres à la méthode async_call de la classe principale (Transcription).

ParamètreTypeValeur par défautObligatoireDescription

model

str

Oui

Nom du modèle pour la transcription de fichiers audio et vidéo Paraformer. Modèles pris en charge.

file_urls

list[str]

Oui

Liste d'URL pour la transcription de fichiers audio et vidéo. Les protocoles HTTP et HTTPS sont pris en charge. Une seule requête accepte uniquement 1 URL.

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://.

vocabulary_id

str

Non

ID du vocabulaire personnalisé. Pris en charge pour les modèles de la série v2 ; nécessite la configuration de la langue. Désactivé par défaut. Vocabulaires personnalisés.

channel_id

list[int]

[0]

Non

Spécifie les index des pistes audio à reconnaître dans un fichier audio multipiste. Les index commencent à 0. Par exemple, [0] signifie la reconnaissance de la première piste, et [0, 1] signifie la reconnaissance simultanée des première et deuxième pistes. Si ce paramètre est omis, seule la première piste est traitée par défaut.

ImportantChaque piste spécifiée est facturée indépendamment. Par exemple, demander [0, 1] pour un seul fichier entraîne deux facturations distinctes.

disfluency_removal_enabled

bool

False

Non

Filtre les mots de remplissage. Désactivé par défaut.

timestamp_alignment_enabled

bool

False

Non

Active l'alignement des horodatages. Désactivé par défaut.

special_word_filter

str

Non

Spécifie les mots sensibles à traiter lors de la reconnaissance vocale et permet de définir différentes méthodes de traitement pour différents mots sensibles.

Si ce paramètre n'est pas fourni, le système utilise la logique de filtrage des mots sensibles intégrée, et les mots correspondant à la liste des mots sensibles d'Alibaba Cloud Model Studio dans les résultats de reconnaissance seront remplacés par des * de longueur égale.

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

  • Remplacer par : remplace les mots sensibles correspondants par des de longueur égale.
  • Filtrer directement : supprime complètement les mots sensibles correspondants des résultats de reconnaissance.

La valeur de ce paramètre doit être une chaîne JSON avec 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 de reconnaissance seront remplacés par des de longueur égale.

    • Exemple : en utilisant le JSON ci-dessus, le résultat de reconnaissance vocale pour « Aidez-moi à tester ce code » serait « Aidez-moi à **** ce code ».

    • Champs internes :

      • word_list : un 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 complètement supprimés.

    • Exemple : en utilisant le JSON ci-dessus, le résultat de reconnaissance vocale pour « Le jeu est sur le point de commencer, n'est-ce pas ? » serait « Le jeu est sur le point de, n'est-ce pas ? ».

    • Champs internes :

      • word_list : un 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 : indique s'il faut activer les règles de mots sensibles intégrées du système. Lorsqu'il est défini sur true, la logique de filtrage des mots sensibles intégrée du système est également activée, et les mots correspondant à la liste des mots sensibles d'Alibaba Cloud Model Studio dans les résultats de reconnaissance seront remplacés par des * de longueur égale.

language_hints

list[str]

["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

diarization_enabled

bool

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 de reconnaissance incluent un champ speaker_id pour distinguer les différents locuteurs.

RemarqueSi la diarisation des locuteurs est activée, nous recommandons que la durée audio ne dépasse pas 2 heures, faute de quoi la reconnaissance risque d'échouer ou d'expirer.

Pour un exemple de speaker_id, consultez la section Description des résultats de reconnaissance.

speaker_count

int

Non

Nombre de locuteurs de référence. Entier compris entre 2 et 100.

Prend effet uniquement lorsque diarization_enabled est vrai.

Déterminé automatiquement par défaut. La définition de ce paramètre guide l'algorithme mais ne garantit pas le nombre exact.

Réponse

TranscriptionResponse

Un objet TranscriptionResponse contient task_id, task_status et le résultat d'exécution dans la propriété output. Consultez TranscriptionOutput.

Cliquez pour afficher des exemples de structure TranscriptionResponse

Le TranscriptionResponse retourné par async_call n'inclut pas submit_time ni scheduled_time.

{
    "status_code":200,
    "request_id":"251aceab-a6aa-9fc4-b7f7-0cc6d3e2a9f3",
    "code":null,
    "message":"",
    "output":{
        "task_id":"7d0a58a3-1dbe-4de9-8cff-5f48213128b0",
        "task_status":"PENDING"
    },
    "usage":null
}

Pour obtenir submit_time et scheduled_time, utilisez les méthodes wait() ou fetch() au lieu d'utiliser directement la valeur de retour de async_call(). Le TranscriptionResponse retourné par wait() ou fetch() :

{
    "status_code":200,
    "request_id":"251aceab-a6aa-9fc4-b7f7-0cc6d3e2a9f3",
    "code":null,
    "message":"",
    "output":{
        "task_id":"7d0a58a3-1dbe-4de9-8cff-5f48213128b0",
        "task_status":"PENDING",
        "submit_time":"2025-02-13 16:55:08.573",
        "scheduled_time":"2025-02-13 16:55:08.592",
        "task_metrics":{
            "TOTAL":1,
            "SUCCEEDED":0,
            "FAILED":0
        }
    },
    "usage":null
}
{
    "status_code":200,
    "request_id":"d9d530f1-853c-9848-a5f1-f5de59086ff7",
    "code":null,
    "message":"",
    "output":{
        "task_id":"6351feef-9694-45d2-9d32-63454f2ffb8d",
        "task_status":"RUNNING",
        "submit_time":"2025-02-13 17:31:20.681",
        "scheduled_time":"2025-02-13 17:31:20.703",
        "task_metrics":{
            "TOTAL":1,
            "SUCCEEDED":0,
            "FAILED":0
        }
    },
    "usage":null
}
{
    "status_code":200,
    "request_id":"16668704-6702-9e03-8ab7-a32a5d7bb095",
    "code":null,
    "message":"",
    "output":{
        "task_id":"6351feef-9694-45d2-9d32-63454f2ffb8d",
        "task_status":"SUCCEEDED",
        "submit_time":"2025-02-13 17:31:20.681",
        "scheduled_time":"2025-02-13 17:31:20.703",
        "end_time":"2025-02-13 17:31:21.867",
        "results":[
            {
                "file_url":"{YOUR_AUDIO_URL}",
                "transcription_url":"https://dashscope-result-bj.oss-cn-beijing.aliyuncs.com/prod/paraformer-v2/20250213/17%3A31/20ee4e4f-0404-4806-b617-c7d4c62eed19-1.json?Expires=1739525481&OSSAccessKeyId=YOUR_ACCESS_KEY_ID&Signature=YOUR_SIGNATURE",
                "subtask_status":"SUCCEEDED"
            }
        ],
        "task_metrics":{
            "TOTAL":1,
            "SUCCEEDED":1,
            "FAILED":0
        }
    },
    "usage":{
        "duration":9
    }
}
{
    "status_code":200,
    "request_id":"16668704-6702-9e03-8ab7-a32a5d7bb095",
    "code":null,
    "message":"",
    "output":{
        "task_id": "7bac899c-06ec-4a79-8875-xxxxxxxxxxxx",
        "task_status": "FAILED",
        "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
        }
    },
    "usage":{
        "duration":9
    }
}

Paramètres clés :

ParamètreDescription

status_code

Code d'état de la requête HTTP.

code

  • Ignorez le code le plus externe.
  • Dans output.results, le champ code correspond au code d'erreur. Utilisez-le conjointement avec le champ message et reportez-vous aux codes d'erreur pour le dépannage.

message

  • Ignorez le message le plus externe.
  • Le message sous output.results correspond au message d'erreur. Utilisez-le conjointement avec le champ code et reportez-vous aux codes d'erreur pour le dépannage.

task_id

ID de la tâche.

task_status

État de la tâche.

Les quatre états possibles sont PENDING, RUNNING, SUCCEEDED et FAILED.

Lorsqu'une tâche contient plusieurs sous-tâches, si l'une d'elles réussit, l'état global de la tâche est marqué comme SUCCEEDED. Vérifiez le champ subtask_status pour déterminer le résultat de chaque sous-tâche spécifique.

results

Résultats de reconnaissance des sous-tâches.

subtask_status

État de la sous-tâche.

Les quatre états possibles sont PENDING, RUNNING, SUCCEEDED et FAILED.

file_url

URL du fichier audio à reconnaître.

transcription_url

URL correspondant au résultat de reconnaissance audio.

Le résultat de reconnaissance est enregistré dans un fichier JSON. Téléchargez le fichier depuis l'URL indiquée dans transcription_url ou lisez son contenu via une requête HTTP. Pour plus de détails sur le contenu du fichier JSON, consultez la section Description des résultats de reconnaissance.

TranscriptionOutput

Un objet TranscriptionOutput correspond à la propriété output d'un objet TranscriptionResponse et contient le résultat d'exécution de la tâche.

Cliquez pour afficher des exemples de structure TranscriptionOutput

État PENDING

{
    "task_id":"f2f7c2fa-0cd9-4bb2-a283-27b26ee4bb67",
    "task_status":"PENDING",
    "submit_time":"2025-02-13 17:59:27.754",
    "scheduled_time":"2025-02-13 17:59:27.789",
    "task_metrics":{
        "TOTAL":1,
        "SUCCEEDED":0,
        "FAILED":0
    }
}

État RUNNING

{
    "task_id":"f2f7c2fa-0cd9-4bb2-a283-27b26ee4bb67",
    "task_status":"RUNNING",
    "submit_time":"2025-02-13 17:59:27.754",
    "scheduled_time":"2025-02-13 17:59:27.789",
    "task_metrics":{
        "TOTAL":1,
        "SUCCEEDED":0,
        "FAILED":0
    }
}

État SUCCEEDED

{
    "task_id":"f2f7c2fa-0cd9-4bb2-a283-27b26ee4bb67",
    "task_status":"SUCCEEDED",
    "submit_time":"2025-02-13 17:59:27.754",
    "scheduled_time":"2025-02-13 17:59:27.789",
    "end_time":"2025-02-13 17:59:28.828",
    "results":[
        {
            "file_url":"{YOUR_AUDIO_URL}",
            "transcription_url":"https://dashscope-result-bj.oss-cn-beijing.aliyuncs.com/prod/paraformer-v2/20250213/17%3A59/70e737cc-bf8c-418b-b0c8-83fab192a0fa-1.json?Expires=1739527168&OSSAccessKeyId=YOUR_ACCESS_KEY_ID&Signature=YOUR_SIGNATURE",
            "subtask_status":"SUCCEEDED"
        }
    ],
    "task_metrics":{
        "TOTAL":1,
        "SUCCEEDED":1,
        "FAILED":0
    }
}

État FAILED

code correspond au code d'erreur et message au message d'erreur. Retournés uniquement en cas d'erreur. Consultez la section Codes d'erreur.

{
    "task_id": "7bac899c-06ec-4a79-8875-xxxxxxxxxxxx",
    "task_status": "FAILED",
    "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
    }
}

Paramètres importants :

Paramètre

Description

code

Code d'erreur. À utiliser avec le champ message. Consultez la section Codes d'erreur.

message

Message d'erreur. À utiliser avec le champ code. Consultez la section Codes d'erreur.

task_id

ID de la tâche.

task_status

État de la tâche.

Les quatre états possibles sont PENDING, RUNNING, SUCCEEDED et FAILED.

Lorsqu'une tâche contient plusieurs sous-tâches, si l'une d'elles réussit, l'état global de la tâche est marqué comme SUCCEEDED. Vérifiez le champ subtask_status pour déterminer le résultat de chaque sous-tâche spécifique.

results

Résultats de reconnaissance des sous-tâches.

subtask_status

État de la sous-tâche.

Les quatre états possibles sont PENDING, RUNNING, SUCCEEDED et FAILED.

file_url

URL du fichier audio à reconnaître.

transcription_url

URL correspondant au résultat de reconnaissance audio.

Le résultat de reconnaissance est enregistré dans un fichier JSON. Téléchargez le fichier depuis transcription_url ou lisez son contenu via une requête HTTP. Pour plus de détails sur le contenu JSON, consultez la section Description des résultats de reconnaissance.

Description des résultats de reconnaissance

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

Cliquez pour afficher un exemple de résultat de reconnaissance

{
    "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]

Informations sur l'index des pistes audio du fichier source. Retourne [0] pour l'audio mono, [0, 1] pour l'audio à deux pistes, etc.

original_sampling_rate

integer

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

original_duration

integer

Durée audio originale (ms) du 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 modèle de reconnaissance vocale Paraformer transcrit et mesure uniquement le contenu identifié comme parole dans la piste audio, et facture en conséquence. Le contenu non vocal n'est ni mesuré ni facturé. Généralement, la durée du contenu vocal est inférieure à la durée audio originale. Étant donné que la détermination de la présence de contenu vocal est effectuée par un modèle d'IA, il peut exister un certain écart par rapport à la réalité.

transcript

string

Résultat de transcription vocale au niveau du paragraphe.

sentences

array

Résultat de transcription vocale au niveau de la phrase.

words

array

Résultat de transcription vocale au niveau du mot.

begin_time

integer

Horodatage de début (ms).

end_time

integer

Horodatage de fin (ms).

text

string

Résultat de transcription vocale.

speaker_id

integer

Index du locuteur actuel, commençant à 0, utilisé pour distinguer les différents locuteurs.

Ce champ s'affiche uniquement dans les résultats de reconnaissance lorsque la diarisation des locuteurs est activée.

punctuation

string

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

Référence API

Classe principale (Transcription)

Importez la classe Transcription : from dashscope.audio.asr import Transcription.

Méthode membreSignature de la méthodeDescription

async_call

@classmethod
def async_call(cls,
               model: str,
               file_urls: List[str],
               phrase_id: str = None,
               api_key: str = None,
               workspace: str = None,
               **kwargs) -> TranscriptionResponse

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

Cette méthode retourne un objet TranscriptionResponse.

wait

@classmethod
def wait(cls,
         task: Union[str, TranscriptionResponse],
         api_key: str = None,
         workspace: str = None,
         **kwargs) -> TranscriptionResponse

Bloque le thread actuel jusqu'à l'achèvement de la tâche asynchrone (l'état est SUCCEEDED ou FAILED).

Cette méthode retourne un objet TranscriptionResponse.

fetch

@classmethod
def fetch(cls,
          task: Union[str, TranscriptionResponse],
          api_key: str = None,
          workspace: str = None,
          **kwargs) -> TranscriptionResponse

Interroge de manière asynchrone le résultat d'exécution de la tâche.

Cette méthode retourne un objet TranscriptionResponse.

Codes d'erreur

En cas d'erreur, consultez la section Codes d'erreur pour le dépannage.

Si le problème persiste, rejoignez la communauté des développeurs pour signaler le problème et fournir l'ID de requête pour une investigation plus approfondie.

Lorsqu'une tâche contient plusieurs sous-tâches, tant qu'une sous-tâche réussit, l'état global de la tâche est marqué comme SUCCEEDED. Vérifiez le champ subtask_status pour déterminer le résultat 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

Découvrez davantage d'exemples sur GitHub.

FAQ

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 sous forme d'URL accessibles publiquement ?

Suivez généralement ces étapes (cette procédure fournit une approche générale ; les spécificités varient selon le produit de stockage. Nous recommandons de télécharger l'audio sur Alibaba Cloud OSS) :

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

Par exemple :

  • Object Storage Service (recommandé) :

    • Utilisez le service de stockage objet d'un fournisseur cloud (tel que Alibaba Cloud OSS) pour télécharger des fichiers audio dans un bucket et les configurer en accès public.
    • 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 prenant en charge l'accès HTTP/HTTPS (tel que 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 le CDN.
    • Avantages : diffusion accélérée des fichiers, adapté aux scénarios à forte concurrence.

2. Télécharger les fichiers audio

Téléchargez les fichiers audio en fonction de la méthode de stockage/hébergement choisie, par exemple :

  • Object Storage Service :

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

    • Placez les fichiers audio dans le répertoire désigné du serveur (tel que /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échargement, 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>).
    • Si vous avez besoin d'un domaine plus convivial, vous pouvez lier un domaine personnalisé et activer HTTPS.
  • Serveur Web :

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

    • Après avoir configuré l'accélération CDN, utilisez l'URL fournie par le CDN (telle que 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 (tels que curl ou Postman) pour vérifier si l'URL retourne une réponse HTTP correcte (code d'état 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 prises en charge :

  • L'URL temporaire est valide pendant 48 heures et ne peut plus être utilisée après expiration. Ne l'utilisez pas dans un environnement de production.
  • L'API pour obtenir un identifiant de téléchargement est limitée à 100 QPS et ne prend pas en charge la mise à l'échelle horizontale. Ne l'utilisez pas dans des environnements de production, des scénarios à forte concurrence ou des scénarios de test de charge.
  • Pour les environnements de production, utilisez un service de stockage stable tel que OSS afin de garantir la disponibilité à long terme des fichiers et d'éviter les problèmes de limitation de débit.

Q : Combien de temps faut-il pour obtenir les résultats de reconnaissance ?

Après soumission, la 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. Veuillez patienter. Les fichiers audio plus longs nécessitent un temps de traitement plus important.

Dépannage

Pour les erreurs de code, consultez la section Codes d'erreur.

Q : Que faire si les résultats de reconnaissance ne sont pas synchronisés avec la lecture audio ?

Définissez le paramètre de requête timestamp_alignment_enabled sur true pour activer la calibration des horodatages, ce qui synchronise les résultats de reconnaissance avec la lecture vocale.

Q : Que faire si la tâche retourne une erreur InvalidFile.DownloadFailed ?

Vérifiez si l'URL du fichier contient des espaces ou d'autres caractères non ASCII (tels que des caractères chinois). Si le nom du fichier comprend des espaces (par exemple, my audio recording.mp4), remplacez chaque espace par %20 pour encoder l'URL du nom de fichier avant de le transmettre au paramètre file_urls.

Q : Impossible d'obtenir des résultats après une interrogation continue ?

Cela peut être dû à une limitation de débit. Veuillez patienter. Si vous avez besoin d'une extension 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 répond aux exigences (format, taux d'échantillonnage).
  • Si vous utilisez le modèle paraformer-v2, vérifiez si le paramètre language_hints est correct.
  • Si aucune des solutions ci-dessus ne résout le problème, personnalisez des mots clés pour améliorer la reconnaissance de mots spécifiques.

Autres questions

Consultez la page QA sur GitHub.