Python SDK - Alibaba Cloud Model Studio - Centre de documentation Alibaba Cloud

Paramètres et interfaces du SDK Python de reconnaissance vocale en temps réel Paraformer.

ImportantCe document s'applique uniquement à la région Chine continentale (Pékin). Pour utiliser les modèles, 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 d'utilisation : Pour une présentation des modèles et des recommandations de sélection, consultez Reconnaissance vocale en temps réel - Fun-ASR/Paraformer.

Prérequis

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

RemarqueLorsque vous devez accorder un accès temporaire à des applications ou utilisateurs tiers, ou lorsque vous souhaitez contrôler strictement des opérations sensibles telles que l'accès ou la suppression de données confidentielles, nous vous recommandons d'utiliser 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.

Installez la dernière version du SDK DashScope.

Liste des modèles

	paraformer-realtime-v2	paraformer-realtime-8k-v2
Scénarios	Diffusion en direct, réunions et scénarios similaires	Reconnaissance audio 8 kHz dans des scénarios tels que le service client téléphonique et la messagerie vocale
Taux d'échantillonnage	Quelconque	8kHz
Langue	Chinois (y compris le mandarin et divers dialectes), anglais, japonais, coréen, allemand, français, russe Dialectes chinois pris en charge : shanghaïen, wu, minnan, nord-est, gansu, guizhou, henan, hubei, hunan, jiangxi, ningxia, shanxi, shaanxi, shandong, sichuan, tianjin, yunnan, cantonais	Chinois
Prédiction de la ponctuation	✅ Pris en charge par défaut. Aucune configuration requise.	✅ Pris en charge par défaut. Aucune configuration requise.
Normalisation inverse du texte (ITN)	✅ Pris en charge par défaut. Aucune configuration requise.	✅ Pris en charge par défaut. Aucune configuration requise.
Vocabulaire personnalisé	✅ Voir Personnaliser les mots-clés	✅ Voir Personnaliser les mots-clés
Spécifier la langue de reconnaissance	✅ Spécifiez la langue à l'aide du paramètre `language_hints`.	❌
Reconnaissance des émotions	❌	✅ (Cliquez pour voir l'utilisation) La reconnaissance des émotions est soumise aux contraintes suivantes : S'applique uniquement au modèle `paraformer-realtime-8k-v2`. Vous devez désactiver la ponctuation sémantique (contrôlée par le paramètre de requête `semantic_punctuation_enabled`). La ponctuation sémantique est désactivée par défaut. Le résultat de la reconnaissance des émotions s'affiche uniquement lorsque la méthode `is_sentence_end` de RecognitionResult retourne `True`. Pour obtenir les résultats de détection des émotions, récupérez respectivement l'émotion et le niveau de confiance de l'émotion de la phrase actuelle depuis les champs `emo_tag` et `emo_confidence` des informations de phrase unique (Sentence).

Premiers pas

La classe Recognition fournit des méthodes pour les appels non streaming et streaming bidirectionnel. Choisissez la méthode appropriée selon vos besoins :

Appel non streaming : Reconnaît un fichier local et retourne le résultat complet en une seule fois. Cette méthode convient au traitement d'audio préenregistré.
Appel streaming bidirectionnel : Reconnaît un flux audio et produit les 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. Cette approche est idéale pour les scénarios nécessitant un retour immédiat.

Appel non streaming

Cette méthode soumet une tâche de transcription vocale en temps réel pour un fichier local. Le processus est bloquant jusqu'à ce que le résultat complet de la transcription soit retourné.

Instanciez la classe Recognition, définissez les paramètres de requête, puis appelez la méthode call pour effectuer la reconnaissance ou la traduction et obtenir le RecognitionResult.

Cliquez pour voir l'exemple complet

from http import HTTPStatus
from dashscope.audio.asr import Recognition
# China (Beijing): Replace {WorkspaceId} with your actual workspace ID. The configuration varies by region.
dashscope.base_websocket_api_url = "wss://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/api-ws/v1/inference"

# If you have not configured the API key in the environment variable, uncomment the following line of code and replace apiKey with your API key.
# import dashscope
# dashscope.api_key = "apiKey"

recognition = Recognition(model='paraformer-realtime-v2',
                          format='wav',
                          sample_rate=16000,
                          # The "language_hints" parameter is supported only by the paraformer-realtime-v2 model.
                          language_hints=['zh', 'en'],
                          callback=None)
result = recognition.call('{YOUR_AUDIO_FILE}')
if result.status_code == HTTPStatus.OK:
    sentences = result.get_sentence()
    for sentence in sentences:
        print(sentence['text'])
else:
    print('Error: ', result.message)

print(
    '[Metric] requestId: {}, first package delay ms: {}, last package delay ms: {}'
    .format(
        recognition.get_last_request_id(),
        recognition.get_first_package_delay(),
        recognition.get_last_package_delay(),
    ))

RemarqueDans un appel non streaming, result.get_sentence() retourne une liste de phrases (List[Dict]). Chaque élément contient des champs tels que text (texte reconnu), begin_time / end_time (horodatages) et words (horodatages par mot). Parcourez la liste et utilisez sentence['text'] pour extraire le texte brut.

Cela diffère d'un rappel streaming, où result.get_sentence() retourne une seule phrase (Dict[str, Any]). Pour plus de détails, voir Sentence.

Appel streaming bidirectionnel

Cette méthode soumet une tâche de transcription vocale en temps réel et retourne les résultats de reconnaissance en temps réel via une interface de rappel.

Démarrer la reconnaissance vocale en streaming

Instanciez la classe Recognition, liez les paramètres de requête et l'interface de rappel (RecognitionCallback), puis appelez la méthode start pour lancer la reconnaissance vocale en streaming.
Streaming

Appelez de manière répétée la méthode send_audio_frame de la classe Recognition pour envoyer le flux audio binaire depuis un fichier local ou un périphérique (tel qu'un microphone) au serveur par segments.

Au fur et à mesure que les données audio sont envoyées, le serveur utilise la méthode on_event de l'interface de rappel RecognitionCallback pour retourner les résultats de reconnaissance au client en temps réel.

Nous recommandons que la durée de chaque segment audio envoyé soit d'environ 100 millisecondes, avec une taille de données comprise entre 1 Ko et 16 Ko.
Terminer le traitement

Appelez la méthode stop de la classe Recognition pour arrêter la reconnaissance vocale.

Cette méthode bloque le thread actuel jusqu'à ce que le rappel on_complete ou on_error de l'interface de rappel (RecognitionCallback) soit déclenché.

Cliquez pour voir l'exemple complet

Recognize speech from a microphone

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

import dashscope
import pyaudio
from dashscope.audio.asr import *
# China (Beijing): Replace {WorkspaceId} with your actual workspace ID. The configuration varies by region.
dashscope.base_websocket_api_url = "wss://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/api-ws/v1/inference"

mic = None
stream = None

# Set recording parameters
sample_rate = 16000  # sampling rate (Hz)
channels = 1  # mono channel
dtype = 'int16'  # data type
format_pcm = 'pcm'  # the format of the audio data
block_size = 3200  # number of frames per buffer

def init_dashscope_api_key():
    """
        Set your DashScope API-key. More information:
        https://github.com/aliyun/alibabacloud-bailian-speech-demo/blob/master/PREREQUISITES.md
    """

    if 'DASHSCOPE_API_KEY' in os.environ:
        dashscope.api_key = os.environ[
            'DASHSCOPE_API_KEY']  # load API-key from environment variable DASHSCOPE_API_KEY
    else:
        dashscope.api_key = '<your-dashscope-api-key>'  # set API-key manually

# Real-time speech recognition callback
class Callback(RecognitionCallback):
    def on_open(self) -> None:
        global mic
        global stream
        print('RecognitionCallback open.')
        mic = pyaudio.PyAudio()
        stream = mic.open(format=pyaudio.paInt16,
                          channels=1,
                          rate=16000,
                          input=True)

    def on_close(self) -> None:
        global mic
        global stream
        print('RecognitionCallback close.')
        stream.stop_stream()
        stream.close()
        mic.terminate()
        stream = None
        mic = None

    def on_complete(self) -> None:
        print('RecognitionCallback completed.')  # recognition completed

    def on_error(self, message) -> None:
        print('RecognitionCallback task_id: ', message.request_id)
        print('RecognitionCallback error: ', message.message)
        # Stop and close the audio stream if it is running
        if 'stream' in globals() and stream.active:
            stream.stop()
            stream.close()
        # Forcefully exit the program
        sys.exit(1)

    def on_event(self, result: RecognitionResult) -> None:
        sentence = result.get_sentence()
        if 'text' in sentence:
            print('RecognitionCallback text: ', sentence['text'])
            if RecognitionResult.is_sentence_end(sentence):
                print(
                    'RecognitionCallback sentence end, request_id:%s, usage:%s'
                    % (result.get_request_id(), result.get_usage(sentence)))

def signal_handler(sig, frame):
    print('Ctrl+C pressed, stop recognition ...')
    # Stop recognition
    recognition.stop()
    print('Recognition stopped.')
    print(
        '[Metric] requestId: {}, first package delay ms: {}, last package delay ms: {}'
        .format(
            recognition.get_last_request_id(),
            recognition.get_first_package_delay(),
            recognition.get_last_package_delay(),
        ))
    # Forcefully exit the program
    sys.exit(0)

# main function
if __name__ == '__main__':
    init_dashscope_api_key()
    print('Initializing ...')

    # Create the recognition callback
    callback = Callback()

    # Call recognition service by async mode, you can customize the recognition parameters, like model, format,
    # sample_rate
    recognition = Recognition(
        model='paraformer-realtime-v2',
        format=format_pcm,
        # 'pcm', 'wav', 'opus', 'speex', 'aac', or 'amr'. You can check the supported formats in the document.
        sample_rate=sample_rate,
        # 8000 or 16000 is supported.
        semantic_punctuation_enabled=False,
        callback=callback)

    # Start recognition
    recognition.start()

    signal.signal(signal.SIGINT, signal_handler)
    print("Press 'Ctrl+C' to stop recording and recognition...")
    # Create a keyboard listener until "Ctrl+C" is pressed

    while True:
        if stream:
            data = stream.read(3200, exception_on_overflow=False)
            recognition.send_audio_frame(data)
        else:
            break

    recognition.stop()

Recognize a local audio file

import os
import time
from dashscope.audio.asr import *
# China (Beijing): Replace {WorkspaceId} with your actual workspace ID. The configuration varies by region.
dashscope.base_websocket_api_url = "wss://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/api-ws/v1/inference"

# If you have not configured the API key in the environment variable, uncomment the following line of code and replace apiKey with your API key.
# import dashscope
# dashscope.api_key = "apiKey"

from datetime import datetime

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

class Callback(RecognitionCallback):
    def on_complete(self) -> None:
        print(get_timestamp() + ' Recognition completed')  # recognition complete

    def on_error(self, result: RecognitionResult) -> None:
        print('Recognition task_id: ', result.request_id)
        print('Recognition error: ', result.message)
        exit(0)

    def on_event(self, result: RecognitionResult) -> None:
        sentence = result.get_sentence()
        if 'text' in sentence:
            print(get_timestamp() + ' RecognitionCallback text: ', sentence['text'])
            if RecognitionResult.is_sentence_end(sentence):
                print(get_timestamp() +
                    'RecognitionCallback sentence end, request_id:%s, usage:%s'
                    % (result.get_request_id(), result.get_usage(sentence)))

callback = Callback()

recognition = Recognition(model='paraformer-realtime-v2',
                          format='wav',
                          sample_rate=16000,
                          # The "language_hints" parameter is supported only by the paraformer-realtime-v2 model.
                          language_hints=['zh', 'en'],
                          callback=callback)

recognition.start()

try:
    audio_data: bytes = None
    f = open("{YOUR_AUDIO_FILE}", 'rb')
    if os.path.getsize("{YOUR_AUDIO_FILE}"):
        while True:
            audio_data = f.read(3200)
            if not audio_data:
                break
            else:
                recognition.send_audio_frame(audio_data)
            time.sleep(0.1)
    else:
        raise Exception(
            'The supplied file was empty (zero bytes long)')
    f.close()
except Exception as e:
    raise e

recognition.stop()

print(
    '[Metric] requestId: {}, first package delay ms: {}, last package delay ms: {}'
    .format(
        recognition.get_last_request_id(),
        recognition.get_first_package_delay(),
        recognition.get_last_package_delay(),
    ))

Appels simultanés

En Python, en raison du Global Interpreter Lock (GIL), un seul thread peut exécuter du code Python à la fois (bien que certaines bibliothèques orientées performances puissent lever cette limitation). Pour mieux exploiter les ressources de calcul d'un ordinateur multicœur, nous vous recommandons d'utiliser multiprocessing ou concurrent.futures.ProcessPoolExecutor. Le multithreading peut augmenter considérablement la latence des appels SDK sous une forte concurrence.

Paramètres de requête

Les paramètres de requête se définissent dans le constructeur (init) de la classe Recognition.

Paramètre	Type	Valeur par défaut	Obligatoire	Description
model	str		Oui	Modèle utilisé pour la reconnaissance vocale en temps réel. Pour plus d'informations, voir Liste des modèles.
sample_rate	int		Oui	Définissez le taux d'échantillonnage (en Hz) de l'audio à reconnaître. Varie selon le modèle : paraformer-realtime-v2 prend en charge n'importe quel taux d'échantillonnage. paraformer-realtime-8k-v2 ne prend en charge que le taux d'échantillonnage de 8000 Hz.
format	str		Oui	Définissez le format audio à reconnaître. Formats audio pris en charge : pcm, wav, mp3, opus, speex, aac, amr. Importantopus/speex : Doit utiliser l'encapsulation Ogg. wav : Doit être encodé en PCM. amr : Seul le type AMR-NB est pris en charge.
vocabulary_id	str		Non	Définissez l'ID du mot-clé. S'il n'est pas défini, les mots-clés ne seront pas pris en compte. Utilisez ce champ pour définir l'ID du mot-clé pour les modèles v2 et ultérieurs. Lors de la session de reconnaissance vocale en cours, les informations de mot-clé correspondant à cet ID seront appliquées. Pour une utilisation détaillée, voir Personnaliser les mots-clés.
disfluency_removal_enabled	bool	False	Non	Définissez s'il faut filtrer les mots de remplissage : true : Filtrer les mots de remplissage false (par défaut) : Ne pas filtrer les mots de remplissage
language_hints	list[str]	["zh", "en"]	Non	Définissez les codes de langue pour la reconnaissance. Si vous ne pouvez pas déterminer la langue à l'avance, vous pouvez laisser ce champ vide et le modèle détectera automatiquement la langue. Codes de langue actuellement pris en charge : zh : Chinois en : Anglais ja : Japonais yue : Cantonais ko : Coréen de : Allemand fr : Français ru : Russe Ce paramètre s'applique uniquement aux modèles multilingues. Pour plus d'informations, voir Liste des modèles.
semantic_punctuation_enabled	bool	False	Non	Définissez s'il faut activer la segmentation sémantique. Désactivée par défaut. true : Active la segmentation sémantique et désactive la segmentation VAD (Voice Activity Detection). false (par défaut) : Active la segmentation VAD (Voice Activity Detection) et désactive la segmentation sémantique. La segmentation sémantique offre une précision supérieure et convient aux scénarios de transcription de réunions. La segmentation VAD (Voice Activity Detection) présente une latence plus faible et convient aux scénarios interactifs. En ajustant le paramètre `semantic_punctuation_enabled`, vous pouvez modifier la méthode de segmentation de la reconnaissance vocale pour l'adapter à différents scénarios. Ce paramètre ne prend effet que lorsque le modèle est v2 ou ultérieur.
max_sentence_silence	int	800	Non	Définissez le seuil de durée de silence (en ms) pour la segmentation VAD (Voice Activity Detection). Lorsque la durée de silence après un segment vocal dépasse ce seuil, le système considère que la phrase est terminée. La plage de paramètres s'étend de 200 ms à 6000 ms, avec une valeur par défaut de 800 ms. Ce paramètre ne prend effet que lorsque le paramètre `semantic_punctuation_enabled` est false (segmentation VAD) et que le modèle est v2 ou ultérieur.
multi_threshold_mode_enabled	bool	False	Non	Lorsque ce commutateur est activé (true), il empêche la segmentation VAD de couper des phrases trop longues. Désactivé par défaut. Ce paramètre ne prend effet que lorsque le paramètre `semantic_punctuation_enabled` est false (segmentation VAD) et que le modèle est v2 ou ultérieur.
punctuation_prediction_enabled	bool	True	Non	Définissez s'il faut ajouter automatiquement la ponctuation dans les résultats de reconnaissance : true (par défaut) : Oui false : Non Ce paramètre ne prend effet que lorsque le modèle est v2 ou ultérieur.
heartbeat	bool	False	Non	Lorsque vous devez maintenir une connexion longue avec le serveur, utilisez ce commutateur pour contrôler le comportement : true : La connexion avec le serveur peut être maintenue sans interruption lors de l'envoi continu d'audio silencieux. false (par défaut) : Même lors de l'envoi continu d'audio silencieux, la connexion sera interrompue après 60 secondes en raison d'un délai d'attente. L'audio silencieux désigne des fichiers audio ou des flux de données ne contenant aucun signal sonore. L'audio silencieux peut être généré par diverses méthodes, par exemple en utilisant des logiciels d'édition audio comme Audacity ou Adobe Audition, ou via des outils en ligne de commande comme FFmpeg. Ce paramètre ne prend effet que lorsque le modèle est v2 ou ultérieur. Lors de l'utilisation de ce champ, la version du SDK doit être 1.23.1 ou ultérieure.
inverse_text_normalization_enabled	bool	True	Non	Définissez s'il faut activer l'ITN (Normalisation inverse du texte). Activé par défaut (true). Lorsqu'elle est activée, les chiffres chinois sont convertis en chiffres arabes. Ce paramètre ne prend effet que lorsque le modèle est v2 ou ultérieur.
callback	RecognitionCallback		Non	Interface RecognitionCallback.

Interfaces clés

Classe `Recognition`

La classe Recognition est importée à l'aide de from dashscope.audio.asr import *.

Méthode membre	Signature de la méthode	Description
call	`def call(self, file: str, phrase_id: str = None, **kwargs) -> RecognitionResult`	Appel non streaming utilisant un fichier local. Cette méthode bloque le thread actuel jusqu'à ce que l'intégralité du fichier audio soit lue. Le fichier doit disposer des permissions de lecture. Le résultat de la reconnaissance est retourné sous forme de type `RecognitionResult`.
start	`def start(self, phrase_id: str = None, **kwargs)`	Démarre la reconnaissance vocale. Il s'agit d'une méthode de reconnaissance en temps réel en streaming basée sur des rappels, qui ne bloque pas le thread actuel. Elle doit être utilisée conjointement avec `send_audio_frame` et `stop`.
send_audio_frame	`def send_audio_frame(self, buffer: bytes)`	Envoie un flux audio. Le flux audio envoyé à chaque fois ne doit être ni trop volumineux ni trop petit. Nous recommandons que chaque paquet audio ait une durée d'environ 100 ms et une taille comprise entre 1 Ko et 16 Ko. Vous pouvez obtenir les résultats de reconnaissance via la méthode on_event de l'interface de rappel (RecognitionCallback).
stop	`def stop(self)`	Arrête la reconnaissance vocale. Cette méthode est bloquante jusqu'à ce que le service ait reconnu tout l'audio reçu et que la tâche soit terminée.
get_last_request_id	`def get_last_request_id(self)`	Obtient le request_id. Peut être utilisé après l'appel du constructeur (création de l'objet).
get_first_package_delay	`def get_first_package_delay(self)`	Obtient le délai du premier paquet, c'est-à-dire la latence entre l'envoi du premier paquet audio et la réception du premier paquet de résultat de reconnaissance. À utiliser une fois la tâche terminée.
get_last_package_delay	`def get_last_package_delay(self)`	Obtient le délai du dernier paquet, c'est-à-dire le temps écoulé entre l'envoi de l'instruction `stop` et la réception du dernier paquet de résultat de reconnaissance. À utiliser une fois la tâche terminée.

Interface de rappel (`RecognitionCallback`)

Lors d'un appel streaming bidirectionnel, le serveur utilise des rappels pour retourner des informations clés sur le processus et des données au client. Vous devez implémenter une méthode de rappel pour traiter les informations et données retournées.

Cliquez pour voir l'exemple

class Callback(RecognitionCallback):
    def on_open(self) -> None:
        print('Connection successful')

    def on_event(self, result: RecognitionResult) -> None:
        # Implement the logic for receiving recognition results

    def on_complete(self) -> None:
        print('Task completed')

    def on_error(self, result: RecognitionResult) -> None:
        print('An exception occurred: ', result)

    def on_close(self) -> None:
        print('Connection closed')

callback = Callback()

Méthode	Paramètre	Valeur de retour	Description
`def on_open(self) -> None`	None	None	Cette méthode est appelée immédiatement après l'établissement d'une connexion avec le serveur.
`def on_event(self, result: RecognitionResult) -> None`	`result`: RecognitionResult	None	Cette méthode est appelée lorsque le service envoie une réponse.
`def on_complete(self) -> None`	None	None	Cette méthode est appelée après le retour de tous les résultats de reconnaissance.
`def on_error(self, result: RecognitionResult) -> None`	`result`: Résultat de reconnaissance	None	Cette méthode est appelée lorsqu'une exception survient.
`def on_close(self) -> None`	None	None	Cette méthode est appelée après que le service a fermé la connexion.

Résultats de réponse

Résultat de reconnaissance (RecognitionResult)

RecognitionResult représente le résultat de reconnaissance d'une seule reconnaissance en temps réel dans un appel streaming bidirectionnel ou un appel non streaming.

Méthode membre Signature de la méthode Description

Méthode membre	Signature de la méthode	Description
get_sentence	`def get_sentence(self) -> Union[Dict[str, Any], List[Any]]`	Obtient la phrase reconnue actuelle et les informations d'horodatage. Dans un rappel, une seule phrase est retournée, donc cette méthode retourne un type Dict[str, Any]. Pour plus d'informations, voir Sentence.
get_request_id	`def get_request_id(self) -> str`	Obtient le request_id de la requête.
is_sentence_end	`@staticmethod def is_sentence_end(sentence: Dict[str, Any]) -> bool`	Détermine si la phrase donnée est terminée.

get_sentence

def get_sentence(self) -> Union[Dict[str, Any], List[Any]]

Obtient la phrase reconnue actuelle et les informations d'horodatage. Dans un rappel, une seule phrase est retournée, donc cette méthode retourne un type Dict[str, Any].

Pour plus d'informations, voir Sentence.

get_request_id

def get_request_id(self) -> str

Obtient le request_id de la requête.

is_sentence_end

@staticmethod
def is_sentence_end(sentence: Dict[str, Any]) -> bool

Détermine si la phrase donnée est terminée.

Sentence (`Sentence`)

Les membres de la classe Sentence sont les suivants :

Paramètre	Type	Description
begin_time	int	Heure de début de la phrase, en ms.
end_time	int	Heure de fin de la phrase, en ms.
text	str	Texte reconnu.
words	Une liste d'informations d'horodatage des mots (Word)	Informations d'horodatage des mots.
emo_tag	str	Émotion de la phrase actuelle : positive : Émotion positive, telle que heureux ou satisfait negative : Émotion négative, telle que colère ou tristesse neutral : Aucune émotion évidente La reconnaissance des émotions est soumise aux contraintes suivantes : S'applique uniquement au modèle `paraformer-realtime-8k-v2`. Vous devez désactiver la ponctuation sémantique (contrôlée par le paramètre de requête `semantic_punctuation_enabled`). La ponctuation sémantique est désactivée par défaut. Le résultat de la reconnaissance des émotions s'affiche uniquement lorsque la méthode `is_sentence_end` de RecognitionResult retourne `True`.
emo_confidence	float	Niveau de confiance de l'émotion reconnue pour la phrase actuelle. La valeur est comprise entre 0,0 et 1,0. Une valeur plus élevée indique un niveau de confiance supérieur. La reconnaissance des émotions est soumise aux contraintes suivantes : S'applique uniquement au modèle `paraformer-realtime-8k-v2`. Vous devez désactiver la ponctuation sémantique (contrôlée par le paramètre de requête `semantic_punctuation_enabled`). La ponctuation sémantique est désactivée par défaut. Le résultat de la reconnaissance des émotions s'affiche uniquement lorsque la méthode `is_sentence_end` de RecognitionResult retourne `True`.

Informations d'horodatage des mots (Word)

Les membres de la classe Word sont les suivants :

Paramètre	Type	Description
begin_time	int	Heure de début du mot, en ms.
end_time	int	Heure de fin du mot, en ms.
text	str	Le mot.
punctuation	str	La ponctuation.

Codes d'erreur

Si vous rencontrez des erreurs, consultez 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 pour une investigation plus approfondie.

Plus d'exemples

Pour plus d'exemples, voir GitHub.

FAQ

Fonctionnalités

Q : Comment maintenir une connexion longue avec le serveur lors d'un silence prolongé ?

Définissez le paramètre de requête heartbeat sur true et envoyez continuellement de l'audio silencieux au serveur.

L'audio silencieux désigne des fichiers audio ou des flux de données ne contenant aucun signal sonore. L'audio silencieux peut être généré par diverses méthodes, par exemple en utilisant des logiciels d'édition audio comme Audacity ou Adobe Audition, ou via des outils en ligne de commande comme FFmpeg.

Q : Comment convertir l'audio vers un format pris en charge ?

Vous pouvez utiliser l'outil FFmpeg. Pour plus d'informations sur son utilisation, reportez-vous au site officiel de FFmpeg.

# Basic conversion command (universal template)
# -i: Input file path. Example: audio.wav
# -c:a: Audio codec. Example: aac, libmp3lame, pcm_s16le
# -b:a: Bitrate (quality control). Example: 192k, 320k
# -ar: Sample rate. Example: 44100 (CD), 48000, 16000
# -ac: Number of channels. Example: 1 (mono), 2 (stereo)
# -y: Overwrite existing file (no value needed)
ffmpeg -i input_audio.ext -c:a codec_name -b:a bitrate -ar sample_rate -ac channels output.ext

# Example: WAV -> MP3 (preserve original quality)
ffmpeg -i input.wav -c:a libmp3lame -q:a 0 output.mp3
# Example: MP3 -> WAV (16-bit PCM standard format)
ffmpeg -i input.mp3 -c:a pcm_s16le -ar 44100 -ac 2 output.wav
# Example: M4A -> AAC (extract/convert Apple audio)
ffmpeg -i input.m4a -c:a copy output.aac  # Direct extraction without re-encoding
ffmpeg -i input.m4a -c:a aac -b:a 256k output.aac  # Re-encode for higher quality
# Example: FLAC lossless -> Opus (high compression)
ffmpeg -i input.flac -c:a libopus -b:a 128k -vbr on output.opus

Q : Est-il possible de consulter la plage temporelle de chaque phrase ?

Oui. Les résultats de la reconnaissance vocale incluent les horodatages de début et de fin pour chaque phrase, ce qui permet de déterminer la plage temporelle de chacune.

Q : Comment reconnaître un fichier local (fichier audio enregistré) ?

Il existe deux façons de reconnaître un fichier local :

Transmettre directement le chemin du fichier local : Cette méthode retourne le résultat complet de la reconnaissance une fois le fichier entièrement traité. Elle ne convient pas aux scénarios nécessitant un retour immédiat.

Transmettez le chemin du fichier à la méthode call de la classe Recognition pour reconnaître directement le fichier audio. Pour plus d'informations, voir Appel non streaming.
Convertir le fichier local en flux binaire pour la reconnaissance : Cette méthode retourne les résultats de reconnaissance sous forme de flux pendant le traitement du fichier. Elle convient aux scénarios nécessitant un retour immédiat.

Vous pouvez utiliser la méthode send_audio_frame de la classe Recognition pour envoyer un flux binaire au serveur pour reconnaissance. Pour plus d'informations, voir appel streaming bidirectionnel.

Dépannage

Q : Qu'est-ce qui cause l'échec de la reconnaissance vocale (aucun résultat de reconnaissance) ?

Vérifiez si le format audio (format) et le taux d'échantillonnage (sampleRate/sample_rate) dans les paramètres de requête sont correctement définis et respectent les contraintes des paramètres. Voici des exemples d'erreurs courantes :
- L'extension du fichier audio est .wav, mais le format réel est MP3, et le paramètre de requête format est défini sur mp3 (paramétrage incorrect).
- Le taux d'échantillonnage audio est de 3600 Hz, mais le paramètre de requête sampleRate/sample_rate est défini sur 48000 (paramétrage incorrect).
Vous pouvez utiliser l'outil ffprobe pour obtenir des informations sur le conteneur, le codec, le taux d'échantillonnage, les canaux et autres détails de l'audio :
```
ffprobe -v error -show_entries format=format_name -show_entries stream=codec_name,sample_rate,channels -of default=noprint_wrappers=1 input.xxx
```
Lors de l'utilisation du modèle paraformer-realtime-v2, vérifiez si la langue définie dans language_hints correspond à la langue réelle de l'audio.

Par exemple : L'audio est en réalité en chinois, mais language_hints est défini sur en (anglais).
Si toutes les vérifications ci-dessus sont concluantes, vous pouvez utiliser des mots-clés personnalisés pour améliorer la précision de la reconnaissance pour des termes spécifiques.