Skip to main content

Paraformer Java SDK

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

Alibaba Cloud Model Studio a publié un domaine spécifique à l'espace de travail pour la région Chine (Pékin). Ce nouveau domaine dédié offre des performances supérieures et une stabilité accrue pour les requêtes d'inférence. Nous vous recommandons de migrer de dashscope.aliyuncs.com vers {WorkspaceId}.cn-beijing.maas.aliyuncs.com.Remplacez {WorkspaceId} par votre véritable ID d'espace de travail. Le domaine existant reste pleinement fonctionnel.
Ce document s'applique uniquement à la région Chine (Pékin). Pour utiliser des modèles, vous devez disposer d'une clé API provenant de la région Chine (Pékin).
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.
Lorsque vous devez accorder un accès temporaire à des applications tierces ou à des utilisateurs, ou lorsque vous souhaitez contrôler strictement des opérations sensibles telles que l'accès ou la suppression de données confidentielles, nous 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 parfaitement aux scénarios d'appels temporaires et réduisent efficacement le risque de fuite de clé API.Utilisation : Dans votre code, remplacez la clé API initialement utilisée pour l'authentification par le jeton d'authentification temporaire obtenu.

Liste des modèles

paraformer-realtime-v2paraformer-realtime-8k-v2
Cas d'utilisationStreaming en direct, réunions et scénarios similairesReconnaissance audio 8 kHz pour des scénarios tels que le service client téléphonique et la messagerie vocale
Taux d'échantillonnageQuelconque8kHz
LangueChinois (y compris le mandarin et divers dialectes), anglais, japonais, coréen, allemand, français, russeDialectes chinois pris en charge : shanghaïen, wu, minnan, nord-est, gansu, guizhou, henan, hubei, hunan, jiangxi, ningxia, shanxi, shaanxi, shandong, sichuan, tianjin, yunnan, cantonaisChinois
Prédiction de la ponctuationPrise en charge par défaut, aucune configuration requisePrise en charge par défaut, aucune configuration requise
Normalisation inverse du texte (ITN)Prise en charge par défaut, aucune configuration requisePrise en charge par défaut, aucune configuration requise
Mots chauds personnalisésVoir Mots chauds personnalisésVoir Mots chauds personnalisés
Spécifier la langue de reconnaissanceSpécifiez via le paramètre language_hints
Reconnaissance des sentiments
La reconnaissance des sentiments est soumise aux contraintes suivantes :
  • Disponible uniquement pour le modèle paraformer-realtime-8k-v2.
  • La segmentation sémantique doit être désactivée (contrôlée via les Paramètres de requête semantic_punctuation_enabled). La segmentation sémantique est désactivée par défaut.
  • Les résultats de reconnaissance des sentiments ne s'affichent que lorsque la méthode isSentenceEnd du Résultat de reconnaissance en temps réel (RecognitionResult) retourne true.
Pour obtenir les résultats de reconnaissance des sentiments : Appelez les méthodes getEmoTag et getEmoConfidence des Informations sur la phrase (Sentence) afin d'obtenir respectivement le sentiment et le niveau de confiance du sentiment pour la phrase actuelle.

Démarrage rapide

La classe Recognition fournit des interfaces d'appel non streaming et streaming bidirectionnel. Choisissez la méthode d'appel appropriée selon vos besoins :
  • Appel non streaming : Reconnaît les fichiers locaux et retourne le résultat complet en une seule fois. Convient au traitement d'audio préenregistré.
  • Appel streaming bidirectionnel : Reconnaît directement les flux audio et produit des résultats en temps réel. Le flux audio peut provenir de périphériques externes (comme un microphone) ou être lu depuis un fichier local. Idéal pour les scénarios nécessitant un retour immédiat.

Appel non streaming

Soumettez une tâche unique de transcription vocale en temps réel et obtenez de manière synchrone le résultat de transcription en transmettant un fichier local.
image
Instanciez la classe Recognition, appelez la méthode call avec les paramètres de requête et le fichier à reconnaître, effectuez la reconnaissance, puis récupérez le résultat.
import com.alibaba.dashscope.audio.asr.recognition.Recognition;
import com.alibaba.dashscope.audio.asr.recognition.RecognitionParam;
import com.alibaba.dashscope.utils.Constants;

import java.io.File;

public class Main {
    public static void main(String[] args) {
        // The following configuration is for the China (Beijing) region. Replace "{WorkspaceId}" with your actual workspace ID. The configuration varies by region.
        Constants.baseWebsocketApiUrl = "wss://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/api-ws/v1/inference";
        // Create a Recognition instance
        Recognition recognizer = new Recognition();
        // Create RecognitionParam
        RecognitionParam param =
                RecognitionParam.builder()
                        // If you have not configured the API Key as an environment variable, uncomment the following line and replace apiKey with your own API Key
                        // .apiKey("yourApikey")
                        .model("paraformer-realtime-v2")
                        .format("wav")
                        .sampleRate(16000)
                        // "language_hints" is only supported by the paraformer-realtime-v2 model
                        .parameter("language_hints", new String[]{"zh", "en"})
                        .build();

        try {
            System.out.println("Recognition result: " + recognizer.call(param, new File("{YOUR_AUDIO_FILE}")));
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // Close the WebSocket connection after the task ends
            recognizer.getDuplexApi().close(1000, "bye");
        }
        System.out.println(
                "[Metric] requestId: "
                        + recognizer.getLastRequestId()
                        + ", first package delay ms: "
                        + recognizer.getFirstPackageDelay()
                        + ", last package delay ms: "
                        + recognizer.getLastPackageDelay());
        System.exit(0);
    }
}

Streaming bidirectionnel : basé sur les callbacks

Soumettez une tâche unique de transcription vocale en temps réel et recevez les résultats de reconnaissance en temps réel via l'interface de callback.
image
  1. Démarrez la reconnaissance vocale en streaming Instanciez la classe Recognition, appelez la méthode call avec les paramètres de requête et l'interface de callback (ResultCallback) pour lancer la reconnaissance vocale en streaming.
  2. Transmettez les données audio en streaming Appelez la méthode sendAudioFrame de la classe Recognition dans une boucle pour envoyer au serveur des segments de flux audio binaire lus depuis un fichier local ou un périphérique (tel qu'un microphone). Pendant la transmission des données audio, le serveur renvoie les résultats de reconnaissance au client en temps réel via la méthode onEvent de l'interface de callback (ResultCallback). Il est recommandé que chaque segment audio dure environ 100 millisecondes, avec une taille de données comprise entre 1 Ko et 16 Ko.
  3. Terminez 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 callback onComplete ou onError de l'interface de callback (ResultCallback) soit déclenché.
import com.alibaba.dashscope.audio.asr.recognition.Recognition;
import com.alibaba.dashscope.audio.asr.recognition.RecognitionParam;
import com.alibaba.dashscope.audio.asr.recognition.RecognitionResult;
import com.alibaba.dashscope.common.ResultCallback;
import com.alibaba.dashscope.utils.Constants;

import javax.sound.sampled.AudioFormat;
import javax.sound.sampled.AudioSystem;
import javax.sound.sampled.TargetDataLine;

import java.nio.ByteBuffer;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class Main {
    public static void main(String[] args) throws InterruptedException {
        // The following configuration is for the China (Beijing) region. Replace "{WorkspaceId}" with your actual workspace ID. The configuration varies by region.
        Constants.baseWebsocketApiUrl = "wss://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/api-ws/v1/inference";
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        executorService.submit(new RealtimeRecognitionTask());
        executorService.shutdown();
        executorService.awaitTermination(1, TimeUnit.MINUTES);
        System.exit(0);
    }
}

class RealtimeRecognitionTask implements Runnable {
    @Override
    public void run() {
        RecognitionParam param = RecognitionParam.builder()
                // If you have not configured the API Key as an environment variable, replace apiKey with your own API Key
                // .apiKey("yourApikey")
                .model("paraformer-realtime-v2")
                .format("wav")
                .sampleRate(16000)
                // "language_hints" is only supported by the paraformer-realtime-v2 model
                .parameter("language_hints", new String[]{"zh", "en"})
                .build();
        Recognition recognizer = new Recognition();

        ResultCallback<RecognitionResult> callback = new ResultCallback<RecognitionResult>() {
            @Override
            public void onEvent(RecognitionResult result) {
                if (result.isSentenceEnd()) {
                    System.out.println("Final Result: " + result.getSentence().getText());
                } else {
                    System.out.println("Intermediate Result: " + result.getSentence().getText());
                }
            }

            @Override
            public void onComplete() {
                System.out.println("Recognition complete");
            }

            @Override
            public void onError(Exception e) {
                System.out.println("RecognitionCallback error: " + e.getMessage());
            }
        };
        try {
            recognizer.call(param, callback);
            // Create audio format
            AudioFormat audioFormat = new AudioFormat(16000, 16, 1, true, false);
            // Match the default recording device based on the format
            TargetDataLine targetDataLine =
                    AudioSystem.getTargetDataLine(audioFormat);
            targetDataLine.open(audioFormat);
            // Start recording
            targetDataLine.start();
            ByteBuffer buffer = ByteBuffer.allocate(1024);
            long start = System.currentTimeMillis();
            // Record for 50s and perform real-time transcription
            while (System.currentTimeMillis() - start < 50000) {
                int read = targetDataLine.read(buffer.array(), 0, buffer.capacity());
                if (read > 0) {
                    buffer.limit(read);
                    // Send the recorded audio data to the streaming recognition service
                    recognizer.sendAudioFrame(buffer);
                    buffer = ByteBuffer.allocate(1024);
                    // Recording rate is limited, sleep briefly to prevent high CPU usage
                    Thread.sleep(20);
                }
            }
            recognizer.stop();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // Close the WebSocket connection after the task ends
            recognizer.getDuplexApi().close(1000, "bye");
        }

        System.out.println(
                "[Metric] requestId: "
                        + recognizer.getLastRequestId()
                        + ", first package delay ms: "
                        + recognizer.getFirstPackageDelay()
                        + ", last package delay ms: "
                        + recognizer.getLastPackageDelay());
    }
}

Streaming bidirectionnel : basé sur Flowable

Soumettez une tâche unique de transcription vocale en temps réel et recevez les résultats de reconnaissance en temps réel via un workflow Flowable. Flowable est un framework open source de gestion des workflows et des processus métier, publié sous licence Apache 2.0. Pour plus d'informations sur Flowable, consultez la documentation de l'API Flowable.
Appelez directement la méthode streamCall de la classe Recognition pour démarrer la reconnaissance.La méthode streamCall retourne une instance Flowable<RecognitionResult>. Vous pouvez appeler des méthodes telles que blockingForEach et subscribe de l'instance Flowable pour traiter les résultats de reconnaissance. Ces résultats sont encapsulés dans RecognitionResult.La méthode streamCall nécessite deux paramètres :
  • Une instance RecognitionParam (Paramètres de requête) : Utilisez-la pour définir des paramètres tels que le modèle, le taux d'échantillonnage et le format audio pour la reconnaissance vocale.
  • Une instance Flowable<ByteBuffer> : Vous devez créer une instance de type Flowable<ByteBuffer> et y implémenter la méthode d'analyse du flux audio.
import com.alibaba.dashscope.audio.asr.recognition.Recognition;
import com.alibaba.dashscope.audio.asr.recognition.RecognitionParam;
import com.alibaba.dashscope.exception.NoApiKeyException;
import com.alibaba.dashscope.utils.Constants;
import io.reactivex.BackpressureStrategy;
import io.reactivex.Flowable;

import javax.sound.sampled.AudioFormat;
import javax.sound.sampled.AudioSystem;
import javax.sound.sampled.TargetDataLine;
import java.nio.ByteBuffer;

public class Main {
    public static void main(String[] args) throws NoApiKeyException {
        // The following configuration is for the China (Beijing) region. Replace "{WorkspaceId}" with your actual workspace ID. The configuration varies by region.
        Constants.baseWebsocketApiUrl = "wss://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/api-ws/v1/inference";
        // Create a Flowable<ByteBuffer>
        Flowable<ByteBuffer> audioSource =
                Flowable.create(
                        emitter -> {
                            new Thread(
                                    () -> {
                                        try {
                                            // Create audio format
                                            AudioFormat audioFormat = new AudioFormat(16000, 16, 1, true, false);
                                            // Match the default recording device based on the format
                                            TargetDataLine targetDataLine =
                                                    AudioSystem.getTargetDataLine(audioFormat);
                                            targetDataLine.open(audioFormat);
                                            // Start recording
                                            targetDataLine.start();
                                            ByteBuffer buffer = ByteBuffer.allocate(1024);
                                            long start = System.currentTimeMillis();
                                            // Record for 50s and perform real-time transcription
                                            while (System.currentTimeMillis() - start < 50000) {
                                                int read = targetDataLine.read(buffer.array(), 0, buffer.capacity());
                                                if (read > 0) {
                                                    buffer.limit(read);
                                                    // Send the recorded audio data to the streaming recognition service
                                                    emitter.onNext(buffer);
                                                    buffer = ByteBuffer.allocate(1024);
                                                    // Recording rate is limited, sleep briefly to prevent high CPU usage
                                                    Thread.sleep(20);
                                                }
                                            }
                                            // Notify the end of transcription
                                            emitter.onComplete();
                                        } catch (Exception e) {
                                            emitter.onError(e);
                                        }
                                    })
                                    .start();
                        },
                        BackpressureStrategy.BUFFER);

        // Create Recognizer
        Recognition recognizer = new Recognition();
        // Create RecognitionParam, pass the Flowable<ByteBuffer> created above to the audioFrames parameter
        RecognitionParam param = RecognitionParam.builder()
                // If you have not configured the API Key as an environment variable, replace apiKey with your own API Key
                // .apiKey("yourApikey")
                .model("paraformer-realtime-v2")
                .format("pcm")
                .sampleRate(16000)
                // "language_hints" is only supported by the paraformer-realtime-v2 model
                .parameter("language_hints", new String[]{"zh", "en"})
                .build();

        // Streaming call interface
        recognizer
                .streamCall(param, audioSource)
                .blockingForEach(
                        result -> {
                            // Subscribe to the output result
                            if (result.isSentenceEnd()) {
                                System.out.println("Final Result: " + result.getSentence().getText());
                            } else {
                                System.out.println("Intermediate Result: " + result.getSentence().getText());
                            }
                        });
        // Close the WebSocket connection after the task ends
        recognizer.getDuplexApi().close(1000, "bye");
        System.out.println(
                "[Metric] requestId: "
                        + recognizer.getLastRequestId()
                        + ", first package delay ms: "
                        + recognizer.getFirstPackageDelay()
                        + ", last package delay ms: "
                        + recognizer.getLastPackageDelay());
        System.exit(0);
    }
}

Appels à haute concurrence

Le SDK Java DashScope utilise le pool de connexions OkHttp3 pour réduire la surcharge liée à l'établissement répété de connexions. Pour plus d'informations, consultez Optimiser la reconnaissance vocale en temps réel Paraformer pour une concurrence élevée.

Paramètres de requête

Configurez des paramètres tels que le modèle, le taux d'échantillonnage et le format audio via les méthodes chaînées de RecognitionParam. Transmettez l'objet paramètre configuré à la méthode call/streamCall de la classe Recognition.
RecognitionParam param = RecognitionParam.builder()
  .model("paraformer-realtime-v2")
  .format("pcm")
  .sampleRate(16000)
  // "language_hints" is only supported by the paraformer-realtime-v2 model
  .parameter("language_hints", new String[]{"zh", "en"})
  .build();
ParamètreTypeValeur par défautObligatoireDescription
modelString
OuiModèle pour la reconnaissance vocale en temps réel. Pour plus d'informations, consultez la Liste des modèles.
sampleRateInteger
OuiDé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 prend uniquement en charge le taux d'échantillonnage de 8000 Hz.
formatString
OuiDéfinissez le format audio à reconnaître.Formats audio pris en charge : pcm, wav, mp3, opus, speex, aac, amr.
opus/speex : Doivent utiliser l'encapsulation Ogg.wav : Doit être encodé en PCM.amr : Seul le type AMR-NB est pris en charge.
vocabularyIdString
NonDéfinissez l'ID des mots chauds. Si ce champ n'est pas défini, les mots chauds ne seront pas pris en compte. Utilisez ce champ pour définir l'ID des mots chauds pour les modèles v2 et ultérieurs.Dans la session de reconnaissance vocale en cours, les informations relatives aux mots chauds correspondant à cet ID seront appliquées. Pour plus de détails sur l'utilisation, consultez Mots chauds personnalisés.
disfluencyRemovalEnabledbooleanfalseNonIndiquez si vous souhaitez filtrer les mots de remplissage :
  • true : Filtrer les mots de remplissage
  • false (par défaut) : Ne pas filtrer les mots de remplissage
language_hintsString[]["zh", "en"]NonDé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 ne prend effet que pour les modèles prenant en charge plusieurs langues (voir la Liste des modèles).
language_hints doit être défini via la méthode parameter ou la méthode parameters de l'instance RecognitionParam :
RecognitionParam param = RecognitionParam.builder()
 .model("paraformer-realtime-v2")
 .format("pcm")
 .sampleRate(16000)
 .parameter("language_hints", new String[]{"zh", "en"})
 .build();
semantic_punctuation_enabledbooleanfalseNonIndiquez si vous souhaitez activer la segmentation sémantique. Désactivée par défaut.
  • true : Activer la segmentation sémantique et désactiver la segmentation VAD (Voice Activity Detection).
  • false (par défaut) : Activer la segmentation VAD (Voice Activity Detection) et désactiver 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.
semantic_punctuation_enabled doit être défini via la méthode parameter ou la méthode parameters de l'instance RecognitionParam :
RecognitionParam param = RecognitionParam.builder()
 .model("paraformer-realtime-v2")
 .format("pcm")
 .sampleRate(16000)
 .parameter("semantic_punctuation_enabled", true)
 .build();
max_sentence_silenceInteger800NonDé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 valeurs de ce paramètre 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.
max_sentence_silence doit être défini via la méthode parameter ou la méthode parameters de l'instance RecognitionParam :
RecognitionParam param = RecognitionParam.builder()
 .model("paraformer-realtime-v2")
 .format("pcm")
 .sampleRate(16000)
 .parameter("max_sentence_silence", 800)
 .build();
multi_threshold_mode_enabledbooleanfalseNonLorsque 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.
multi_threshold_mode_enabled doit être défini via la méthode parameter ou la méthode parameters de l'instance RecognitionParam :
RecognitionParam param = RecognitionParam.builder()
 .model("paraformer-realtime-v2")
 .format("pcm")
 .sampleRate(16000)
 .parameter("multi_threshold_mode_enabled", true)
 .build();
punctuation_prediction_enabledbooleantrueNonIndiquez si vous souhaitez ajouter automatiquement de 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.
punctuation_prediction_enabled doit être défini via la méthode parameter ou la méthode parameters de l'instance RecognitionParam :
RecognitionParam param = RecognitionParam.builder()
 .model("paraformer-realtime-v2")
 .format("pcm")
 .sampleRate(16000)
 .parameter("punctuation_prediction_enabled", false)
 .build();
heartbeatbooleanfalseNonLorsque 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.
La version du SDK doit être 2.19.1 ou ultérieure pour utiliser ce champ.heartbeat doit être défini via la méthode parameter ou la méthode parameters de l'instance RecognitionParam :
RecognitionParam param = RecognitionParam.builder()
 .model("paraformer-realtime-v2")
 .format("pcm")
 .sampleRate(16000)
 .parameter("heartbeat", true)
 .build();
inverse_text_normalization_enabledbooleantrueNonIndiquez si vous souhaitez activer l'ITN (Normalisation Inverse du Texte).Activé par défaut (true). Lorsqu'il est activé, les chiffres chinois sont convertis en chiffres arabes.Ce paramètre ne prend effet que lorsque le modèle est v2 ou ultérieur.
inverse_text_normalization_enabled doit être défini via la méthode parameter ou la méthode parameters de l'instance RecognitionParam :
RecognitionParam param = RecognitionParam.builder()
 .model("paraformer-realtime-v2")
 .format("pcm")
 .sampleRate(16000)
 .parameter("inverse_text_normalization_enabled", false)
 .build();
apiKeyString
NonClé API de l'utilisateur.

Référence de l’API

Classe Recognition

Recognition est importé via "import com.alibaba.dashscope.audio.asr.recognition.Recognition;". Ses interfaces clés sont les suivantes :
Interface/MéthodeParamètreValeur de retourDescription
public void call(RecognitionParam param, final ResultCallback<RecognitionResult> callback)
AucuneReconnaissance en temps réel streaming basée sur les callbacks. Cette méthode ne bloque pas le thread actuel.
public String call(RecognitionParam param, File file)
Résultat de reconnaissanceAppel non streaming basé sur un fichier local. Cette méthode bloque le thread actuel jusqu'à ce que tout l'audio ait été lu. Le fichier à reconnaître doit disposer des autorisations de lecture.
public Flowable<RecognitionResult> streamCall(RecognitionParam param, Flowable<ByteBuffer> audioFrame)
Flowable<RecognitionResult>Reconnaissance en temps réel streaming basée sur Flowable.
public void sendAudioFrame(ByteBuffer audioFrame)
  • audioFrame : Flux audio binaire de type ByteBuffer
AucuneEnvoyez des données audio. Chaque paquet audio ne doit être ni trop grand ni trop petit. Il est recommandé que chaque paquet dure environ 100 ms, avec une taille comprise entre 1 Ko et 16 Ko.Les résultats de reconnaissance sont obtenus via la méthode onEvent de l'Interface de callback (ResultCallback).
public void stop()
AucunAucuneArrêtez la reconnaissance en temps réel.Cette méthode bloque le thread actuel jusqu'à ce que la méthode onComplete ou onError de l'instance ResultCallback soit appelée.
recognizer.getDuplexApi().close(int code, String reason)
code : Code de fermeture WebSocketreason : Raison de la fermetureCes deux paramètres peuvent être configurés conformément à la documentation The WebSocket Protocol.trueUne fois la tâche terminée, la connexion WebSocket doit être fermée, qu'une exception se soit produite ou non, afin d'éviter les fuites de connexion. Pour savoir comment réutiliser les connexions afin d'améliorer l'efficacité, consultez Optimiser la reconnaissance vocale en temps réel Paraformer pour une concurrence élevée.
public String getLastRequestId()
AucunrequestIdObtenez le requestId de la tâche en cours. Disponible après le démarrage d'une nouvelle tâche avec call ou streamingCall.
Cette méthode est disponible à partir de la version 2.18.0 du SDK.
public long getFirstPackageDelay()
AucunDélai du premier paquetObtenez le délai du premier paquet, c'est-à-dire la latence entre l'envoi du premier paquet audio et la réception du premier résultat de reconnaissance. À utiliser une fois la tâche terminée.
Cette méthode est disponible à partir de la version 2.18.0 du SDK.
public long getLastPackageDelay()
AucunDélai du dernier paquetObtenez le délai du dernier paquet, c'est-à-dire la latence entre l'envoi de la commande stop et la réception du dernier résultat de reconnaissance. À utiliser une fois la tâche terminée.
Cette méthode est disponible à partir de la version 2.18.0 du SDK.

Interface de callback (ResultCallback)

Lors des appels streaming bidirectionnels, le serveur renvoie des informations clés sur le processus et des données au client via des callbacks. Vous devez implémenter les méthodes de callback pour traiter les informations ou les données retournées par le serveur. Les méthodes de callback sont implémentées en étendant la classe abstraite ResultCallback. Lors de l'extension de cette classe abstraite, vous pouvez spécifier le type générique comme RecognitionResult. RecognitionResult encapsule la structure de données retournée par le serveur. Étant donné que Java prend en charge la réutilisation des connexions, il n'y a pas de callbacks onClose ou onOpen.
ResultCallback<RecognitionResult> callback = new ResultCallback<RecognitionResult>() {
    @Override
    public void onEvent(RecognitionResult result) {
        System.out.println("RequestId: " + result.getRequestId());
        // Implement your logic to process speech recognition results here
    }

    @Override
    public void onComplete() {
        System.out.println("Task completed");
    }

    @Override
    public void onError(Exception e) {
        System.out.println("Task failed: " + e.getMessage());
    }
};
Interface/MéthodeParamètreValeur de retourDescription
public void onEvent(RecognitionResult result)
result : Résultat de reconnaissance en temps réel (RecognitionResult)AucuneAppelé lorsque le serveur envoie une réponse.
public void onComplete()
AucunAucuneAppelé lorsque la tâche est terminée.
public void onError(Exception e)
e : Informations sur l'exceptionAucuneAppelé lorsqu'une exception survient.

Réponse

Résultat de reconnaissance en temps réel (RecognitionResult)

RecognitionResult représente le résultat d'une session de reconnaissance en temps réel.
Interface/MéthodeParamètreValeur de retourDescription
public String getRequestId()
AucunrequestIdObtenez le requestId.
public boolean isSentenceEnd()
AucunIndique s'il s'agit d'une phrase complète, c'est-à-dire si une limite de phrase a été atteinteDéterminez si la phrase donnée est terminée.
public Sentence getSentence()
AucunInformations sur la phrase (Sentence)Obtenez les informations sur la phrase, y compris les horodatages et le texte.

Informations sur la phrase (Sentence)

Interface/MéthodeParamètreValeur de retourDescription
public Long getBeginTime()
AucunHeure de début de la phrase en msRetourne l'heure de début de la phrase.
public Long getEndTime()
AucunHeure de fin de la phrase en msRetourne l'heure de fin de la phrase.
public String getText()
AucunTexte reconnuRetourne le texte reconnu.
public List<Word> getWords()
AucunListe des Informations d'horodatage des mots (Word)Retourne les informations d'horodatage au niveau des mots.
public String getEmoTag()
AucunSentiment de la phrase actuelleRetourne le sentiment de la phrase actuelle :
  • positive : Sentiment positif, tel que heureux ou satisfait
  • negative : Sentiment négatif, tel que en colère ou morose
  • neutral : Aucun sentiment évident
La reconnaissance des sentiments est soumise aux contraintes suivantes :
  • Disponible uniquement pour le modèle paraformer-realtime-8k-v2.
  • La segmentation sémantique doit être désactivée (contrôlée via les Paramètres de requête semantic_punctuation_enabled). La segmentation sémantique est désactivée par défaut.
  • Les résultats de reconnaissance des sentiments ne s'affichent que lorsque la méthode isSentenceEnd du Résultat de reconnaissance en temps réel (RecognitionResult) retourne true.
public Double getEmoConfidence()
AucunNiveau de confiance du sentiment de la phrase actuelleRetourne le niveau de confiance du sentiment de la phrase actuelle. Plage de valeurs : [0,0, 1,0]. Une valeur plus élevée indique une confiance plus grande.La reconnaissance des sentiments est soumise aux contraintes suivantes :
  • Disponible uniquement pour le modèle paraformer-realtime-8k-v2.
  • La segmentation sémantique doit être désactivée (contrôlée via les Paramètres de requête semantic_punctuation_enabled). La segmentation sémantique est désactivée par défaut.
  • Les résultats de reconnaissance des sentiments ne s'affichent que lorsque la méthode isSentenceEnd du Résultat de reconnaissance en temps réel (RecognitionResult) retourne true.

Informations d'horodatage des mots (Word)

Interface/MéthodeParamètreValeur de retourDescription
public long getBeginTime()
AucunHeure de début du mot en msRetourne l'heure de début du mot.
public long getEndTime()
AucunHeure de fin du mot en msRetourne l'heure de fin du mot.
public String getText()
AucunMotRetourne le mot reconnu.
public String getPunctuation()
AucunPonctuationRetourne la ponctuation.

Autres exemples

Pour plus d'exemples, consultez GitHub.

Codes d’erreur

Si vous rencontrez des erreurs, consultez les 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.