Tous les produits
Search
Centre de documentation

Alibaba Cloud Model Studio:Qwen-Audio-ASR-Filetrans non-real-time speech recognition Python SDK

Dernière mise à jour :Oct 29, 2026

Cette rubrique détaille les paramètres et les interfaces du SDK Python de reconnaissance vocale hors temps réel Qwen-Audio-ASR-Filetrans.

Pour les prérequis d'entrée (formats audio pris en charge, limites de taille de fichier et de durée), reportez-vous à la section Spécifications audio.

Prérequis

Démarrage rapide

Les exemples suivants utilisent DashScope Python SDK 2.0. La Ressource principale (client.audio.asr) fournit des méthodes pour soumettre, attendre et interroger les tâches de deux façons :

  • Soumission asynchrone avec attente synchrone : après la soumission de la tâche, le thread actuel se bloque jusqu'à la fin de la tâche, puis le résultat de reconnaissance est retourné.
  • Soumission asynchrone avec interrogation asynchrone : après la soumission de la tâche, appelez l'interface d'interrogation pour récupérer le résultat au moment souhaité.

Soumission asynchrone et attente synchrone

Soumettre une tâche et attendre
  1. Appelez client.audio.asr.jobs.create pour soumettre une tâche avec les paramètres de requête.

    Remarque

    • Le service de transcription de fichiers traite les tâches soumises via l'API au mieux de ses capacités. Une fois soumise, une tâche passe à l'état mis en file d'attente (PENDING). Le temps d'attente dépend de la longueur de la file et de la durée du fichier ; il ne peut donc pas être déterminé avec précision, mais reste généralement inférieur à quelques minutes. Dès que le traitement commence, la reconnaissance vocale s'effectue à une vitesse des centaines de fois supérieure au temps réel.
    • Une fois chaque tâche terminée, le résultat de reconnaissance et l'URL de téléchargement restent valides pendant 24 heures. Passé ce délai, vous ne pouvez plus interroger la tâche ni télécharger le résultat via l'URL retournée lors d'une requête précédente.
  2. Appelez client.audio.asr.jobs.wait(job=job) pour attendre la fin de la tâche de manière synchrone.

    Tant que la tâche est PENDING ou RUNNING, jobs.wait continue d’attendre. La méthode renvoie un Job lorsque la tâche réussit.

    Les méthodes renvoient un Job. Consultez la liste des résultats dans job.results ; chaque transcription_url pointe vers un résultat de transcription téléchargeable.

import json
import os

import dashscope

# Remplacez {WorkspaceId} par l’ID réel de l’espace de travail de la région.
client = dashscope.Client(
    api_key=os.environ["DASHSCOPE_API_KEY"],
    workspace="{WorkspaceId}",
    region="ap-southeast-1",
)

job = client.audio.asr.jobs.create(
    model="qwen-audio-3.0-asr-flash-filetrans",
    file_urls=["{YOUR_AUDIO_URL}"],
)

job = client.audio.asr.jobs.wait(job=job)

print(json.dumps(job.model_dump(), indent=4, ensure_ascii=False))

Soumission asynchrone et interrogation asynchrone du résultat

Soumettre une tâche et interroger son état
  1. Appelez client.audio.asr.jobs.create pour soumettre une tâche avec les paramètres de requête.

    Remarque

    • Le service de transcription de fichiers traite les tâches soumises via l'API au mieux de ses capacités. Une fois soumise, une tâche passe à l'état mis en file d'attente (PENDING). Le temps d'attente dépend de la longueur de la file et de la durée du fichier ; il ne peut donc pas être déterminé avec précision, mais reste généralement inférieur à quelques minutes. Dès que le traitement commence, la reconnaissance vocale s'effectue à une vitesse des centaines de fois supérieure au temps réel.
    • Une fois chaque tâche terminée, le résultat de reconnaissance et l'URL de téléchargement restent valides pendant 24 heures. Passé ce délai, vous ne pouvez plus interroger la tâche ni télécharger le résultat via l'URL retournée lors d'une requête précédente.
  2. Appelez client.audio.asr.jobs.fetch(task_id) en boucle et lisez les résultats lorsque la tâche réussit.

    Consultez l’état de la tâche dans job.status. Cet exemple interroge la tâche une fois par seconde.

    Les méthodes renvoient un Job. Consultez la liste des résultats dans job.results ; chaque transcription_url pointe vers un résultat de transcription téléchargeable.

import json
import os
import time

import dashscope

# Remplacez {WorkspaceId} par l’ID réel de l’espace de travail de la région.
client = dashscope.Client(
    api_key=os.environ["DASHSCOPE_API_KEY"],
    workspace="{WorkspaceId}",
    region="ap-southeast-1",
)

job = client.audio.asr.jobs.create(
    model="qwen-audio-3.0-asr-flash-filetrans",
    file_urls=["{YOUR_AUDIO_URL}"],
)

while job.status in ("PENDING", "RUNNING"):
    time.sleep(1)
    job = client.audio.asr.jobs.fetch(task_id=job.task_id)

print(json.dumps(job.model_dump(), indent=4, ensure_ascii=False))

Endpoints de service

Le SDK utilise la région de Pékin par défaut. Lors de la création de dashscope.Client, définissez la région avec region et l’ID de l’espace de travail avec workspace. Le paramètre de région s’applique uniquement à ce Client.

Singapour

https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/api/v1

Remplacez {WorkspaceId} par votre véritable ID d'espace de travail.

Chine (Pékin)

https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/api/v1

Remplacez {WorkspaceId} par votre véritable ID d'espace de travail.

Les clés API diffèrent selon les régions. Utilisez celle de la région correspondante.

Paramètres de requête

Définissez les paramètres de requête avec client.audio.asr.transcribe ou client.audio.asr.jobs.create.

ParamètreTypeObligatoireDescription

model

str

Oui

Le nom du modèle.

file_urls

list[str]

Oui

Liste des URL des fichiers audio ou vidéo à transcrire. Les protocoles HTTP et HTTPS sont pris en charge. Une seule requête ne prend en charge qu'une seule URL. Pour les prérequis d'entrée (formats audio pris en charge, limites de taille de fichier et de durée), consultez la section Spécifications audio.

Si l'enregistrement est stocké dans Alibaba Cloud OSS, l'API RESTful prend en charge les URL temporaires préfixées par oss://, tandis que le SDK ne prend pas en charge les URL temporaires préfixées par oss://.

Important

  • Une URL temporaire est valide pendant 48 heures et ne peut plus être utilisée après son expiration. Ne l'utilisez pas en production.

  • L'interface d'obtention des identifiants de téléchargement est limitée à 100 QPS et ne peut pas être mise à l'échelle. Ne l'utilisez pas en production, dans des scénarios à haute concurrence ou lors de tests de charge.

  • Pour la production, utilisez un stockage stable tel qu'Alibaba Cloud OSS afin de garantir la disponibilité à long terme des fichiers et d'éviter les limitations de débit.

  • Si une URL de fichier audio pointant vers une URL publique temporaire OSS est inaccessible, définissez X-DashScope-OssResourceResolve sur enable dans l'en-tête de la requête (non recommandé).

    Le SDK ne prend pas en charge la configuration des en-têtes de requête.

parameters.keep_dialect

bool

Non

Pris en charge uniquement par qwen-audio-3.1-asr-flash-filetrans. La valeur par défaut, false, transcrit les dialectes en mandarin standard. Définissez la valeur sur true pour conserver les expressions dialectales.

parameters.vocabulary_id

str

Non

ID d'une liste de mots chauds précompilée.

Générez cet ID au préalable en appelant l'API de création de liste de mots chauds. Transmettez l'ID lors de la reconnaissance pour utiliser les mots chauds de la liste.

Convient aux scénarios où le vocabulaire est connu et relativement stable, et où vous devez réutiliser la même liste de mots entre plusieurs requêtes.

Pour plus de détails sur l'utilisation, consultez la section Mots chauds précompilés.

parameters.vocabulary

dict

Non

Mots chauds instantanés.

Transmis sous forme de paires clé-valeur, où la clé correspond au texte du mot chaud (string) et la valeur à son poids (integer). Aucune liste de mots chauds ne doit être créée au préalable. Le poids varie de [1, 5] ou peut être fixé à 50 : une valeur comprise dans [1, 5] augmente la probabilité que le modèle produise ce mot à mesure qu'elle croît ; une valeur de 50 désigne un super mot chaud, ce qui améliore considérablement le rappel, mais le nombre de super mots chauds ne peut pas dépasser 50.

Convient à l'optimisation temporaire de mots chauds au niveau de la session.

Lorsque les mots-clés instantanés et précompilés sont configurés ensemble, les deux listes sont fusionnées. Si la liste fusionnée dépasse 2000 mots-clés, 2000 sont sélectionnés au hasard. Pour plus de détails sur l'utilisation, consultez la section Mots chauds instantanés.

Exemple :

L’exemple suivant réutilise le client configuré avec la région et l’espace de travail dans Démarrage rapide.

vocab = {"Zhang San": 5, "Li Si": 5}
result = client.audio.asr.jobs.create(
    model="qwen-audio-3.0-asr-flash-filetrans",
    file_urls=["{YOUR_AUDIO_URL}"],
    parameters={"vocabulary": vocab},
)

parameters.channel_id

list[int]

Non

Index des pistes audio à reconnaître dans un fichier audio multipiste. L'index commence à 0. Par exemple, [0] reconnaît la première piste, et [0, 1] reconnaît simultanément les première et deuxième pistes. Si vous omettez ce paramètre, seule la première piste est traitée.

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

Valeur par défaut : [0].

parameters.special_word_filter

str

Non

Mots sensibles à traiter lors de la reconnaissance vocale. Vous pouvez définir une méthode de gestion différente pour chaque mot sensible. Pour plus de détails, consultez la section Filtrage des mots sensibles.

parameters.diarization_enabled

bool

Non

Indique s'il faut activer la diarisation des locuteurs. Désactivée par défaut.

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

Lorsque cette option est activée, le résultat de reconnaissance inclut un champ speaker_id permettant de distinguer les différents locuteurs.

RemarqueLorsque la diarisation des locuteurs est activée, maintenez la durée audio sous 2 heures. Sinon, la reconnaissance risque d'échouer ou d'expirer.

Valeur par défaut : False.

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

parameters.speaker_count

int

Non

ImportantPrend effet uniquement lorsque la diarisation des locuteurs est activée (diarization_enabled défini sur True).

Valeur de référence pour le nombre de locuteurs. La plage valide est un entier compris entre 2 et 100 (inclus).

Par défaut, le nombre de locuteurs est détecté automatiquement. Si vous définissez cette valeur, elle guide simplement l'algorithme pour produire le nombre spécifié lorsque cela est possible, sans garantir ce compte exact.

Aucune valeur par défaut.

parameters.language_hints

list[str]

Non

Codes de langue à reconnaître. Si vous ne pouvez pas déterminer la langue à l'avance, laissez ce champ vide et le modèle détectera automatiquement la langue.

Vous pouvez définir jusqu’à 4 valeurs. Au-delà, seules les 4 premières sont prises en compte.

Cliquez pour afficher les codes de langue pris en charge

  • zh : Chinois
  • en : Anglais
  • ja : Japonais
  • ko : Coréen
  • vi : Vietnamien
  • th : Thaï
  • id : Indonésien
  • ms : Malais
  • tl : Filipino
  • hi : Hindi
  • ar : Arabe
  • fr : Français
  • de : Allemand
  • es : Espagnol
  • pt : Portugais
  • ru : Russe
  • it : Italien
  • nl : Néerlandais
  • sv : Suédois
  • da : Danois
  • fi : Finnois
  • no : Norvégien
  • el : Grec
  • pl : Polonais
  • cs : Tchèque
  • hu : Hongrois
  • ro : Roumain
  • bg : Bulgare
  • hr : Croate
  • sk : Slovaque

Réponse

Job

Job contient les informations de la tâche, la sortie brute et l’utilisation.

{
    "task_id": "00000000-0000-0000-0000-000000000001",
    "status": "PENDING",
    "submitted_at": "2026-10-29 10:00:00.000",
    "scheduled_at": null,
    "finished_at": null,
    "output": {
        "task_id": "00000000-0000-0000-0000-000000000001",
        "task_status": "PENDING",
        "submit_time": "2026-10-29 10:00:00.000"
    },
    "usage": null
}
{
    "task_id": "00000000-0000-0000-0000-000000000001",
    "status": "RUNNING",
    "submitted_at": "2026-10-29 10:00:00.000",
    "scheduled_at": "2026-10-29 10:00:00.100",
    "finished_at": null,
    "output": {
        "task_id": "00000000-0000-0000-0000-000000000001",
        "task_status": "RUNNING",
        "submit_time": "2026-10-29 10:00:00.000",
        "scheduled_time": "2026-10-29 10:00:00.100"
    },
    "usage": null
}
{
    "task_id": "00000000-0000-0000-0000-000000000001",
    "status": "SUCCEEDED",
    "submitted_at": "2026-10-29 10:00:00.000",
    "scheduled_at": "2026-10-29 10:00:00.100",
    "finished_at": "2026-10-29 10:00:01.000",
    "output": {
        "task_id": "00000000-0000-0000-0000-000000000001",
        "task_status": "SUCCEEDED",
        "submit_time": "2026-10-29 10:00:00.000",
        "scheduled_time": "2026-10-29 10:00:00.100",
        "end_time": "2026-10-29 10:00:01.000",
        "results": [
            {
                "file_url": "{YOUR_AUDIO_URL}",
                "transcription_url": "{TRANSCRIPTION_URL}",
                "subtask_status": "SUCCEEDED"
            }
        ]
    },
    "usage": {
        "duration": 1,
        "total_tokens": 0,
        "output_tokens": 0,
        "input_tokens": 0
    }
}
{
    "task_id": "00000000-0000-0000-0000-000000000001",
    "status": "FAILED",
    "submitted_at": "2026-10-29 10:00:00.000",
    "scheduled_at": "2026-10-29 10:00:00.100",
    "finished_at": "2026-10-29 10:00:01.000",
    "output": {
        "task_id": "00000000-0000-0000-0000-000000000001",
        "task_status": "FAILED",
        "submit_time": "2026-10-29 10:00:00.000",
        "scheduled_time": "2026-10-29 10:00:00.100",
        "end_time": "2026-10-29 10:00:01.000",
        "code": "SERVER_ERROR",
        "file_url": "{YOUR_AUDIO_URL}",
        "subtask_status": "FAILED",
        "results": [
            {
                "file_url": "{YOUR_AUDIO_URL}",
                "subtask_status": "FAILED",
                "results": []
            }
        ]
    },
    "usage": null
}

Champ

Description

task_id

L’ID de la tâche.

status

L’état de la tâche : PENDING, RUNNING, SUCCEEDED ou FAILED.

submitted_at

L’heure de soumission, correspondant à job.output["submit_time"].

scheduled_at

Le début du traitement, correspondant à job.output["scheduled_time"].

finished_at

L’heure de fin, correspondant à job.output["end_time"].

output

Le dictionnaire de sortie brute de la tâche.

results

La liste des résultats des sous-tâches, accessible via job.results. Téléchargez le fichier JSON à l’URL transcription_url pour obtenir le texte reconnu.

usage

Les informations d’utilisation de la tâche. qwen-audio-3.1-asr-flash-filetrans indique l’utilisation des tokens dans input_tokens, output_tokens et total_tokens. qwen-audio-3.0-asr-flash-filetrans est mesuré selon duration.

Job.output

job.output est le dictionnaire de sortie brute de la tâche renvoyé par le service.

PENDING

{
    "task_id": "00000000-0000-0000-0000-000000000001",
    "task_status": "PENDING",
    "submit_time": "2026-10-29 10:00:00.000"
}

RUNNING

{
    "task_id": "00000000-0000-0000-0000-000000000001",
    "task_status": "RUNNING",
    "submit_time": "2026-10-29 10:00:00.000",
    "scheduled_time": "2026-10-29 10:00:00.100"
}

SUCCEEDED

{
    "task_id": "00000000-0000-0000-0000-000000000001",
    "task_status": "SUCCEEDED",
    "submit_time": "2026-10-29 10:00:00.000",
    "scheduled_time": "2026-10-29 10:00:00.100",
    "end_time": "2026-10-29 10:00:01.000",
    "results": [
        {
            "file_url": "{YOUR_AUDIO_URL}",
            "transcription_url": "{TRANSCRIPTION_URL}",
            "subtask_status": "SUCCEEDED"
        }
    ]
}

FAILED (raise_on_error=False)

{
    "task_id": "00000000-0000-0000-0000-000000000001",
    "task_status": "FAILED",
    "submit_time": "2026-10-29 10:00:00.000",
    "scheduled_time": "2026-10-29 10:00:00.100",
    "end_time": "2026-10-29 10:00:01.000",
    "code": "SERVER_ERROR",
    "file_url": "{YOUR_AUDIO_URL}",
    "subtask_status": "FAILED",
    "results": [
        {
            "file_url": "{YOUR_AUDIO_URL}",
            "subtask_status": "FAILED",
            "results": []
        }
    ]
}
ParamètreDescription

code

Code d'erreur. Associez-le au champ message et reportez-vous à la section Codes d'erreur pour résoudre le problème.

message

Message d'erreur. Associez-le au champ code et reportez-vous à la section Codes d'erreur pour résoudre le problème.

task_id

ID de la tâche.

task_status

État de la tâche.

L'un des quatre états suivants : PENDING, RUNNING, SUCCEEDED et FAILED.

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

results

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

subtask_status

État de la sous-tâche.

L'un des quatre états suivants : PENDING, RUNNING, SUCCEEDED et FAILED.

file_url

URL du fichier audio reconnu.

transcription_url

URL du résultat de reconnaissance audio.

Le résultat de reconnaissance est enregistré dans un fichier JSON. Vous pouvez télécharger ce fichier via le lien associé à transcription_url ou lire directement son contenu via une requête HTTP. Pour le contenu du fichier JSON, consultez la section Description du résultat de reconnaissance.

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 Alibaba Speech Lab.",
            "sentences":[
                {
                    "begin_time":100,
                    "end_time":3820,
                    "text":"Hello world, this is Alibaba Speech Lab.",
                    "sentence_id":1,
                    "speaker_id":0, //This field is displayed only 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 is omitted here
                    ]
                }
            ]
        }
    ]
}

Les paramètres suivants méritent une attention particulière :

ParamètreTypeDescription

audio_format

string

Format audio du fichier source.

channels

array[integer]

Index de piste de l'audio dans le fichier source. Pour un audio monopiste, [0] est retourné ; pour un audio bipiste, [0, 1] est retourné, et ainsi de suite.

original_sampling_rate

integer

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

original_duration_in_milliseconds

integer

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

channel_id

integer

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

content_duration

integer

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

RemarqueLa description de facturation ci-dessous s’applique à qwen-audio-3.0-asr-flash-filetrans. qwen-audio-3.1-asr-flash-filetrans est facturé selon l’utilisation des tokens.

Le service de modèle de reconnaissance vocale transcrit uniquement le contenu d'une piste identifié comme parole, et facture en fonction de cette durée. Le contenu non vocal n'est ni mesuré ni facturé. En règle générale, la durée du contenu vocal est inférieure à la durée audio originale. Étant donné que la présence de contenu vocal est déterminée par un modèle d'IA, le résultat peut différer légèrement de la réalité.

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

Résultat de transcription.

speaker_id

integer

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

Ce champ n'apparaît dans le résultat de reconnaissance que si la diarisation des locuteurs est activée.

punctuation

string

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

Interfaces principales

Ressource principale (client.audio.asr)

Créez un client avec dashscope.Client, puis utilisez la ressource client.audio.asr. Toutes les méthodes ci-dessous renvoient un Job.

Méthode

Signature de méthode

Description

transcribe

def transcribe(
    file_urls: List[str],
    *,
    model: str = "qwen-audio-3.1-asr-flash-filetrans",
    parameters: Optional[Dict[str, Any]] = None,
    phrase_id: Optional[str] = None,
    timeout: float = 86400.0,
    submit_timeout: Optional[float] = None,
    poll_interval: float = 1.0,
    max_interval: float = 8.0,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
) -> Job

Soumettez une tâche et attendez sa fin de manière synchrone. Le modèle par défaut est qwen-audio-3.1-asr-flash-filetrans. Spécifiez explicitement model pour appeler un autre modèle.

jobs.create

def create(
    *,
    model: str,
    file_urls: List[str],
    parameters: Optional[Dict[str, Any]] = None,
    phrase_id: Optional[str] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
) -> Job

Soumettez une tâche et renvoyez un Job contenant task_id et status, sans attendre la fin de la reconnaissance.

jobs.wait

def wait(
    job: Union[Job, str],
    *,
    poll_interval: float = 1.0,
    max_interval: float = 8.0,
    timeout: float = 86400.0,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
) -> Job

Transmettez un Job ou un ID de tâche et attendez la fin de manière synchrone. Définissez les intervalles initial et maximal de consultation avec poll_interval et max_interval, et le délai total avec timeout. Toutes les valeurs sont en secondes.

jobs.fetch

def fetch(
    task_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
) -> Job

Interrogez une fois l’état et les résultats par ID de tâche, sans attendre sa fin.

Codes d'erreur

Par défaut, une tâche en échec lève DashScopeError. Pour recevoir un Job en échec, définissez raise_on_error=False lors de la création du Client, puis vérifiez job.status.

Si vous rencontrez une erreur, consultez la section Codes d'erreur pour résoudre le problème.

Lorsqu'une tâche contient plusieurs sous-tâches, l'état global de la tâche est marqué comme SUCCEEDED dès qu'au moins une sous-tâche réussit. 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
    }
}

FAQ

Fonctionnalités

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

L'audio encodé en Base64 n'est pas pris en charge. Seul l'audio accessible via une URL publique peut être reconnu. Les flux binaires et les fichiers locaux ne peuvent pas être reconnus directement.

Q : Comment rendre un fichier audio disponible via une URL accessible publiquement ?

Les étapes typiques sont les suivantes. Il s'agit d'une approche parmi d'autres ; le processus exact varie selon le produit de stockage. Nous vous recommandons de télécharger l'audio vers Alibaba Cloud OSS :

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

Par exemple :

  • Service de stockage d'objets (recommandé) :

    • Utilisez le service de stockage d'objets d'un fournisseur cloud (tel qu'Alibaba Cloud OSS) pour télécharger le fichier audio dans un bucket et le configurer en accès public.
    • Avantages : haute disponibilité, prise en charge de l'accélération CDN et gestion simplifiée.
  • Serveur web :

    • Placez le fichier audio sur un serveur web prenant en charge l'accès HTTP/HTTPS (tel que Nginx ou Apache).
    • Avantages : convient aux petits projets ou aux tests locaux.
  • Réseau de diffusion de contenu (CDN) :

    • Hébergez le fichier audio sur un CDN et accédez-y via l'URL fournie par le CDN.
    • Avantages : accélère la distribution des fichiers et convient aux scénarios à forte concurrence.

2. Télécharger le fichier audio

Téléchargez l'audio conformément à la méthode de stockage ou d'hébergement choisie. Par exemple :

  • Service de stockage d'objets :

    • Connectez-vous à la console du fournisseur cloud et créez un bucket.
    • Téléchargez le fichier audio et définissez ses permissions sur lecture publique, ou générez un lien d'accès temporaire.
  • Serveur web :

    • Placez le fichier audio dans un répertoire dédié sur le serveur (tel que /var/www/html/audio/).
    • Assurez-vous que le fichier est accessible via HTTP/HTTPS.

3. Générer une URL accessible publiquement

Par exemple :

  • Service de stockage d'objets :

    • Une fois le fichier téléchargé, 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 nom de domaine plus convivial, associez 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 (par exemple https://your-domain.com/audio/file.mp3).
  • CDN :

    • Après avoir configuré l'accélération CDN, utilisez l'URL fournie par le CDN (par exemple https://cdn.your-domain.com/audio/file.mp3).

4. Vérifier que l'URL fonctionne

Assurez-vous que l'URL générée est accessible via le réseau public. Par exemple :

  • Ouvrez l'URL dans un navigateur et vérifiez si le fichier audio se lit correctement.
  • Utilisez un outil (tel que curl ou Postman) pour vérifier que l'URL retourne la 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 son 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. Ne l'utilisez pas dans des environnements de production, des scénarios à haute concurrence ou des scénarios de test de charge.
  • Pour les environnements de production, utilisez un service de stockage stable tel qu'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 le résultat de reconnaissance ?

Une fois une tâche soumise, elle passe à l'état mis en file d'attente (PENDING). Le temps d'attente dépend de la longueur de la file et de la durée de l'audio ; il ne peut donc pas être déterminé avec précision, mais reste généralement inférieur à quelques minutes. En règle générale, plus l'audio est long, plus le traitement prend du temps.

Dépannage

Si vous rencontrez une erreur de code, résolvez le problème en vous basant sur les informations de la section Codes d'erreur.

Q : L'interrogation ne retourne jamais de résultat ?

Cela peut être dû à une limitation de débit. Patientez un instant et réessayez.

Q : Pourquoi la parole n'est-elle pas reconnue (aucun résultat de reconnaissance) ?

Vérifiez que le format audio et la fréquence d'échantillonnage sont corrects et respectent les contraintes des paramètres.

Utilisez l'outil ffprobe pour obtenir le conteneur audio, le codec, la fréquence d'échantillonnage, les canaux et d'autres détails :

ffprobe -v error -show_entries format=format_name -show_entries stream=codec_name,sample_rate,channels -of default=noprint_wrappers=1 input.xxx