Todos los productos
Search

Este producto

    Alibaba Cloud Model Studio:SDK de Java para reconocimiento de voz en tiempo real de Paraformer

    Centro de documentos

    Alibaba Cloud Model Studio:SDK de Java para reconocimiento de voz en tiempo real de Paraformer

    Última actualización: Oct 16, 2026

    Este tema describe los parámetros y los detalles de la interfaz del SDK de Java para reconocimiento de voz en tiempo real de Paraformer.

    ImportanteAlibaba Cloud Model Studio ha lanzado un dominio específico de espacio de trabajo para la región China (Beijing). El nuevo dominio dedicado ofrece un rendimiento superior y mayor estabilidad para las solicitudes de inferencia. Recomendamos migrar de dashscope.aliyuncs.com a {WorkspaceId}.cn-beijing.maas.aliyuncs.com.

    Reemplace {WorkspaceId} con su ID de espacio de trabajo real. El dominio existente permanece totalmente funcional.

    Guía del usuario: Para introducción al modelo y recomendaciones de selección, consulte Reconocimiento de voz en tiempo real - Fun-ASR/Paraformer.

    Requisitos previos

    Ha activado el servicio y ha seguido los pasos para Obtener una clave de API. Por favor, Configure la clave de API como una variable de entorno en lugar de codificarla directamente en su código para prevenir riesgos de seguridad causados por fugas de código.

    NotaCuando necesite proporcionar acceso temporal a aplicaciones o usuarios externos, o cuando want controlar estrictamente operaciones de alto riesgo como acceder o eliminar datos sensibles, le recomendamos utilizar tokens de autenticación temporal.

    En comparación con las claves de API a largo plazo, los tokens de autenticación temporal tienen un período de validez corto (60 segundos) y mayor seguridad, lo que los hace adecuados para escenarios de llamadas temporales y reduce eficazmente el riesgo de fuga de claves de API.

    Uso: En su código, reemplace la clave de API utilizada originalmente para la autenticación con el token de autenticación temporal obtenido.

    Lista de modelos

    paraformer-realtime-v2 (Recomendado)paraformer-realtime-8k-v2 (Recomendado)
    Caso de uso

    Transmisiones en vivo, reuniones y escenarios similares

    Reconocimiento de audio de 8 kHz en escenarios como servicio al cliente telefónico y correo de voz

    Tasa de muestreo

    Cualquiera

    8kHz

    Idioma

    Chino (incluyendo mandarín y varios dialectos), inglés, japonés, coreano, alemán, francés, ruso

    Dialectos chinos admitidos: Shanghainés, Wu, Minnan, Noreste, Gansu, Guizhou, Henan, Hubei, Hunan, Jiangxi, Ningxia, Shanxi, Shaanxi, Shandong, Sichuan, Tianjin, Yunnan, Cantonés

    Chino

    Predicción de puntuación

    Admitido por defecto, no requiere configuración

    Admitido por defecto, no requiere configuración

    Normalización inversa de texto (ITN)

    Admitido por defecto, no requiere configuración

    Admitido por defecto, no requiere configuración

    Palabras clave personalizadas

    Ver Palabras clave personalizadas

    Ver Palabras clave personalizadas

    Especificar idioma de reconocimiento

    Especificar mediante el parámetro language_hints

    Reconocimiento de sentimientos

    (Haga clic para ver el uso)

    El reconocimiento de sentimientos sigue estas restricciones:

    • Solo disponible para el modelo paraformer-realtime-8k-v2.
    • La segmentación semántica debe estar deshabilitada (controlada mediante Parámetros de solicitud semantic_punctuation_enabled). La segmentación semántica está deshabilitada por defecto.
    • Los resultados del reconocimiento de sentimiento solo se muestran cuando el método isSentenceEnd del Resultado de reconocimiento en tiempo real (RecognitionResult) devuelve true.

    Cómo obtener resultados de reconocimiento de sentimiento: Llame a los métodos getEmoTag y getEmoConfidence de Información de oración (Sentence) para obtener el sentimiento y la confianza del sentimiento de la oración actual, respectivamente.

    Inicio rápido

    La clase Recognition proporciona interfaces de llamada sin streaming y con streaming bidireccional. Elija el método de llamada apropiado según sus necesidades:

    • Llamada sin streaming: Reconoce archivos locales y devuelve el resultado completo de una sola vez. Adecuada para procesar audio pregrabado.
    • Llamada con streaming bidireccional: Reconoce flujos de audio directamente y genera resultados en tiempo real. El flujo de audio puede provenir de dispositivos externos (como un micrófono) o leerse desde un archivo local. Adecuada para escenarios que requieren retroalimentación inmediata.

    Llamada sin streaming

    Enviar una única tarea de conversión de voz a texto en tiempo real y obtener sincrónicamente el resultado de la transcripción pasando un archivo local.

    imagen

    Instancie la clase Recognition, llame al método call con los Parámetros de solicitud y el archivo a reconocer, realice el reconocimiento y obtenga el resultado del reconocimiento.

    Haga clic para ver el ejemplo completo

    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 bidireccional: basado en callbacks

    Enviar una única tarea de conversión de voz a texto en tiempo real y transmitir los resultados de reconocimiento en tiempo real a través de la interfaz de callback.

    imagen

    1. Iniciar reconocimiento de voz por transmisión

      Instancie la clase Recognition, llame al método call con los Parámetros de solicitud y la Interfaz de devolución de llamada (ResultCallback) para iniciar el reconocimiento de voz en streaming.

    2. Transmitir datos de audio

      Llame al método sendAudioFrame de la clase Recognition en un bucle para enviar segmentos de flujo de audio binario leídos desde un archivo local o dispositivo (como un micrófono) al servidor.

      Durante la transmisión de datos de audio, el servidor devuelve resultados de reconocimiento al cliente en tiempo real a través del método onEvent de la Interfaz de devolución de llamada (ResultCallback).

      Se recomienda que cada segmento de audio tenga una duración aproximada de 100 milisegundos, con un tamaño de datos entre 1 KB y 16 KB.

    3. Finalizar procesamiento

      Llame al método stop de la clase Recognition para finalizar el reconocimiento de voz.

      Este método bloquea el hilo actual hasta que se active la devolución de llamada onComplete o onError de la Interfaz de devolución de llamada (ResultCallback).

    Haga clic para ver el ejemplo completo

    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 bidireccional: basado en Flowable

    Enviar una única tarea de conversión de voz a texto en tiempo real y transmitir los resultados de reconocimiento en tiempo real a través de un flujo de trabajo Flowable.

    Flowable es un marco de código abierto para gestión de flujos de trabajo y procesos empresariales, publicado bajo la licencia Apache 2.0. Para más información sobre Flowable, consulte la Documentación de la API de Flowable.

    Haga clic para ver el ejemplo completo

    Llame directamente al método streamCall de la clase Recognition para iniciar el reconocimiento.

    El método streamCall devuelve una instancia Flowable<RecognitionResult>. Puede llamar a métodos como blockingForEach y subscribe de la instancia Flowable para procesar los resultados de reconocimiento. Los resultados de reconocimiento están encapsulados en RecognitionResult.

    El método streamCall requiere dos parámetros:

    • Instancia RecognitionParam (Parámetros de solicitud): Úsela para establecer parámetros como el modelo, la frecuencia de muestreo y el formato de audio para el reconocimiento de voz.
    • Instancia Flowable<ByteBuffer>: Debe crear una instancia de tipo Flowable<ByteBuffer> e implementar el método de análisis de flujo de audio dentro de ella.
    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);
    }
}

    Llamadas de alta concurrencia

    El SDK de Java de DashScope utiliza agrupación de conexiones OkHttp3 para reducir la sobrecarga de establecer conexiones repetidamente. Para más información, consulte Optimizar el reconocimiento de voz en tiempo real de Paraformer para alta concurrencia.

    Parámetros de solicitud

    Configure parámetros como el modelo, la frecuencia de muestreo y el formato de audio a través de los métodos encadenados de RecognitionParam. Pase el objeto de parámetros configurado al método call/streamCall de la clase Recognition.

    Haga clic para ver el ejemplo

    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();
    ParámetroTipoPredeterminadoObligatorioDescripción

    model

    String

    Sí

    El modelo para reconocimiento de voz en tiempo real. Para más información, consulte la Lista de modelos.

    sampleRate

    Integer

    Sí

    Establecer la tasa de muestreo (en Hz) del audio a reconocer.

    Varía según el modelo:

    • paraformer-realtime-v2 admite cualquier tasa de muestreo.
    • paraformer-realtime-8k-v2 solo admite una tasa de muestreo de 8000 Hz.

    format

    String

    Sí

    Establecer el formato de audio a reconocer.

    Formatos de audio admitidos: pcm, wav, mp3, opus, speex, aac, amr.

    Importanteopus/speex: Debe usar encapsulación Ogg.

    wav: Debe estar codificado en PCM.

    amr: Solo se admite el tipo AMR-NB.

    vocabularyId

    String

    No

    Establezca el ID de palabras clave. Si no se configura, las palabras clave no surtirán efecto. Utilice este campo para establecer el ID de palabras clave en los modelos v2 y posteriores.

    En la sesión actual de reconocimiento de voz, se aplicará la información de palabras clave correspondiente a este ID de palabras clave. Para un uso detallado, consulte Palabras clave personalizadas.

    disfluencyRemovalEnabled

    boolean

    false

    No

    Establecer si se deben filtrar las muletillas:

    • true: Filtrar muletillas
    • false (predeterminado): No filtrar muletillas

    language_hints

    String[]

    ["zh", "en"]

    No

    Establezca los códigos de idioma para el reconocimiento. Si no puede determinar el idioma con antelación, puede dejar esto sin configurar y el modelo detectará automáticamente el idioma.

    Códigos de idioma admitidos actualmente:

    • zh: Chino
    • en: Inglés
    • ja: Japonés
    • yue: Cantonés
    • ko: Coreano
    • de: Alemán
    • fr: Francés
    • ru: Ruso

    Este parámetro solo surte efecto para modelos que admiten múltiples idiomas (consulte la Lista de modelos).

    Notalanguage_hints debe establecerse a través del método parameter o del método parameters de la instancia de 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

    No

    Establecer si se debe habilitar la segmentación semántica. Deshabilitado por defecto.

    • true: Habilitar la segmentación semántica y deshabilitar la segmentación VAD (Detección de Actividad de Voz).
    • false (predeterminado): Habilitar la segmentación VAD (Detección de Actividad de Voz) y deshabilitar la segmentación semántica.

    La segmentación semántica proporciona mayor precisión y es adecuada para escenarios de transcripción de reuniones. La segmentación VAD (Detección de Actividad de Voz) tiene menor latencia y es adecuada para escenarios interactivos.

    Al ajustar el parámetro semantic_punctuation_enabled, puede cambiar flexiblemente el método de segmentación del reconocimiento de voz para adaptarse a diferentes escenarios.

    Este parámetro solo surte efecto cuando el modelo es v2 o posterior.

    Notasemantic_punctuation_enabled debe establecerse a través del método parameter o del método parameters de la instancia de 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

    No

    Establecer el umbral de duración de silencio (en ms) para la segmentación VAD (Detección de Actividad de Voz).

    Cuando la duración del silencio después de un segmento de habla supera este umbral, el sistema determina que la oración ha terminado.

    El rango del parámetro es de 200 ms a 6000 ms, con un valor predeterminado de 800 ms.

    Este parámetro solo surte efecto cuando el parámetro semantic_punctuation_enabled es false (segmentación VAD) y el modelo es v2 o posterior.

    Notamax_sentence_silence debe establecerse a través del método parameter o del método parameters de la instancia de 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

    No

    Cuando este interruptor está habilitado (true), evita que la segmentación VAD corte oraciones demasiado largas. Deshabilitado por defecto.

    Este parámetro solo surte efecto cuando el parámetro semantic_punctuation_enabled es false (segmentación VAD) y el modelo es v2 o posterior.

    Notamulti_threshold_mode_enabled debe establecerse a través del método parameter o del método parameters de la instancia de 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

    No

    Establecer si se debe agregar automáticamente puntuación en los resultados de reconocimiento:

    • true (predeterminado): Sí
    • false: No

    Este parámetro solo surte efecto cuando el modelo es v2 o posterior.

    Notapunctuation_prediction_enabled debe establecerse a través del método parameter o del método parameters de la instancia de 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

    No

    Cuando necesite mantener una conexión prolongada con el servidor, use este interruptor para controlar el comportamiento:

    • true: La conexión con el servidor puede mantenerse sin interrupción al enviar continuamente audio silencioso.

    • false (predeterminado): Incluso cuando se envía audio silencioso de forma continua, la conexión expira y se cierra después de un período de tiempo.

      El audio silencioso se refiere a archivos de audio o flujos de datos que no contienen señal de sonido. El audio silencioso se puede generar mediante varios métodos, como usar software de edición de audio como Audacity o Adobe Audition, o a través de herramientas de línea de comandos como FFmpeg.

    Este parámetro solo surte efecto cuando el modelo es v2 o posterior.

    NotaLa versión del SDK debe ser 2.19.1 o posterior para usar este campo.

    heartbeat debe establecerse a través del método parameter o del método parameters de la instancia de 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

    No

    Establecer si se debe habilitar ITN (Normalización Inversa de Texto).

    Habilitado por defecto (true). Cuando está habilitado, los numerales chinos se convierten a numerales arábigos.

    Este parámetro solo surte efecto cuando el modelo es v2 o posterior.

    Notainverse_text_normalization_enabled debe establecerse a través del método parameter o del método parameters de la instancia de 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

    No

    Clave API del usuario.

    Interfaces clave

    Clase Recognition

    Recognition se importa mediante "import com.alibaba.dashscope.audio.asr.recognition.Recognition;". Sus interfaces principales son las siguientes:

    Interfaz/MétodoParámetroValor de retornoDescripción
    public void call(RecognitionParam param, final ResultCallback<RecognitionResult> callback)

    None

    Reconocimiento en tiempo real por streaming basado en callbacks. Este método no bloquea el hilo actual.

    public String call(RecognitionParam param, File file)

    Resultado de reconocimiento

    Llamada sin streaming basada en un archivo local. Este método bloquea el hilo actual hasta que se ha leído todo el audio. El archivo a reconocer debe tener permisos de lectura.

    public Flowable<RecognitionResult> streamCall(RecognitionParam param, Flowable<ByteBuffer> audioFrame)

    Flowable<RecognitionResult>

    Reconocimiento en tiempo real por streaming basado en Flowable.

    public void sendAudioFrame(ByteBuffer audioFrame)
    • audioFrame: Flujo de audio binario de tipo ByteBuffer

    None

    Envíe datos de audio. Cada paquete de audio no debe ser ni demasiado grande ni demasiado pequeño. Se recomienda que cada paquete tenga una duración aproximada de 100 ms, con un tamaño entre 1 KB y 16 KB.

    Los resultados del reconocimiento se obtienen a través del método onEvent de la Interfaz de devolución de llamada (ResultCallback).

    public void stop()

    None

    None

    Detener el reconocimiento en tiempo real.

    Este método bloquea el hilo actual hasta que se llame al método onComplete o onError de la instancia de ResultCallback.

    recognizer.getDuplexApi().close(int code, String reason)

    code: Código de cierre de WebSocket

    reason: Motivo de cierre

    Estos dos parámetros se pueden configurar según la documentación de El protocolo WebSocket.

    true

    Después de que finalice la tarea, la conexión WebSocket debe cerrarse independientemente de si ocurrió una excepción, para evitar fugas de conexiones. Para obtener información sobre cómo reutilizar conexiones para mejorar la eficiencia, consulte Optimizar el reconocimiento de voz en tiempo real de Paraformer para alta concurrencia.

    public String getLastRequestId()

    None

    requestId

    Obtener el requestId de la tarea actual. Disponible después de iniciar una nueva tarea con call o streamingCall.

    NotaEste método está disponible a partir de la versión 2.18.0 del SDK.

    public long getFirstPackageDelay()

    None

    Retraso del primer paquete

    Obtenga el retraso del primer paquete, que es la latencia desde el envío del primer paquete de audio hasta la recepción del primer resultado de reconocimiento. Úselo después de que la tarea haya finalizado.

    NotaEste método está disponible a partir de la versión 2.18.0 del SDK.

    public long getLastPackageDelay()

    None

    Retraso del último paquete

    Obtenga el retraso del último paquete, que es la latencia desde el envío del comando stop hasta la recepción del último resultado de reconocimiento. Úselo después de que la tarea haya finalizado.

    NotaEste método está disponible a partir de la versión 2.18.0 del SDK.

    Interfaz de callback (ResultCallback)

    Durante las llamadas con streaming bidireccional, el servidor devuelve información clave del proceso y datos al cliente mediante devoluciones de llamada. Debe implementar los métodos de devolución de llamada para manejar la información o los datos devueltos por el servidor.

    Los métodos de devolución de llamada se implementan extendiendo la clase abstracta ResultCallback. Al extender esta clase abstracta, puede especificar el tipo genérico como RecognitionResult. RecognitionResult encapsula la estructura de datos devuelta por el servidor.

    Dado que Java admite la reutilización de conexiones, no hay callbacks onClose ni onOpen.

    Ejemplo

    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());
    }
};
    Interfaz/MétodoParámetroValor de retornoDescripción
    public void onEvent(RecognitionResult result)

    result: Resultado de reconocimiento en tiempo real (RecognitionResult)

    None

    Se llama cuando el servidor tiene una respuesta.

    public void onComplete()

    None

    None

    Se llama cuando la tarea se completa.

    public void onError(Exception e)

    e: Información de la excepción

    None

    Se llama cuando ocurre una excepción.

    Respuesta

    Resultado de reconocimiento en tiempo real (RecognitionResult)

    RecognitionResult representa el resultado de una sesión de reconocimiento en tiempo real.

    Interfaz/MétodoParámetroValor de retornoDescripción
    public String getRequestId()

    None

    requestId

    Obtener el requestId.

    public boolean isSentenceEnd()

    None

    Si es una oración completa, es decir, si se ha alcanzado un límite de oración

    Determinar si la oración dada ha terminado.

    public Sentence getSentence()

    None

    Información de la oración (Sentence)

    Obtener información de la oración, incluidas marcas de tiempo y texto.

    Información de la oración (Sentence)

    Interfaz/MétodoParámetroValor de retornoDescripción
    public Long getBeginTime()

    None

    Hora de inicio de la oración en ms

    Devuelve la hora de inicio de la oración.

    public Long getEndTime()

    None

    Hora de finalización de la oración en ms

    Devuelve la hora de finalización de la oración.

    public String getText()

    None

    Texto reconocido

    Devuelve el texto reconocido.

    public List<Word> getWords()

    None

    Lista de Información de marcas de tiempo de palabras (Word)

    Devuelve información de marcas de tiempo a nivel de palabra.

    public String getEmoTag()

    None

    Sentimiento de la oración actual

    Devuelve el sentimiento de la oración actual:

    • positive: Sentimiento positivo, como feliz o satisfecho
    • negative: Sentimiento negativo, como enfadado o triste
    • neutral: Sin sentimiento evidente

    El reconocimiento de sentimientos sigue estas restricciones:

    • Solo disponible para el modelo paraformer-realtime-8k-v2.
    • La segmentación semántica debe estar deshabilitada (controlada mediante Parámetros de solicitud semantic_punctuation_enabled). La segmentación semántica está deshabilitada por defecto.
    • Los resultados del reconocimiento de sentimiento solo se muestran cuando el método isSentenceEnd del Resultado de reconocimiento en tiempo real (RecognitionResult) devuelve true.
    public Double getEmoConfidence()

    None

    Confianza del sentimiento de la oración actual

    Devuelve la confianza del sentimiento de la oración actual. Rango de valores: [0.0, 1.0]. Un valor más alto indica mayor confianza.

    El reconocimiento de sentimientos sigue estas restricciones:

    • Solo disponible para el modelo paraformer-realtime-8k-v2.
    • La segmentación semántica debe estar deshabilitada (controlada mediante Parámetros de solicitud semantic_punctuation_enabled). La segmentación semántica está deshabilitada por defecto.
    • Los resultados del reconocimiento de sentimiento solo se muestran cuando el método isSentenceEnd del Resultado de reconocimiento en tiempo real (RecognitionResult) devuelve true.

    Información de marcas de tiempo de palabras (Word)

    Interfaz/MétodoParámetroValor de retornoDescripción
    public long getBeginTime()

    None

    Hora de inicio de la palabra en ms

    Devuelve la hora de inicio de la palabra.

    public long getEndTime()

    None

    Hora de fin de la palabra en ms

    Devuelve la hora de finalización de la palabra.

    public String getText()

    None

    Palabra

    Devuelve la palabra reconocida.

    public String getPunctuation()

    None

    Puntuación

    Devuelve la puntuación.

    Códigos de error

    Si encuentra errores, consulte Códigos de error para solucionar problemas.

    Si el problema persiste, únase a la comunidad de desarrolladores para reportar su incidencia y proporcione el ID de solicitud para una investigación más detallada.

    Más ejemplos

    Para más ejemplos, consulte GitHub.

    FAQ

    Preguntas sobre funciones

    P: ¿Cómo mantener una conexión prolongada con el servidor durante un silencio prolongado?

    Establezca el parámetro de solicitud heartbeat en true y envíe continuamente audio silencioso al servidor.

    El audio silencioso se refiere a archivos de audio o flujos de datos que no contienen señal de sonido. El audio silencioso se puede generar mediante varios métodos, como usar software de edición de audio como Audacity o Adobe Audition, o a través de herramientas de línea de comandos como FFmpeg.

    P: ¿Cómo convertir audio a un formato compatible?

    Puede usar la herramienta FFmpeg. Para más usos, consulte el sitio web oficial 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

    P: ¿Admite ver el rango de tiempo para cada oración?

    Sí. Los resultados del reconocimiento de voz incluyen las marcas de tiempo de inicio y fin para cada oración, las cuales se pueden utilizar para determinar el rango de tiempo de cada oración.

    P: ¿Cómo reconocer un archivo local (audio grabado)?

    Hay dos formas de reconocer archivos locales:

    • Pasar directamente la ruta del archivo local: Este método obtiene el resultado completo del reconocimiento solo después de que todo el reconocimiento ha finalizado, y no es adecuado para escenarios que requieren retroalimentación inmediata.

      Consulte Llamada sin streaming. Pase la ruta del archivo al método call de la clase Recognition para reconocer directamente el archivo grabado.

    • Convertir el archivo local a un flujo binario para el reconocimiento: Este método reconoce el archivo mientras transmite en streaming los resultados de reconocimiento, adecuado para escenarios que requieren retroalimentación inmediata.

    Solución de problemas

    P: ¿Qué causa el fallo al reconocer el habla (sin resultados de reconocimiento)?

    1. Verifique si el formato de audio (format) y la frecuencia de muestreo (sampleRate/sample_rate) en los parámetros de solicitud están configurados correctamente y cumplen con las restricciones de parámetros. Los siguientes son ejemplos comunes de errores:

      • La extensión del archivo de audio es .wav, pero el formato real es MP3, y el parámetro de solicitud format está configurado como mp3 (configuración de parámetros incorrecta).
      • La frecuencia de muestreo del audio es de 3600 Hz, pero el parámetro de solicitud sampleRate/sample_rate está configurado en 48000 (configuración de parámetro incorrecta).

      Puede utilizar la herramienta ffprobe para obtener información sobre el contenedor, códec, frecuencia de muestreo, canales y otros detalles del audio:

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

    1. Al utilizar el modelo paraformer-realtime-v2, verifique si el idioma configurado en language_hints coincide con el idioma real del audio.

      Por ejemplo: El audio está realmente en chino, pero language_hints está configurado como en (inglés).

    2. Si todas las comprobaciones anteriores son correctas, puede usar palabras clave personalizadas para mejorar la precisión del reconocimiento de palabras específicas.