定制热词

import dashscope
from dashscope.audio.asr import *

# 若没有将API Key配置到环境变量中，需将your-api-key替换为自己的API Key
# dashscope.api_key = "your-api-key"

prefix = 'prefix'
target_model = "gummy-realtime-v1"

my_vocabulary = [
    {"text": "阿里巴巴语音实验室", "lang": "zh", "target_lang": "en", "translation": "Alibaba Speech Lab"}
]

# 创建热词
service = VocabularyService()
vocabulary_id = service.create_vocabulary(
    prefix=prefix,
    target_model=target_model,
    vocabulary=my_vocabulary)

print(f"热词表ID为：{vocabulary_id}")

# 使用热词进行语音识别
translator = TranslationRecognizerRealtime(
    model=target_model,  # 设置模型
    format="wav",  # 设置音频格式
    sample_rate=16000,  # 设置采样率
    translation_target_languages=["en"],  # 设置翻译目标语言
    translation_enabled=True,  # 启用翻译
    vocabulary_id=vocabulary_id,  # 传入热词表ID
    callback=None,
)
result = translator.call("asr_example.wav")
if not result.error_message:
    print("Request ID：", result.request_id)
    print("识别结果：")
    for transcription_result in result.transcription_result_list:
        print(transcription_result.text)

    print("翻译结果：")
    for translation_result in result.translation_result_list:
        print(translation_result.get_translation('en').text)
else:
    print("出现异常：", result.error_message)

import com.alibaba.dashscope.audio.asr.translation.TranslationRecognizerParam;
import com.alibaba.dashscope.audio.asr.translation.TranslationRecognizerRealtime;
import com.alibaba.dashscope.audio.asr.translation.results.TranscriptionResult;
import com.alibaba.dashscope.audio.asr.translation.results.TranslationRecognizerResultPack;
import com.alibaba.dashscope.audio.asr.translation.results.TranslationResult;
import com.alibaba.dashscope.audio.asr.vocabulary.Vocabulary;
import com.alibaba.dashscope.audio.asr.vocabulary.VocabularyService;
import com.alibaba.dashscope.exception.InputRequiredException;
import com.alibaba.dashscope.exception.NoApiKeyException;
import com.google.gson.JsonArray;
import com.google.gson.JsonObject;

import java.io.File;
import java.util.ArrayList;
import java.util.List;

public class Main {
    public static String apiKey = System.getenv("DASHSCOPE_API_KEY"); // 若没有将API Key配置到环境变量中，需将apiKey替换为自己的API Key

    public static void main(String[] args) throws NoApiKeyException, InputRequiredException {
        String targetModel = "gummy-realtime-v1";
        // 定义热词类
        class HotWord {
            String text;
            String lang;
            String targetLang;
            String translation;

            public HotWord(String text, String lang, String targetLang, String translation) {
                this.text = text;
                this.lang = lang;
                this.targetLang = targetLang;
                this.translation = translation;
            }
        }
        JsonArray vocabulary = new JsonArray();
        List<HotWord> wordList = new ArrayList<>();
        wordList.add(new HotWord("阿里巴巴语音实验室", "zh", "en", "Alibaba Speech Lab"));

        for (HotWord word : wordList) {
            JsonObject jsonObject = new JsonObject();
            jsonObject.addProperty("text", word.text);
            jsonObject.addProperty("lang", word.lang);
            jsonObject.addProperty("target_lang", word.targetLang);
            jsonObject.addProperty("translation", word.translation);
            vocabulary.add(jsonObject);
        }

        // 创建热词
        VocabularyService service = new VocabularyService(apiKey);
        Vocabulary myVoc = service.createVocabulary(targetModel, "prefix", vocabulary);
        System.out.println("热词表ID：" + myVoc.getVocabularyId());

        // 使用热词进行语音识别
        String targetLanguage = "en";
        // 创建TranslationRecognizerRealtime实例
        TranslationRecognizerRealtime translator = new TranslationRecognizerRealtime();
        // 设置请求参数
        TranslationRecognizerParam param =
                TranslationRecognizerParam.builder()
                        .apiKey(apiKey)
                        .model("gummy-realtime-v1") // 设置模型
                        .format("wav") // 设置音频格式
                        .sampleRate(16000) // 设置采样率
                        .transcriptionEnabled(true) // 启用语音识别
                        .translationEnabled(true) // 启用翻译
                        .translationLanguages(new String[] {targetLanguage}) // 设置翻译目标语言
                        .vocabularyId(myVoc.getVocabularyId()) // 设置热词表ID
                        .build();
        // 解析识别/翻译结果
        TranslationRecognizerResultPack result = translator.call(param, new File("asr_example.wav"));
        if (result.getError() != null) {
            System.out.println("error: " + result.getError());
            throw new RuntimeException(result.getError());
        } else {
            System.out.println("RequestId：" + result.getRequestId());
            System.out.println("识别结果：");
            ArrayList<TranscriptionResult> transcriptionResults = result.getTranscriptionResultList();
            for (int i = 0; i < transcriptionResults.size(); i++) {
                System.out.println(transcriptionResults.get(i).getText());
            }

            System.out.println("翻译结果：");
            ArrayList<TranslationResult> translationResultList = result.getTranslationResultList();
            for (int i = 0; i < translationResultList.size(); i++) {
                System.out.println(translationResultList.get(i).getTranslation(targetLanguage).getText());
            }
        }
        System.exit(0);
    }
}