Tous les produits
Search
Centre de documentation

Alibaba Cloud Model Studio:Qwen-Audio-ASR / Fun-ASR Python SDK

Dernière mise à jour :Nov 19, 2026

Prérequis

Le service est activé et vous avez obtenu une clé API. Pour éviter les risques de sécurité liés à la divulgation de code, configurez la clé API comme variable d'environnement au lieu de l'intégrer directement dans votre code.

Démarrage rapide

Utilisez les mêmes exemples pour les modèles ci-dessous. Remplacez l’ID de modèle à l’aide de ce tableau.

ModèleID de modèle dans l’exemple
Qwen-Audio-ASR-Streamingqwen-audio-3.1-asr-flash-streaming
Qwen-Audio-ASR-Messageqwen-audio-3.1-asr-flash-message
Prend uniquement en charge la fréquence d’échantillonnage de 16000 Hz.
Fun-ASR-Realtimefun-asr-realtime

Référence de l’API

Qwen-Audio-ASR-Message

La ressource principale (client.audio.asr) fournit des interfaces pour les appels non diffusés (non-streaming) et les appels bidirectionnels en flux continu (streaming). Choisissez la méthode d'appel adaptée à vos besoins :

  • Appel non diffusé (recognize_file) : reconnaît un fichier local. Le SDK envoie automatiquement l'audio par segments et conduit la tâche jusqu'à son terme. Convient au traitement de fichiers audio préenregistrés.
  • Appel bidirectionnel en flux continu (session recognize) : reconnaît un flux audio directement et produit des résultats en temps réel. Le flux audio peut provenir d'un périphérique externe, tel qu'un microphone, ou être lu depuis un fichier local. Convient aux scénarios nécessitant un retour immédiat.

Appel non diffusé

Soumettez une tâche unique de reconnaissance vocale en temps réel et obtenez le résultat de manière synchrone en transmettant un fichier local.

Appelez la méthode recognize_file de la ressource principale (client.audio.asr) pour associer les paramètres de requête et transmettre le chemin du fichier local, puis itérez sur les événements du serveur pour obtenir le résultat de reconnaissance.

import os
import dashscope

# Les API Key des régions Singapour et Pékin sont différentes. Obtenez votre API Key : https://www.alibabacloud.com/help/model-studio/get-api-key
# Si la variable d'environnement n'est pas configurée, remplacez la ligne suivante par votre API Key de Model Studio : api_key="sk-xxx"
client = dashscope.Client(
    api_key=os.environ.get('DASHSCOPE_API_KEY'),
    # Voici la configuration de la région de Singapour (ap-southeast-1). Remplacez {WorkspaceId} par l'ID de votre workspace. La valeur de region varie selon la région.
    workspace="{WorkspaceId}",
    region="ap-southeast-1",
)

# Reconnaître un fichier audio local : recognize_file envoie automatiquement l'audio par segments et conduit la tâche jusqu'à son terme
for event in client.audio.asr.recognize_file(
        '{YOUR_AUDIO_FILE}',
        model='qwen-audio-3.1-asr-flash-streaming',
        format='wav',
        sample_rate=16000):
    payload = event.get('payload') or {}
    sentence = (payload.get('output') or {}).get('sentence') or {}
    if sentence.get('text') and not sentence.get('heartbeat'):
        print('Recognition result:', sentence['text'])

Appel bidirectionnel en flux continu

Soumettez une tâche unique de reconnaissance vocale en temps réel et diffusez les résultats en temps réel en itérant sur les événements.

  1. Démarrez la reconnaissance vocale en flux continu.

    Appelez la méthode recognize de la ressource principale (client.audio.asr) pour créer une session de reconnaissance et associer les paramètres de requête, puis entrez dans le contexte with (qui appelle automatiquement la méthode start pour établir la connexion et envoyer la tâche) pour lancer la reconnaissance vocale en flux continu.

  2. Diffusez l'audio.

    Appelez la méthode send_audio_frame de la session dans une boucle afin d'envoyer le flux audio binaire au serveur par segments. Le flux est lu depuis un fichier local ou un périphérique, tel qu'un microphone.

    L'envoi et la réception doivent s'exécuter de manière concurrente : le thread récepteur itère sur les événements du serveur via la méthode events() de la session, qui renvoie les résultats de reconnaissance au client en temps réel.

    Envoyez environ 100 ms d'audio par trame, en veillant à ce que chaque trame soit comprise entre 1 Ko et 16 Ko.

  3. Terminez la tâche.

    Appelez la méthode stop de la session pour mettre fin à la reconnaissance vocale.

    Cette méthode notifie seulement le serveur que la saisie est terminée ; le thread récepteur doit continuer à consommer events() jusqu'à l'événement task-finished pour obtenir les résultats et statistiques finaux de reconnaissance. Les erreurs de la couche WebSocket sont levées sous forme d'exceptions DashScopeError, que vous pouvez capturer par try/except côté envoi ou réception.

import os
import signal  # for keyboard events handling (press "Ctrl+C" to terminate recording)
import sys

import dashscope
import pyaudio
from concurrent.futures import ThreadPoolExecutor

mic = None
stream = None

# Définir les paramètres d'enregistrement
sample_rate = 16000  # Utilisez la même fréquence pour la capture et la reconnaissance. Qwen-Audio-ASR-Message prend uniquement en charge 16000 Hz.
channels = 1  # canal mono
dtype = 'int16'  # type de données
format_pcm = 'pcm'  # le format des données audio
block_size = 3200  # nombre de trames par tampon

# Récepteur d'événements de reconnaissance vocale en temps réel
def receive_events(rec):
    for event in rec.events():
        payload = event.get('payload') or {}
        sentence = (payload.get('output') or {}).get('sentence') or {}
        if sentence.get('text') and not sentence.get('heartbeat'):
            print('Recognition text: ', sentence['text'])
            if sentence.get('sentence_end'):
                print(
                    'Recognition sentence end, request_id:%s, usage:%s'
                    % (rec.request_id, rec.usage))

def signal_handler(sig, frame):
    print('Ctrl+C pressed, stop recognition ...')
    # Arrêter la reconnaissance
    recognition.stop()
    print('Recognition stopped.')
    print(
        '[Metric] requestId: {}, first package delay ms: {}, last package delay ms: {}'
        .format(
            recognition.request_id,
            recognition.first_package_delay,
            recognition.last_package_delay,
        ))
    # Forcer la sortie du programme
    sys.exit(0)

# fonction principale
if __name__ == '__main__':
    # Les API Key des régions Singapour et Pékin sont différentes. Obtenez votre API Key : https://www.alibabacloud.com/help/model-studio/get-api-key
    # Si la variable d'environnement n'est pas configurée, remplacez la ligne suivante par votre API Key de Model Studio : api_key="sk-xxx"
    client = dashscope.Client(
        api_key=os.environ.get('DASHSCOPE_API_KEY'),
        # Voici la configuration de la région de Singapour (ap-southeast-1). Remplacez {WorkspaceId} par l'ID de votre workspace. La valeur de region varie selon la région.
        workspace="{WorkspaceId}",
        region="ap-southeast-1",
    )

    # Appelez le service de reconnaissance ; vous pouvez personnaliser les paramètres de reconnaissance, comme model, format,
    # sample_rate
    with client.audio.asr.recognize(
            model='qwen-audio-3.1-asr-flash-streaming',
            format=format_pcm,
            # 'pcm'、'wav'、'opus'、'speex'、'aac'、'amr' ; consultez les formats pris en charge dans la documentation
            sample_rate=sample_rate,
    ) as recognition:
        # Ouvrir le microphone
        mic = pyaudio.PyAudio()
        stream = mic.open(format=pyaudio.paInt16,
                          channels=1,
                          rate=sample_rate,
                          input=True)
        with ThreadPoolExecutor(max_workers=1) as pool:
            receiver = pool.submit(receive_events, recognition)
            try:
                # Envoyer l'audio du microphone jusqu'à l'appui sur "Ctrl+C"
                while stream:
                    data = stream.read(3200, exception_on_overflow=False)
                    recognition.send_audio_frame(data)
                recognition.stop()
                receiver.result()
            finally:
                # close doit être exécuté dans le contexte du pool pour débloquer le récepteur
                recognition.close()
        stream.stop_stream()
        stream.close()
        mic.terminate()
        stream = None
        mic = None
import os
import time
import dashscope
from concurrent.futures import ThreadPoolExecutor

# Les API Key des régions Singapour et Pékin sont différentes. Obtenez votre API Key : https://www.alibabacloud.com/help/model-studio/get-api-key
# Si la variable d'environnement n'est pas configurée, remplacez la ligne suivante par votre API Key de Model Studio : api_key="sk-xxx"
client = dashscope.Client(
    api_key=os.environ.get('DASHSCOPE_API_KEY'),
    # Voici la configuration de la région de Singapour (ap-southeast-1). Remplacez {WorkspaceId} par l'ID de votre workspace. La valeur de region varie selon la région.
    workspace="{WorkspaceId}",
    region="ap-southeast-1",
)

from datetime import datetime

def get_timestamp():
    now = datetime.now()
    formatted_timestamp = now.strftime("[%Y-%m-%d %H:%M:%S.%f]")
    return formatted_timestamp

# Récepteur d'événements de reconnaissance vocale en temps réel
def receive_events(rec):
    for event in rec.events():
        payload = event.get('payload') or {}
        sentence = (payload.get('output') or {}).get('sentence') or {}
        if sentence.get('text') and not sentence.get('heartbeat'):
            print(get_timestamp() + ' Recognition text: ', sentence['text'])
        if sentence.get('sentence_end'):
            print(get_timestamp() +
                  'Recognition sentence end, request_id:%s, usage:%s'
                  % (rec.request_id, rec.usage))

with client.audio.asr.recognize(
        model='qwen-audio-3.1-asr-flash-streaming',
        format='wav',
        sample_rate=16000,
) as recognition:
    with ThreadPoolExecutor(max_workers=1) as pool:
        receiver = pool.submit(receive_events, recognition)
        try:
            audio_data: bytes = None
            f = open("{YOUR_AUDIO_FILE}", 'rb')
            if os.path.getsize("{YOUR_AUDIO_FILE}"):
                # Lire toutes les données du fichier dans le tampon en une seule fois
                file_buffer = f.read()
                f.close()
                print("Start Recognition")

                # Envoyer 3200 octets du tampon à la fois
                buffer_size = len(file_buffer)
                offset = 0
                chunk_size = 3200

                while offset < buffer_size:
                    # Calculer la taille du segment de données à envoyer cette fois
                    remaining_bytes = buffer_size - offset
                    current_chunk_size = min(chunk_size, remaining_bytes)

                    # Extraire le segment de données courant du tampon
                    audio_data = file_buffer[offset:offset + current_chunk_size]

                    # Envoyer la trame de données audio
                    recognition.send_audio_frame(audio_data)
                    # Mettre à jour le décalage
                    offset += current_chunk_size

                    # Ajouter un délai pour simuler la transmission en temps réel
                    time.sleep(0.1)

                recognition.stop()
                receiver.result()
            else:
                raise Exception(
                    'The supplied file was empty (zero bytes long)')
        finally:
            # close doit être exécuté dans le contexte du pool pour débloquer le récepteur
            recognition.close()

print(
    '[Metric] requestId: {}, first package delay ms: {}, last package delay ms: {}'
    .format(
        recognition.request_id,
        recognition.first_package_delay,
        recognition.last_package_delay,
    ))

Paramètres de requête

Qwen-Audio-ASR-Streaming

Référence commune

Consultez la documentation Qwen-Audio-ASR-Streaming Python SDK actuelle.

Définissez les paramètres de requête via les méthodes recognize/recognize_file de la ressource principale (client.audio.asr) : model, format, sample_rate et vocabulary_id sont des arguments nommés. Transmettez language_hints dans le dictionnaire parameters.

ParamètreTypeObligatoireDescription
modelstr

Oui

Le nom du modèle.
sample_rateint

Oui

Le taux d’échantillonnage en Hz. Tous les taux sont pris en charge.

formatstr

Oui

Le format audio.

Valeurs valides :

  • pcm
  • wav
  • mp3
  • opus
  • speex
  • aac
  • amr

Importantopus/speex : doit utiliser l'encapsulation Ogg.

wav : doit utiliser l'encodage PCM.

amr : seul le type AMR-NB est pris en charge.

keep_dialectbool

Non

RemarqueS’applique uniquement à qwen-audio-3.1-asr-flash-streaming.

Par défaut : false, pour transcrire les dialectes en chinois standard. Définissez sur true pour conserver les expressions dialectales. Transmettez ce champ dans le dictionnaire parameters.

vad_modelstr

Non

RemarqueS’applique uniquement à qwen-audio-3.1-asr-flash-streaming.

Modèle VAD : near_meeting_16k (champ proche) ou far_field_meeting_16k (champ lointain, par défaut). Transmettez ce champ dans le dictionnaire parameters.

vocabulary_idstr

Non

L'ID d'une liste de mots clés précompilée.

Générez cet ID à l'avance en appelant l'API de création de liste de mots clés. Transmettez l'ID lors de la reconnaissance pour utiliser les mots clés 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 rubrique Mots clés précompilés.

vocabularydict

Non

Mots clés instantanés.

Transmis sous forme de paires clé-valeur, où la clé correspond au texte du mot clé (string) et la valeur au poids du mot clé (integer). Aucune liste de mots clés ne doit être créée à l'avance. Le poids varie de [1, 5] ou est défini sur 50 : une valeur comprise entre [1, 5] augmente la probabilité que le modèle génère le mot à mesure que la valeur augmente ; une valeur de 50 désigne un super mot clé, ce qui améliore considérablement le rappel, mais le nombre de super mots clés ne peut pas dépasser 50.

Adapté à l'optimisation temporaire des mots clés au niveau de la session.

Lorsqu'ils sont configurés conjointement avec des mots clés précompilés, seuls les mots clés instantanés prennent effet. Pour plus de détails sur l'utilisation, consultez la rubrique Mots clés instantanés.

Exemple :

import os
import dashscope

client = dashscope.Client(api_key=os.getenv("DASHSCOPE_API_KEY"))

# Les mots clés instantanés se transmettent via parameters
vocab = {"John Smith": 5, "Jane Doe": 5}
recognition = client.audio.asr.recognize(
    model='qwen-audio-3.1-asr-flash-streaming',
    format='wav',
    sample_rate=16000,
    parameters={"vocabulary": vocab},
)
max_sentence_silenceint

Non

Le seuil de silence VAD pour la segmentation, en ms. Lorsque le silence après un segment de parole dépasse ce seuil, le système considère que la phrase est terminée.

Valeur par défaut : 800.

Valeurs valides : [200, 6000].

multi_threshold_mode_enabledbool

Non

Indique s'il faut activer le mode multi-seuil. Lorsqu'il est activé, ce mode empêche la segmentation VAD de produire des segments trop longs.

Par défaut : False.

punctuation_prediction_enabledbool

Non

Indique s'il faut ajouter automatiquement la ponctuation aux résultats de reconnaissance :

  • True (par défaut) : Oui. Cette valeur ne peut pas être modifiée.
heartbeatbool

Non

Indique s'il faut activer les paquets de maintien de connexion (heartbeat).

Par défaut : False.

  • True : maintient la connexion au serveur active pendant l'envoi continu d'audio silencieux.
  • False (par défaut) : même lorsque de l'audio silencieux est envoyé en continu, la connexion expire et se ferme après un certain temps.

L'audio silencieux désigne le contenu d'un fichier audio ou d'un flux de données ne contenant aucun signal sonore. Vous pouvez générer de l'audio silencieux de plusieurs manières, par exemple en utilisant des logiciels de montage audio tels qu'Audacity ou Adobe Audition, ou des outils en ligne de commande comme FFmpeg.

Ce champ nécessite la version 2.0.1 ou ultérieure du SDK.

language_hintslist[str]

Non

La langue de l'audio à reconnaître. Il n'y a pas de valeur par défaut ; si ce paramètre n'est pas défini, le modèle détecte automatiquement la langue.

Vous pouvez définir jusqu’à 4 valeurs. Au-delà, seules les 4 premières prennent effet.

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 : philippin
  • 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
speech_noise_thresholdfloat

Non

Le seuil permettant de distinguer la parole du bruit, utilisé pour ajuster la sensibilité de la détection d'activité vocale (VAD).

Valeurs valides : [-1,0, 1,0].

Descriptions des valeurs :

  • Plus la valeur se rapproche de -1 : le seuil de bruit diminue, ce qui rend le bruit plus susceptible d'être reconnu comme de la parole, pouvant entraîner la transcription de davantage de bruit.
  • Plus la valeur se rapproche de +1 : le seuil de bruit augmente, ce qui rend la parole plus susceptible d'être identifiée à tort comme du bruit, pouvant entraîner le filtrage de certaines parties de la parole.

Il s'agit d'un paramètre de configuration avancé. Son ajustement peut affecter significativement les résultats de reconnaissance. Recommandations :

  • Testez et vérifiez minutieusement les résultats avant tout ajustement.
  • Ajustez par petits incréments en fonction de l'environnement audio réel (un pas de 0,1 est recommandé).
special_word_filterstr

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. Pour plus de détails, consultez la rubrique Filtrage des mots sensibles.

Transmettez le contexte dans input lors de la création de la session avec recognize.

ParamètreTypeObligatoireDescription
inputdict

Non

L'objet d'entrée utilisé pour transmettre le contexte de conversation. L'amélioration contextuelle améliore la précision de la reconnaissance pour les termes spécifiques à un domaine. Pour l'utilisation, consultez le guide de démarrage rapide.

Le dictionnaire doit inclure une clé context dont la valeur est une liste de messages (list[dict]). Chaque message contient les champs suivants :

  • role (str, obligatoire) : le rôle du message. user représente les résultats de reconnaissance des tours précédents de l'utilisateur ou une liste de mots spécifiques à un domaine. assistant représente les réponses du grand modèle de langage des tours précédents.
  • content (list[dict], obligatoire) : la liste du contenu du message. Chaque élément contient type (str ; défini sur input_text lorsque le rôle est user, et sur text lorsque le rôle est assistant) et text (str, le contenu textuel).

ImportantLimites : les messages de contexte de type input_text et text sont chacun limités à 5 messages. Lorsque la limite est dépassée, seuls les 5 messages les plus récents sont conservés. La longueur totale du texte par tour de contexte ne peut pas dépasser 400 caractères, tout excédent étant tronqué à la fin.

ImportantLorsque vous transmettez un contexte, les messages dans context doivent respecter un ordre spécifique : les messages de contexte doivent être organisés par tour de conversation, et au sein de chaque tour, le message user (type input_text) doit précéder son message assistant correspondant (type text).

RemarqueCe champ nécessite la version 2.0.1 ou ultérieure du SDK.

Transmettez-le via le paramètre input lors de la création de la session de reconnaissance :

# Construire l'entrée à transmettre
input_context = {
    "context": [
        {
            "role": "user",
            "content": [
                {
                    "type": "input_text",
                    "text": "Hello there"
                }
            ]
        },
        {
            "role": "assistant",
            "content": [
                {
                    "type": "text",
                    "text": "Hello, I am Qwen. How can I help you?"
                }
            ]
        }
    ]
}

# La transmettre via le paramètre input lors de la création de la session de reconnaissance
recognition = client.audio.asr.recognize(
    model='qwen-audio-3.1-asr-flash-streaming',
    format='wav',
    sample_rate=16000,
    input=input_context,
)

Qwen-Audio-ASR-Message

Référence commune

Consultez la documentation Qwen-Audio-ASR-Message Python SDK actuelle.

Définissez les paramètres de requête via les méthodes recognize/recognize_file de la ressource principale (client.audio.asr) : model, format, sample_rate et vocabulary_id sont des arguments nommés. Transmettez language_hints dans le dictionnaire parameters.

ParamètreTypeObligatoireDescription
modelstr

Oui

Le nom du modèle.
sample_rateint

Oui

Le taux d’échantillonnage en Hz. Seule la valeur 16000 est prise en charge.

formatstr

Oui

Le format audio.

Valeurs valides :

  • pcm
  • wav
  • mp3
  • opus
  • speex
  • aac
  • amr

Importantopus/speex : doit utiliser l'encapsulation Ogg.

wav : doit utiliser l'encodage PCM.

amr : seul le type AMR-NB est pris en charge.

keep_dialectbool

Non

Par défaut : false, pour transcrire les dialectes en chinois standard. Définissez sur true pour conserver les expressions dialectales. Transmettez ce champ dans le dictionnaire parameters.

Ce paramètre s’applique uniquement aux résultats finaux (sentence_end=true) et n’est pas pris en charge pour les résultats intermédiaires (sentence_end=false).

vad_modelstr

Non

Modèle VAD : near_meeting_16k (champ proche) ou far_field_meeting_16k (champ lointain, par défaut). Transmettez ce champ dans le dictionnaire parameters.

disfluency_removal_enabledbool

Non

Indique s’il faut supprimer les mots de remplissage et améliorer le texte produit. Par défaut : false. Définissez sur true pour activer. Transmettez-le comme argument nommé portant le même nom.

intermediate_result_enabledbool

Non

Indique s’il faut renvoyer les résultats intermédiaires en streaming. Par défaut : false. Définissez sur true pour les recevoir. Transmettez ce champ dans le dictionnaire parameters.

vocabulary_idstr

Non

L'ID d'une liste de mots clés précompilée.

Générez cet ID à l'avance en appelant l'API de création de liste de mots clés. Transmettez l'ID lors de la reconnaissance pour utiliser les mots clés 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 rubrique Mots clés précompilés.

vocabularydict

Non

Mots clés instantanés.

Transmis sous forme de paires clé-valeur, où la clé correspond au texte du mot clé (string) et la valeur au poids du mot clé (integer). Aucune liste de mots clés ne doit être créée à l'avance. Le poids varie de [1, 5] ou est défini sur 50 : une valeur comprise entre [1, 5] augmente la probabilité que le modèle génère le mot à mesure que la valeur augmente ; une valeur de 50 désigne un super mot clé, ce qui améliore considérablement le rappel, mais le nombre de super mots clés ne peut pas dépasser 50.

Adapté à l'optimisation temporaire des mots clés au niveau de la session.

Lorsqu'ils sont configurés conjointement avec des mots clés précompilés, seuls les mots clés instantanés prennent effet. Pour plus de détails sur l'utilisation, consultez la rubrique Mots clés instantanés.

ImportantSeuls les modèles qwen-audio-3.1-asr-flash-message prennent en charge les mots clés instantanés.

Exemple :

import os
import dashscope

client = dashscope.Client(api_key=os.getenv("DASHSCOPE_API_KEY"))

# Les mots clés instantanés se transmettent via parameters
vocab = {"John Smith": 5, "Jane Doe": 5}
recognition = client.audio.asr.recognize(
    model='qwen-audio-3.1-asr-flash-message',
    format='wav',
    sample_rate=16000,
    parameters={"vocabulary": vocab},
)
language_hintslist[str]

Non

La langue de l'audio à reconnaître. Il n'y a pas de valeur par défaut ; si ce paramètre n'est pas défini, le modèle détecte automatiquement la langue.

Vous pouvez définir jusqu’à 4 valeurs. Au-delà, seules les 4 premières prennent effet.

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 : philippin
  • 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

Transmettez ce champ dans le dictionnaire parameters, par exemple parameters={"language_hints": ["zh"]}.

Ce paramètre s’applique uniquement aux résultats finaux (sentence_end=true) et n’est pas pris en charge pour les résultats intermédiaires (sentence_end=false).

max_sentence_silenceint

Non

Seuil de silence VAD pour la segmentation, en millisecondes. La phrase est considérée comme terminée si le silence après la parole dépasse ce seuil. Par défaut : 800. Plage valide : [200, 6000].

heartbeatbool

Non

Indique s'il faut activer les paquets de maintien de connexion (heartbeat).

Par défaut : False.

  • True : maintient la connexion au serveur active pendant l'envoi continu d'audio silencieux.
  • False (par défaut) : même lorsque de l'audio silencieux est envoyé en continu, la connexion expire et se ferme après un certain temps.

L'audio silencieux désigne le contenu d'un fichier audio ou d'un flux de données ne contenant aucun signal sonore. Vous pouvez générer de l'audio silencieux de plusieurs manières, par exemple en utilisant des logiciels de montage audio tels qu'Audacity ou Adobe Audition, ou des outils en ligne de commande comme FFmpeg.

Ce champ nécessite la version 2.0.1 ou ultérieure du SDK.

speech_noise_thresholdfloat

Non

Le seuil permettant de distinguer la parole du bruit, utilisé pour ajuster la sensibilité de la détection d'activité vocale (VAD).

Valeurs valides : [-1,0, 1,0].

Descriptions des valeurs :

  • Plus la valeur se rapproche de -1 : le seuil de bruit diminue, ce qui rend le bruit plus susceptible d'être reconnu comme de la parole, pouvant entraîner la transcription de davantage de bruit.
  • Plus la valeur se rapproche de +1 : le seuil de bruit augmente, ce qui rend la parole plus susceptible d'être identifiée à tort comme du bruit, pouvant entraîner le filtrage de certaines parties de la parole.

Il s'agit d'un paramètre de configuration avancé. Son ajustement peut affecter significativement les résultats de reconnaissance. Recommandations :

  • Testez et vérifiez minutieusement les résultats avant tout ajustement.
  • Ajustez par petits incréments en fonction de l'environnement audio réel (un pas de 0,1 est recommandé).

Transmettez le contexte dans input lors de la création de la session avec recognize.

ParamètreTypeObligatoireDescription
inputdict

Non

L'objet d'entrée utilisé pour transmettre le contexte de conversation. L'amélioration contextuelle améliore la précision de la reconnaissance pour les termes spécifiques à un domaine. Pour l'utilisation, consultez le guide de démarrage rapide.

ImportantLe paramètre de contexte est pris en charge uniquement par les modèles qwen-audio-3.1-asr-flash-message.

Le dictionnaire doit inclure une clé context dont la valeur est une liste de messages (list[dict]). Chaque message contient les champs suivants :

  • role (str, obligatoire) : le rôle du message. user représente les résultats de reconnaissance des tours précédents de l'utilisateur ou une liste de mots spécifiques à un domaine. assistant représente les réponses du grand modèle de langage des tours précédents.
  • content (list[dict], obligatoire) : la liste du contenu du message. Chaque élément contient type (str ; défini sur input_text lorsque le rôle est user, et sur text lorsque le rôle est assistant) et text (str, le contenu textuel).

ImportantLimites : les messages de contexte de type input_text et text sont chacun limités à 5 messages. Lorsque la limite est dépassée, seuls les 5 messages les plus récents sont conservés. La longueur totale du texte par tour de contexte ne peut pas dépasser 400 caractères, tout excédent étant tronqué à la fin.

ImportantLorsque vous transmettez un contexte, les messages dans context doivent respecter un ordre spécifique : les messages de contexte doivent être organisés par tour de conversation, et au sein de chaque tour, le message user (type input_text) doit précéder son message assistant correspondant (type text).

RemarqueCe champ nécessite la version 2.0.1 ou ultérieure du SDK.

Transmettez-le via le paramètre input lors de la création de la session de reconnaissance :

# Construire l'entrée à transmettre
input_context = {
    "context": [
        {
            "role": "user",
            "content": [
                {
                    "type": "input_text",
                    "text": "Hello there"
                }
            ]
        },
        {
            "role": "assistant",
            "content": [
                {
                    "type": "text",
                    "text": "Hello, I am Qwen. How can I help you?"
                }
            ]
        }
    ]
}

# La transmettre via le paramètre input lors de la création de la session de reconnaissance
recognition = client.audio.asr.recognize(
    model='qwen-audio-3.1-asr-flash-message',
    format='wav',
    sample_rate=16000,
    input=input_context,
)

Fun-ASR-Realtime

Référence commune

Consultez la documentation Fun-ASR-Realtime Python SDK actuelle.

Définissez les paramètres de requête via les méthodes recognize/recognize_file de la ressource principale (client.audio.asr) : model, format, sample_rate et vocabulary_id sont des arguments nommés. Transmettez max_sentence_silence et language_hints dans le dictionnaire parameters.

ParamètreTypeObligatoireDescription
modelstr

Oui

Le nom du modèle.
sample_rateint

Oui

La fréquence d'échantillonnage, en Hz.

Valeurs valides : les modèles 8 kHz prennent uniquement en charge 8 000 Hz ; les autres modèles acceptent n'importe quelle fréquence d'échantillonnage.

formatstr

Oui

Le format audio.

Valeurs valides :

  • pcm
  • wav
  • mp3
  • opus
  • speex
  • aac
  • amr

Importantopus/speex : doit utiliser l'encapsulation Ogg.

wav : doit utiliser l'encodage PCM.

amr : seul le type AMR-NB est pris en charge.

vocabulary_idstr

Non

L'ID d'une liste de mots clés précompilée.

Générez cet ID à l'avance en appelant l'API de création de liste de mots clés. Transmettez l'ID lors de la reconnaissance pour utiliser les mots clés 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 rubrique Mots clés précompilés.

max_sentence_silenceint

Non

Le seuil de silence VAD pour la segmentation, en ms. Lorsque le silence après un segment de parole dépasse ce seuil, le système considère que la phrase est terminée.

Valeur par défaut : 1300.

Valeurs valides : [200, 6000].

multi_threshold_mode_enabledbool

Non

Indique s'il faut activer le mode multi-seuil. Lorsqu'il est activé, ce mode empêche la segmentation VAD de produire des segments trop longs.

Par défaut : False.

punctuation_prediction_enabledbool

Non

Indique s'il faut ajouter automatiquement la ponctuation aux résultats de reconnaissance :

  • True (par défaut) : Oui. Cette valeur ne peut pas être modifiée.
heartbeatbool

Non

Indique s'il faut activer les paquets de maintien de connexion (heartbeat).

Par défaut : False.

  • True : maintient la connexion au serveur active pendant l'envoi continu d'audio silencieux.
  • False (par défaut) : même lorsque de l'audio silencieux est envoyé en continu, la connexion expire et se ferme après un certain temps.

L'audio silencieux désigne le contenu d'un fichier audio ou d'un flux de données ne contenant aucun signal sonore. Vous pouvez générer de l'audio silencieux de plusieurs manières, par exemple en utilisant des logiciels de montage audio tels qu'Audacity ou Adobe Audition, ou des outils en ligne de commande comme FFmpeg.

Ce champ nécessite la version 2.0.1 ou ultérieure du SDK.

language_hintslist[str]

Non

La langue de l'audio à reconnaître. Il n'y a pas de valeur par défaut ; si ce paramètre n'est pas défini, le modèle détecte automatiquement la langue.

Vous pouvez définir une seule valeur. Si vous en définissez plusieurs, seule la première prend effet.

Cliquez pour afficher les codes de langue pris en charge

  • fun-asr-realtime :

    • zh : chinois
    • en : anglais
    • ja : japonais
    • ko : coréen
    • vi : vietnamien
    • th : thaï
    • id : indonésien
    • ms : malais
    • tl : philippin
    • 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
  • fun-asr-realtime-2026-02-28 :

    • zh : chinois
    • en : anglais
    • ja : japonais
  • fun-asr-flash-8k-realtime, fun-asr-flash-8k-realtime-2026-01-28 :

    • zh : chinois
speech_noise_thresholdfloat

Non

Le seuil permettant de distinguer la parole du bruit, utilisé pour ajuster la sensibilité de la détection d'activité vocale (VAD).

Valeurs valides : [-1,0, 1,0].

Descriptions des valeurs :

  • Plus la valeur se rapproche de -1 : le seuil de bruit diminue, ce qui rend le bruit plus susceptible d'être reconnu comme de la parole, pouvant entraîner la transcription de davantage de bruit.
  • Plus la valeur se rapproche de +1 : le seuil de bruit augmente, ce qui rend la parole plus susceptible d'être identifiée à tort comme du bruit, pouvant entraîner le filtrage de certaines parties de la parole.

Il s'agit d'un paramètre de configuration avancé. Son ajustement peut affecter significativement les résultats de reconnaissance. Recommandations :

  • Testez et vérifiez minutieusement les résultats avant tout ajustement.
  • Ajustez par petits incréments en fonction de l'environnement audio réel (un pas de 0,1 est recommandé).
special_word_filterstr

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. Pour plus de détails, consultez la rubrique Filtrage des mots sensibles.

Transmettez le contexte dans input lors de la création de la session avec recognize.

ParamètreTypeObligatoireDescription
inputdict

Non

L'objet d'entrée utilisé pour transmettre le contexte de conversation. L'amélioration contextuelle améliore la précision de la reconnaissance pour les termes spécifiques à un domaine. Pour l'utilisation, consultez la rubrique Améliorer la précision de la reconnaissance.

ImportantLe paramètre de contexte est pris en charge uniquement par les modèles fun-asr-realtime.

Le dictionnaire doit inclure une clé context dont la valeur est une liste de messages (list[dict]). Chaque message contient les champs suivants :

  • role (str, obligatoire) : le rôle du message. user représente les résultats de reconnaissance des tours précédents de l'utilisateur ou une liste de mots spécifiques à un domaine. assistant représente les réponses du grand modèle de langage des tours précédents.
  • content (list[dict], obligatoire) : la liste du contenu du message. Chaque élément contient type (str ; défini sur input_text lorsque le rôle est user, et sur text lorsque le rôle est assistant) et text (str, le contenu textuel).

ImportantLimites : les messages de contexte de type input_text et text sont chacun limités à 5 messages. Lorsque la limite est dépassée, seuls les 5 messages les plus récents sont conservés. La longueur totale du texte par tour de contexte ne peut pas dépasser 400 caractères, tout excédent étant tronqué à la fin.

ImportantLorsque vous transmettez un contexte, les messages dans context doivent respecter un ordre spécifique : les messages de contexte doivent être organisés par tour de conversation, et au sein de chaque tour, le message user (type input_text) doit précéder son message assistant correspondant (type text).

RemarqueCe champ nécessite la version 2.0.1 ou ultérieure du SDK.

Transmettez-le via le paramètre input lors de la création de la session de reconnaissance :

# Construire l'entrée à transmettre
input_context = {
    "context": [
        {
            "role": "user",
            "content": [
                {
                    "type": "input_text",
                    "text": "Hello there"
                }
            ]
        },
        {
            "role": "assistant",
            "content": [
                {
                    "type": "text",
                    "text": "Hello, I am Qwen. How can I help you?"
                }
            ]
        }
    ]
}

# La transmettre via le paramètre input lors de la création de la session de reconnaissance
recognition = client.audio.asr.recognize(
    model='fun-asr-realtime',
    format='wav',
    sample_rate=16000,
    input=input_context,
)

Référence de l’API

Interfaces communes

Ressource principale (client.audio.asr)

La reconnaissance vocale en temps réel est montée sur la ressource client.audio.asr : recognize crée une session de reconnaissance bidirectionnelle en flux continu (Recognition) et recognize_file reconnaît un fichier local en un seul appel.

Méthode membreSignature de la méthodeDescription

recognize

def recognize(self,
              *,
              model: str,
              format: str = "pcm",
              sample_rate: int = 16000,
              vocabulary_id: str = None,
              disfluency_removal_enabled: bool = None,
              diarization_enabled: bool = None,
              parameters: Dict = None,
              input: Dict = None,
              phrase_id: str = None,
              ...) -> Recognition
Crée une session de reconnaissance bidirectionnelle en flux continu. L'entrée dans le contexte with appelle automatiquement start pour établir la connexion et envoyer la tâche.

L'envoi d'audio et la consommation d'événements doivent s'exécuter de manière concurrente (à utiliser avec send_audio_frame, events()/results() et stop).

recognize_file

def recognize_file(self,
                   path: str,
                   *,
                   model: str,
                   format: str = "pcm",
                   sample_rate: int = 16000,
                   ...) -> Iterator[Dict]
Un appel non diffusé basé sur un fichier local : envoie automatiquement l'audio par segments et conduit la tâche jusqu'à son terme, en délivrant les événements du serveur un par un. Cette méthode nécessite une autorisation de lecture sur le fichier.

start

def start(self)
Démarre la reconnaissance vocale : établit la connexion, envoie la tâche et attend task-started. Appelée automatiquement à l'entrée dans le contexte with. L'audio ne peut être envoyé qu'après un démarrage réussi.

send_audio_frame

def send_audio_frame(self, buffer: bytes)
Envoie l'audio. Veillez à ce que chaque trame audio envoyée ne soit ni trop grande ni trop petite : environ 100 ms par trame, entre 1 Ko et 16 Ko.

Les résultats de reconnaissance s'obtiennent en itérant sur events()/results().

stop

def stop(self)
Arrête la reconnaissance vocale : notifie seulement le serveur que la saisie est terminée. Le thread récepteur doit continuer à consommer events() jusqu'à l'événement task-finished.

events / results

def events(self) -> Iterator[Dict]
def results(self) -> Iterator[RecognitionResult]
Itère sur les événements du serveur : events() délivre des dict d'événements bruts (le texte reconnu se trouve dans payload.output.sentence) ; results() ne délivre que les trames de résultats de reconnaissance, en renvoyant des objets typés Résultat de reconnaissance (RecognitionResult) (les trames de heartbeat sont filtrées).

close

def close(self)
Ferme la session de reconnaissance. Appelée automatiquement à la sortie du contexte with.

request_id / first_package_delay / last_package_delay / last_response

rec.request_id
rec.first_package_delay
rec.last_package_delay
rec.last_response
Récupère le request_id, la latence du premier paquet (délai entre l'envoi du premier paquet audio et la réception du premier résultat de reconnaissance) et la latence du dernier paquet (temps écoulé entre l'envoi de la commande stop et le dernier résultat de reconnaissance). À utiliser après la fin de la tâche. last_response est le dernier message brut lu correctement, utile pour récupérer les erreurs d'une tâche échouée. Restent lisibles après la fermeture de la session.

Itération d'événements (events()/results())

Lors d'un appel bidirectionnel en flux continu, le serveur renvoie les informations clés du processus et les données au client via des événements. Dans un thread récepteur, itérez sur les events() de la session (dict d'événements bruts) ou results() (trames typées de résultats de reconnaissance) pour traiter les informations et données renvoyées par le serveur.

# Itérer sur les événements bruts : le texte reconnu se trouve dans payload.output.sentence
def receive_events(rec):
    for event in rec.events():
        payload = event.get('payload') or {}
        sentence = (payload.get('output') or {}).get('sentence') or {}
        if sentence.get('text') and not sentence.get('heartbeat'):
            print('Recognized text: ', sentence['text'])


# Ou itérer uniquement sur les trames de résultats de reconnaissance (renvoie RecognitionResult, les trames de heartbeat sont filtrées)
def receive_results(rec):
    for result in rec.results():
        sentence = result.get_sentence()
        if sentence and 'text' in sentence:
            print('Recognized text: ', sentence['text'])
Événement/méthode d'itérationSortieValeur de retourDescription
event["header"]["event"] == "task-started"
Événement task-startedNoneLu en interne par start() et enregistré dans last_response au retour du démarrage. N'est pas redélivré par events().
def events(self) -> Iterator[Dict]
event : dict d'événement du serveurItérateurDélivre des événements lors des réponses du serveur. Le résultat de reconnaissance se trouve dans payload.output.sentence, qui peut être un événement de heartbeat ou de texte vide que les applications peuvent ignorer selon les besoins. Consommez-le depuis un unique thread récepteur et ne créez pas plusieurs lecteurs concurrents.
def results(self) -> Iterator[RecognitionResult]
result : résultat de reconnaissance (RecognitionResult)ItérateurNe délivre que les trames de résultats de reconnaissance (les trames de heartbeat sont filtrées). L'itération se termine après le renvoi de tous les résultats de reconnaissance.
try:
    ...
except DashScopeError as e:
    print(e.code, e.message, e.request_id)
Exception DashScopeErrorNoneLevée dans le thread d'envoi/réception en cas d'erreur. Vous pouvez la capturer par try/except.
event["header"]["event"] == "task-finished"
Événement task-finishedNoneDélivré par events() lorsque le serveur a terminé toute la reconnaissance, après quoi l'itération se termine. Vous devez continuer à lire cet événement après l'appel de stop().

Informations d'horodatage au niveau des mots (Word)

Les membres de la classe Word sont les suivants :

ParamètreTypeDescription
begin_timeintHeure de début du mot, en ms.
end_timeintHeure de fin du mot, en ms.
textstrLe mot.
punctuationstrLa ponctuation.

Qwen-Audio-ASR-Streaming

Interfaces principales

Mettre à jour le contexte de conversation

Appelez update_context pour mettre à jour le contexte de la conversation pendant l'exécution d'une tâche de reconnaissance. Le contexte sert à aider la reconnaissance de l'audio ultérieur. Cette méthode nécessite DashScope Python SDK 2.0.1 ou ultérieure.

def update_context(self, context: dict)
  • Quand appeler : après le début de la reconnaissance en flux continu (l'entrée dans le contexte with appelle automatiquement start) et avant l'appel de stop.
  • Paramètre : context est un dictionnaire contenant l'objet payload.input d'un événement continue-task, incluant le champ context. N'ajoutez pas d'enveloppe payload ou input supplémentaire.
  • Modèles pris en charge et restrictions de paramètres : consultez continue-task.

L'exemple suivant utilise une instance recognition existante et démarrée.

payload_input = {
    "context": [
        {
            "role": "user",
            "content": [{"type": "input_text", "text": "Hello"}]
        },
        {
            "role": "assistant",
            "content": [{"type": "text", "text": "Hello, I am Qwen. How can I help you?"}]
        }
    ]
}
recognition.update_context(context=payload_input)

Réponse

Résultat de reconnaissance (RecognitionResult)

RecognitionResult représente une trame de résultat de reconnaissance unique délivrée lors de l'itération sur les results() de la session (utilisable aussi bien dans les appels bidirectionnels en flux continu que non diffusés ; events() délivre des dict d'événements bruts ; utilisez results() si vous avez besoin de cette vue typée).

Méthode membreSignature de la méthodeDescription
get_sentence
def get_sentence(self) -> Union[Dict[str, Any], List[Any]]

Récupère la phrase reconnue actuelle et ses informations d'horodatage. Cette méthode renvoie Dict[str, Any] (informations d'une seule phrase). Pour plus de détails, consultez la rubrique Phrase (Sentence).

request_id
result.request_id
Le request_id correspondant à l'événement courant.
is_sentence_end
def is_sentence_end(self) -> bool
Détermine si la phrase courante est terminée. Cette méthode vérifie si le champ end_time dans les informations de phrase unique renvoyées par get_sentence() est None : une valeur end_time différente de None indique que la phrase est terminée.

Les membres de la classe Sentence sont les suivants :

ParamètreTypeDescription
begin_timeintHeure de début de la phrase, en ms.
end_timeintHeure de fin de la phrase, en ms.
textstrTexte reconnu.
wordsUne liste d'informations d'horodatage au niveau des mots (Word)Informations d'horodatage au niveau des mots.

Qwen-Audio-ASR-Message

Interfaces principales

Mettre à jour le contexte de conversation

Appelez update_context pour mettre à jour le contexte de la conversation pendant l'exécution d'une tâche de reconnaissance. Le contexte sert à aider la reconnaissance de l'audio ultérieur. Cette méthode nécessite DashScope Python SDK 2.0.1 ou ultérieure.

def update_context(self, context: dict)
  • Quand appeler : après le début de la reconnaissance en flux continu (l'entrée dans le contexte with appelle automatiquement start) et avant l'appel de stop.
  • Paramètre : context est un dictionnaire contenant l'objet payload.input d'un événement continue-task, incluant le champ context. N'ajoutez pas d'enveloppe payload ou input supplémentaire.
  • Modèles pris en charge et restrictions de paramètres : consultez continue-task.

L'exemple suivant utilise une instance recognition existante et démarrée.

payload_input = {
    "context": [
        {
            "role": "user",
            "content": [{"type": "input_text", "text": "Hello"}]
        },
        {
            "role": "assistant",
            "content": [{"type": "text", "text": "Hello, I am Qwen. How can I help you?"}]
        }
    ]
}
recognition.update_context(context=payload_input)

Réponse

Résultat de reconnaissance (RecognitionResult)

RecognitionResult représente une trame de résultat de reconnaissance unique délivrée lors de l'itération sur les results() de la session (utilisable aussi bien dans les appels bidirectionnels en flux continu que non diffusés ; events() délivre des dict d'événements bruts ; utilisez results() si vous avez besoin de cette vue typée).

Méthode membreSignature de la méthodeDescription
get_sentence
def get_sentence(self) -> Union[Dict[str, Any], List[Any]]

Récupère la phrase reconnue actuelle et ses informations d'horodatage. Cette méthode renvoie Dict[str, Any] (informations d'une seule phrase). Pour plus de détails, consultez la rubrique Phrase (Sentence).

request_id
result.request_id
Le request_id correspondant à l'événement courant.
is_sentence_end
def is_sentence_end(self) -> bool
Détermine si la phrase courante est terminée. Cette méthode vérifie si le champ end_time dans les informations de phrase unique renvoyées par get_sentence() est None : une valeur end_time différente de None indique que la phrase est terminée.

Les membres de la classe Sentence sont les suivants :

ParamètreTypeDescription
begin_timeintHeure de début de la phrase, en ms.
end_timeintHeure de fin de la phrase, en ms.
textstrTexte reconnu.
wordsUne liste d'informations d'horodatage au niveau des mots (Word)Informations d'horodatage au niveau des mots.

Fun-ASR-Realtime

Interfaces principales

Réponse

Résultat de reconnaissance (RecognitionResult)

RecognitionResult représente une trame de résultat de reconnaissance unique délivrée lors de l'itération sur les results() de la session (utilisable aussi bien dans les appels bidirectionnels en flux continu que non diffusés ; events() délivre des dict d'événements bruts ; utilisez results() si vous avez besoin de cette vue typée).

Méthode membreSignature de la méthodeDescription
get_sentence
def get_sentence(self) -> Union[Dict[str, Any], List[Any]]
Récupère la phrase reconnue actuelle et ses informations d'horodatage. Cette méthode renvoie Dict[str, Any] (informations d'une seule phrase).

Pour plus de détails, consultez la rubrique Phrase (Sentence).

request_id
result.request_id
Le request_id correspondant à l'événement courant.
is_sentence_end
def is_sentence_end(self) -> bool
Détermine si la phrase courante est terminée. Cette méthode vérifie si le champ end_time dans les informations de phrase unique renvoyées par get_sentence() est None : une valeur end_time différente de None indique que la phrase est terminée.
Informations sur la phrase (Sentence)

Les membres de la classe Sentence sont les suivants :

ParamètreTypeDescription
begin_timeintHeure de début de la phrase, en ms.
end_timeintHeure de fin de la phrase, en ms.
textstrTexte reconnu.
wordsUne liste d'informations d'horodatage au niveau des mots (Word)Informations d'horodatage au niveau des mots.

Codes d’erreur

Si vous rencontrez des erreurs, consultez la rubrique Codes d'erreur pour le dépannage.

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