Tous les produits
Search

Ce produit

    Alibaba Cloud Model Studio:Paraformer Real-time Speech Recognition Java SDK

    Centre de documentation

    Alibaba Cloud Model Studio:Paraformer Real-time Speech Recognition Java SDK

    Dernière mise à jour :Sep 07, 2026

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

    ImportantAlibaba 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.

    ImportantCe 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.

    RemarqueLorsque 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'utilisation

    Streaming en direct, réunions et scénarios similaires

    Reconnaissance audio 8 kHz pour 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

    Prise en charge par défaut, aucune configuration requise

    Prise en charge par défaut, aucune configuration requise

    Normalisation inverse du texte (ITN)

    Prise en charge par défaut, aucune configuration requise

    Prise en charge par défaut, aucune configuration requise

    Mots chauds personnalisés

    Voir Mots chauds personnalisés

    Voir Mots chauds personnalisés

    Spécifier la langue de reconnaissance

    Spécifiez via le paramètre language_hints

    Reconnaissance des sentiments

    (Cliquez pour voir l'utilisation)

    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.

    Cliquez pour voir l'exemple complet

    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é.

    Cliquez pour voir l'exemple complet

    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());
    }
}

    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 java.io.FileInputStream;
import java.nio.ByteBuffer;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

class TimeUtils {
    private static final DateTimeFormatter formatter =
            DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SSS");

    public static String getTimestamp() {
        return LocalDateTime.now().format(formatter);
    }
}

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(Paths.get(System.getProperty("user.dir"), "{YOUR_AUDIO_FILE}")));
        executorService.shutdown();

        // wait for all tasks to complete
        executorService.awaitTermination(1, TimeUnit.MINUTES);
        System.exit(0);
    }
}

class RealtimeRecognitionTask implements Runnable {
    private Path filepath;

    public RealtimeRecognitionTask(Path filepath) {
        this.filepath = filepath;
    }

    @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();

        String threadName = Thread.currentThread().getName();

        ResultCallback<RecognitionResult> callback = new ResultCallback<RecognitionResult>() {
            @Override
            public void onEvent(RecognitionResult message) {
                if (message.isSentenceEnd()) {

                    System.out.println(TimeUtils.getTimestamp()+" "+
                            "[process " + threadName + "] Final Result:" + message.getSentence().getText());
                } else {
                    System.out.println(TimeUtils.getTimestamp()+" "+
                            "[process " + threadName + "] Intermediate Result: " + message.getSentence().getText());
                }
            }

            @Override
            public void onComplete() {
                System.out.println(TimeUtils.getTimestamp()+" "+"[" + threadName + "] Recognition complete");
            }

            @Override
            public void onError(Exception e) {
                System.out.println(TimeUtils.getTimestamp()+" "+
                        "[" + threadName + "] RecognitionCallback error: " + e.getMessage());
            }
        };

        try {
            recognizer.call(param, callback);
            // Please replace the path with your audio file path
            System.out.println(TimeUtils.getTimestamp()+" "+"[" + threadName + "] Input file_path is: " + this.filepath);
            // Read file and send audio by chunks
            FileInputStream fis = new FileInputStream(this.filepath.toFile());
            // chunk size set to 1 seconds for 16KHz sample rate
            byte[] buffer = new byte[3200];
            int bytesRead;
            // Loop to read chunks of the file
            while ((bytesRead = fis.read(buffer)) != -1) {
                ByteBuffer byteBuffer;
                // Handle the last chunk which might be smaller than the buffer size
                System.out.println(TimeUtils.getTimestamp()+" "+"[" + threadName + "] bytesRead: " + bytesRead);
                if (bytesRead < buffer.length) {
                    byteBuffer = ByteBuffer.wrap(buffer, 0, bytesRead);
                } else {
                    byteBuffer = ByteBuffer.wrap(buffer);
                }

                recognizer.sendAudioFrame(byteBuffer);
                buffer = new byte[3200];
                Thread.sleep(100);
            }
            System.out.println(TimeUtils.getTimestamp()+" "+LocalDateTime.now());
            recognizer.stop();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // Close the WebSocket connection after the task ends
            recognizer.getDuplexApi().close(1000, "bye");
        }

        System.out.println(
                "["
                        + threadName
                        + "][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.

    Cliquez pour voir l'exemple complet

    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.

    Cliquez pour voir l'exemple

    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

    model

    String

    Oui

    Modèle pour la reconnaissance vocale en temps réel. Pour plus d'informations, consultez la Liste des modèles.

    sampleRate

    Integer

    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 prend uniquement en charge le taux d'échantillonnage de 8000 Hz.

    format

    String

    Oui

    Définissez le format audio à reconnaître.

    Formats audio pris en charge : pcm, wav, mp3, opus, speex, aac, amr.

    Importantopus/speex : Doivent utiliser l'encapsulation Ogg.

    wav : Doit être encodé en PCM.

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

    vocabularyId

    String

    Non

    Dé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.

    disfluencyRemovalEnabled

    boolean

    false

    Non

    Indiquez 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_hints

    String[]

    ["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 ne prend effet que pour les modèles prenant en charge plusieurs langues (voir la Liste des modèles).

    Remarquelanguage_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();

    RecognitionParam param = RecognitionParam.builder()
 .model("paraformer-realtime-v2")
 .format("pcm")
 .sampleRate(16000)
 .parameters(Collections.singletonMap("language_hints", new String[]{"zh", "en"}))
 .build();

    semantic_punctuation_enabled

    boolean

    false

    Non

    Indiquez 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.

    Remarquesemantic_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();

    RecognitionParam param = RecognitionParam.builder()
 .model("paraformer-realtime-v2")
 .format("pcm")
 .sampleRate(16000)
 .parameters(Collections.singletonMap("semantic_punctuation_enabled", true))
 .build();

    max_sentence_silence

    Integer

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

    Remarquemax_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();

    RecognitionParam param = RecognitionParam.builder()
 .model("paraformer-realtime-v2")
 .format("pcm")
 .sampleRate(16000)
 .parameters(Collections.singletonMap("max_sentence_silence", 800))
 .build();

    multi_threshold_mode_enabled

    boolean

    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.

    Remarquemulti_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();

    RecognitionParam param = RecognitionParam.builder()
 .model("paraformer-realtime-v2")
 .format("pcm")
 .sampleRate(16000)
 .parameters(Collections.singletonMap("multi_threshold_mode_enabled", true))
 .build();

    punctuation_prediction_enabled

    boolean

    true

    Non

    Indiquez 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.

    Remarquepunctuation_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();

    RecognitionParam param = RecognitionParam.builder()
 .model("paraformer-realtime-v2")
 .format("pcm")
 .sampleRate(16000)
 .parameters(Collections.singletonMap("punctuation_prediction_enabled", false))
 .build();

    heartbeat

    boolean

    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.

    RemarqueLa 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();

    RecognitionParam param = RecognitionParam.builder()
 .model("paraformer-realtime-v2")
 .format("pcm")
 .sampleRate(16000)
 .parameters(Collections.singletonMap("heartbeat", true))
 .build();

    inverse_text_normalization_enabled

    boolean

    true

    Non

    Indiquez 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.

    Remarqueinverse_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();

    RecognitionParam param = RecognitionParam.builder()
 .model("paraformer-realtime-v2")
 .format("pcm")
 .sampleRate(16000)
 .parameters(Collections.singletonMap("inverse_text_normalization_enabled", false))
 .build();

    apiKey

    String

    Non

    Clé API de l'utilisateur.

    Interfaces clés

    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)

    Aucune

    Reconnaissance 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 reconnaissance

    Appel 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

    Aucune

    Envoyez 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()

    Aucun

    Aucune

    Arrê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 WebSocket

    reason : Raison de la fermeture

    Ces deux paramètres peuvent être configurés conformément à la documentation The WebSocket Protocol.

    true

    Une 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()

    Aucun

    requestId

    Obtenez le requestId de la tâche en cours. Disponible après le démarrage d'une nouvelle tâche avec call ou streamingCall.

    RemarqueCette méthode est disponible à partir de la version 2.18.0 du SDK.

    public long getFirstPackageDelay()

    Aucun

    Délai du premier paquet

    Obtenez 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.

    RemarqueCette méthode est disponible à partir de la version 2.18.0 du SDK.

    public long getLastPackageDelay()

    Aucun

    Délai du dernier paquet

    Obtenez 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.

    RemarqueCette 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.

    Exemple

    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)

    Aucune

    Appelé lorsque le serveur envoie une réponse.

    public void onComplete()

    Aucun

    Aucune

    Appelé lorsque la tâche est terminée.

    public void onError(Exception e)

    e : Informations sur l'exception

    Aucune

    Appelé 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()

    Aucun

    requestId

    Obtenez le requestId.

    public boolean isSentenceEnd()

    Aucun

    Indique s'il s'agit d'une phrase complète, c'est-à-dire si une limite de phrase a été atteinte

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

    public Sentence getSentence()

    Aucun

    Informations 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()

    Aucun

    Heure de début de la phrase en ms

    Retourne l'heure de début de la phrase.

    public Long getEndTime()

    Aucun

    Heure de fin de la phrase en ms

    Retourne l'heure de fin de la phrase.

    public String getText()

    Aucun

    Texte reconnu

    Retourne le texte reconnu.

    public List<Word> getWords()

    Aucun

    Liste des Informations d'horodatage des mots (Word)

    Retourne les informations d'horodatage au niveau des mots.

    public String getEmoTag()

    Aucun

    Sentiment de la phrase actuelle

    Retourne 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()

    Aucun

    Niveau de confiance du sentiment de la phrase actuelle

    Retourne 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()

    Aucun

    Heure de début du mot en ms

    Retourne l'heure de début du mot.

    public long getEndTime()

    Aucun

    Heure de fin du mot en ms

    Retourne l'heure de fin du mot.

    public String getText()

    Aucun

    Mot

    Retourne le mot reconnu.

    public String getPunctuation()

    Aucun

    Ponctuation

    Retourne la ponctuation.

    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.

    Plus d'exemples

    Pour plus d'exemples, consultez GitHub.

    FAQ

    Questions sur les fonctionnalités

    Q : Comment maintenir une connexion longue avec le serveur pendant 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 dans 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 de temps pour 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 de temps de chaque phrase.

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

    Il existe deux façons de reconnaître des fichiers locaux :

    • Transmettez directement le chemin du fichier local : Cette méthode obtient le résultat de reconnaissance complet uniquement une fois la reconnaissance entièrement terminée, et ne convient pas aux scénarios nécessitant un retour immédiat.

      Consultez Appel non streaming. Transmettez le chemin du fichier à la méthode call de la classe Recognition pour reconnaître directement le fichier enregistré.

    • Convertissez le fichier local en flux binaire pour la reconnaissance : Cette méthode reconnaît le fichier tout en diffusant les résultats de reconnaissance en streaming, ce qui convient aux scénarios nécessitant un retour immédiat.

    Dépannage

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

    1. 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

    2. 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).

    3. Si toutes les vérifications ci-dessus sont concluantes, vous pouvez utiliser des mots chauds personnalisés pour améliorer la précision de la reconnaissance pour des mots spécifiques.