Konuşmayı tanıma ve çevirme

Metne konuşma REST API başvurusu | Kısa ses başvurusu için metin REST API'sine konuşma | GitHub'da ek örnekler

Availability

Konuşma çevirisi için REST API'yi kullanabilirsiniz, ancak buraya henüz bir kılavuz eklemedik. Başlamak ve kavramlar hakkında bilgi edinmek için lütfen başka bir programlama dili seçin.

Başvuru belgeleri | Paketi (PyPi) | GitHub'da ek örnekler

Bu nasıl yapılır kılavuzunda insan konuşmasını tanımayı ve başka bir dile çevirmeyi öğreneceksiniz.

Aşağıdakiler hakkında daha fazla bilgi için konuşma çevirisine genel bakış bölümüne bakın:

Konuşmayı metne çevirme
Konuşmayı birden çok hedef dile çevirme
Doğrudan konuşmadan konuşmaya çeviri gerçekleştirme

Hassas veriler ve ortam değişkenleri

Bu makaledeki örnek kaynak kodu, Konuşma kaynağının abonelik anahtarı ve bölgesi gibi hassas verileri depolamaya yönelik ortam değişkenlerine bağlıdır. Python kod dosyası, konak makinenin ortam değişkenlerinden atanan iki değer içerir: SPEECH__SUBSCRIPTION__KEY ve SPEECH__SERVICE__REGION. Bu değişkenlerin her ikisi de genel kapsamda olduğundan kod dosyasının işlev tanımından erişilebilir:

speech_key, service_region = os.environ['SPEECH__SUBSCRIPTION__KEY'], os.environ['SPEECH__SERVICE__REGION']

Ortam değişkenleri hakkında daha fazla bilgi için bkz . Ortam değişkenleri ve uygulama yapılandırması.

Önemli

API anahtarlarını dikkatli kullanın. API anahtarını doğrudan kodunuzla eklemeyin ve hiçbir zaman herkese açık olarak göndermeyin. API anahtarı kullanıyorsanız, bunu Azure Key Vault'ta güvenli bir şekilde depolayın. Uygulamalarınızda API anahtarlarını güvenli bir şekilde kullanma hakkında daha fazla bilgi için bkz . Azure Key Vault ile API anahtarları.

Yapay zeka hizmetleri güvenliği hakkında daha fazla bilgi için bkz . Azure AI hizmetlerine yönelik isteklerin kimliğini doğrulama.

Konuşma çevirisi yapılandırması oluşturma

Konuşma SDK'sını kullanarak Konuşma hizmetini çağırmak için bir SpeechTranslationConfig örnek oluşturmanız gerekir. Bu sınıf anahtarınız ve ilişkili bölgeniz, uç noktanız, konağınız veya yetkilendirme belirteciniz gibi Konuşma kaynağınızla ilgili bilgileri içerir.

İpucu

Konuşma tanıma, konuşma sentezi, çeviri veya amaç tanıma gerçekleştirmenize bakılmaksızın, her zaman bir yapılandırma oluşturursunuz.

SpeechTranslationConfig başlatmanın birkaç yolu vardır:

Abonelikle: anahtarı ve ilişkili bölgeyi geçirin.
Bir uç nokta belirleyerek: Konuşma hizmeti uç noktasını girin. Anahtar veya yetkilendirme belirteci isteğe bağlıdır.
Sunucu ile: bir sunucu adresi giriniz. Anahtar veya yetkilendirme belirteci isteğe bağlıdır.
Yetkilendirme belirteci ile: Yetkilendirme belirtecini ve ilişkili bölgeyi iletin.

Anahtar ve bölge kullanarak nasıl bir SpeechTranslationConfig örneği oluşturabileceğinize bakalım. Azure portalında Konuşma kaynak anahtarını ve bölgesini alın.

from_language, to_language = 'en-US', 'de'

def translate_speech_to_text():
    translation_config = speechsdk.translation.SpeechTranslationConfig(
            subscription=speech_key, region=service_region)

Kaynak dili değiştirme

Konuşma çevirisinin yaygın görevlerinden biri giriş (veya kaynak) dilini belirtmektir. Aşağıdaki örnekte giriş dilini İtalyanca olarak nasıl değiştirdiğiniz gösterilmektedir. Kodunuzda, SpeechTranslationConfig'ı speech_recognition_language özelliğine atayarak örnekle etkileşim kurun.

def translate_speech_to_text():
    translation_config = speechsdk.translation.SpeechTranslationConfig(
            subscription=speech_key, region=service_region)

    # Source (input) language
    from_language = "it-IT"
    translation_config.speech_recognition_language = from_language

speech_recognition_language özelliği bir dil-yerel ayar biçim dizesi bekler. Desteklenen konuşma çevirisi yerel ayarlarının listesine bakın.

Çeviri dili ekleme

Konuşma çevirisinin bir diğer yaygın görevi de hedef çeviri dillerini belirtmektir. En az bir tane gereklidir, ancak birden fazla desteklenmektedir. Aşağıdaki kod parçacığı hem Fransızca hem de Almancayı çeviri dili hedefleri olarak ayarlar:

def translate_speech_to_text():
    translation_config = speechsdk.translation.SpeechTranslationConfig(
            subscription=speech_key, region=service_region)

    translation_config.speech_recognition_language = "it-IT"

    # Translate to languages. See, https://aka.ms/speech/sttt-languages
    translation_config.add_target_language("fr")
    translation_config.add_target_language("de")

için yapılan her çağrıda add_target_languageyeni bir hedef çeviri dili belirtilir. Başka bir deyişle, konuşma kaynak dilden tanındığında, sonuçta elde edilen çeviri işleminin bir parçası olarak her hedef çeviri kullanılabilir.

Çeviri tanıyıcıyı başlatma

Bir SpeechTranslationConfig örneği oluşturduktan sonra, sonraki adım TranslationRecognizer'i başlatmaktır. TranslationRecognizer başlattığınızda, translation_config örneğinizi geçirmeniz gerekir. Yapılandırma nesnesi, Konuşma hizmetinin isteğinizi doğrulamak için gerektirdiği kimlik bilgilerini sağlar.

Eğer konuşmayı cihazınızın varsayılan mikrofonunu kullanarak TranslationRecognizer tanıyorsanız, aşağıdaki gibi görünmelidir:

def translate_speech_to_text():
    translation_config = speechsdk.translation.SpeechTranslationConfig(
            subscription=speech_key, region=service_region)

    translation_config.speech_recognition_language = from_language
    translation_config.add_target_language(to_language)

    translation_recognizer = speechsdk.translation.TranslationRecognizer(
            translation_config=translation_config)

Ses giriş cihazını belirtmek istiyorsanız, bir AudioConfig sınıf örneği oluşturmanız ve başlatılırken audio_config parametresini TranslationRecognizer sağlamanız gerekir.

İpucu

Ses giriş cihazınızın cihaz kimliğini nasıl alacağınızı öğrenin.

İlk olarak, AudioConfig nesnesine aşağıdaki şekilde başvurun:

def translate_speech_to_text():
    translation_config = speechsdk.translation.SpeechTranslationConfig(
            subscription=speech_key, region=service_region)

    translation_config.speech_recognition_language = from_language
    for lang in to_languages:
        translation_config.add_target_language(lang)

    audio_config = speechsdk.audio.AudioConfig(use_default_microphone=True)
    translation_recognizer = speechsdk.translation.TranslationRecognizer(
            translation_config=translation_config, audio_config=audio_config)

Mikrofon kullanmak yerine ses dosyası sağlamak istiyorsanız yine de bir audioConfig parametre sağlamanız gerekir. Ancak, bir AudioConfig sınıf örneği oluşturduğunuzda use_default_microphone=True yerine filename="path-to-file.wav" ile çağırır ve filename parametresini sağlarsınız.

def translate_speech_to_text():
    translation_config = speechsdk.translation.SpeechTranslationConfig(
            subscription=speech_key, region=service_region)

    translation_config.speech_recognition_language = from_language
    for lang in to_languages:
        translation_config.add_target_language(lang)

    audio_config = speechsdk.audio.AudioConfig(filename="path-to-file.wav")
    translation_recognizer = speechsdk.translation.TranslationRecognizer(
            translation_config=translation_config, audio_config=audio_config)

Konuşmayı çevirme

Konuşma SDK’sının konuşmayı çevirmek için bir mikrofona veya ses dosyası girişine ihtiyacı vardır. Konuşma tanıma, konuşma çevirisinden önce gerçekleşir. Tüm nesneler başlatıldıktan sonra recognize-once işlevini çağırın ve sonucu alın:

import os
import azure.cognitiveservices.speech as speechsdk

speech_key, service_region = os.environ['SPEECH__SERVICE__KEY'], os.environ['SPEECH__SERVICE__REGION']
from_language, to_languages = 'en-US', 'de'

def translate_speech_to_text():
    translation_config = speechsdk.translation.SpeechTranslationConfig(
            subscription=speech_key, region=service_region)

    translation_config.speech_recognition_language = from_language
    translation_config.add_target_language(to_language)

    translation_recognizer = speechsdk.translation.TranslationRecognizer(
            translation_config=translation_config)
    
    print('Say something...')
    translation_recognition_result = translation_recognizer.recognize_once()
    print(get_result_text(reason=translation_recognition_result.reason, result=translation_recognition_result))

def get_result_text(reason, translation_recognition_result):
    reason_format = {
        speechsdk.ResultReason.TranslatedSpeech:
            f'RECOGNIZED "{from_language}": {translation_recognition_result.text}\n' +
            f'TRANSLATED into "{to_language}"": {translation_recognition_result.translations[to_language]}',
        speechsdk.ResultReason.RecognizedSpeech: f'Recognized: "{translation_recognition_result.text}"',
        speechsdk.ResultReason.NoMatch: f'No speech could be recognized: {translation_recognition_result.no_match_details}',
        speechsdk.ResultReason.Canceled: f'Speech Recognition canceled: {translation_recognition_result.cancellation_details}'
    }
    return reason_format.get(reason, 'Unable to recognize speech')

translate_speech_to_text()

Konuşmayı metne dönüştürme hakkında daha fazla bilgi için bkz . Konuşma tanımanın temelleri.

Olay tabanlı çeviri

TranslationRecognizer nesnesi bir recognizing olayı açığa çıkarır. Olay birkaç kez tetiklenir ve ara çeviri sonuçlarını almak için bir mekanizma sunar.

Not

Çok dilli konuşma çevirisi kullandığınızda ara çeviri sonuçları kullanılamaz.

Aşağıdaki örnek ara çeviri sonuçlarını konsola yazdırır:

import os
import azure.cognitiveservices.speech as speechsdk

speech_key, service_region = os.environ['SPEECH__SERVICE__KEY'], os.environ['SPEECH__SERVICE__REGION']
from_language, to_language = 'en-US', 'de'

def translate_speech_continuous():
    translation_config = speechsdk.translation.SpeechTranslationConfig(
        subscription=speech_key, region=service_region)
    
    translation_config.speech_recognition_language = from_language
    translation_config.add_target_language(to_language)
    
    audio_config = speechsdk.audio.AudioConfig(filename="whatstheweatherlike.wav")
    translation_recognizer = speechsdk.translation.TranslationRecognizer(
        translation_config=translation_config, audio_config=audio_config)
    
    done = False
    
    def recognizing_cb(evt):
        print(f'RECOGNIZING in "{from_language}": Text={evt.result.text}')
        for language, translation in evt.result.translations.items():
            print(f'    TRANSLATING into "{language}": {translation}')
    
    def recognized_cb(evt):
        if evt.result.reason == speechsdk.ResultReason.TranslatedSpeech:
            print(f'RECOGNIZED in "{from_language}": Text={evt.result.text}')
            for language, translation in evt.result.translations.items():
                print(f'    TRANSLATED into "{language}": {translation}')
        elif evt.result.reason == speechsdk.ResultReason.RecognizedSpeech:
            print(f'RECOGNIZED: Text={evt.result.text}')
            print('    Speech not translated.')
        elif evt.result.reason == speechsdk.ResultReason.NoMatch:
            print('NOMATCH: Speech could not be recognized.')
    
    def canceled_cb(evt):
        print(f'CANCELED: Reason={evt.cancellation_details.reason}')
        if evt.cancellation_details.reason == speechsdk.CancellationReason.Error:
            print(f'CANCELED: ErrorDetails={evt.cancellation_details.error_details}')
        nonlocal done
        done = True
    
    def session_stopped_cb(evt):
        print('SESSION STOPPED')
        nonlocal done
        done = True
    
    # Connect callbacks
    translation_recognizer.recognizing.connect(recognizing_cb)
    translation_recognizer.recognized.connect(recognized_cb)
    translation_recognizer.canceled.connect(canceled_cb)
    translation_recognizer.session_stopped.connect(session_stopped_cb)
    
    # Start continuous recognition
    print('Start translation...')
    translation_recognizer.start_continuous_recognition()
    
    # Wait for completion
    while not done:
        pass
    
    # Stop recognition
    translation_recognizer.stop_continuous_recognition()

translate_speech_continuous()

Çevirileri sentezle

Başarılı bir konuşma tanıma ve konuşma çevirisinin ardından, sonuç bir sözlükteki tüm çevirileri içerir. translations Sözlük anahtarı hedef çeviri dili, değer ise çevrilmiş metindir. Tanınan konuşma çevrilebilir ve daha sonra farklı bir dilde (konuşmadan konuşmaya) sentezlenebilir.

Olay tabanlı sentez

TranslationRecognizer nesnesi bir Synthesizing olayı açığa çıkarır. Olay birkaç kez gerçekleşir ve çeviri tanıma sonucundan sentezlenmiş sesi almak için bir yöntem sunar. Birden çok dile çeviri yapıyorsanız, bkz. El ile sentezleme.

Bir voice_name örnek atayarak sentez sesini belirtin ve ses dosyasını almak için Synthesizing olayını işlemek için bir olay işleyicisi sağlayın. Aşağıdaki örnek çevrilmiş sesi .wav dosyası olarak kaydeder.

Önemli

Olay tabanlı sentez yalnızca tek bir çeviriyle çalışır. Birden çok hedef çeviri dili eklemeyin. Ayrıca, değerin voice_name hedef çeviri diliyle aynı dil olması gerekir. Örneğin, "de", "de-DE-Hedda" ile eşlenebilir.

import os
import azure.cognitiveservices.speech as speechsdk

speech_key, service_region = os.environ['SPEECH__SERVICE__KEY'], os.environ['SPEECH__SERVICE__REGION']
from_language, to_language = 'en-US', 'de'

def translate_speech_to_text():
    translation_config = speechsdk.translation.SpeechTranslationConfig(
            subscription=speech_key, region=service_region)

    translation_config.speech_recognition_language = from_language
    translation_config.add_target_language(to_language)

    # See: https://aka.ms/speech/sdkregion#standard-and-neural-voices
    translation_config.voice_name = "de-DE-Hedda"

    translation_recognizer = speechsdk.translation.TranslationRecognizer(
            translation_config=translation_config)

    def synthesis_callback(evt):
        size = len(evt.result.audio)
        print(f'Audio synthesized: {size} byte(s) {"(COMPLETED)" if size == 0 else ""}')

        if size > 0:
            file = open('translation.wav', 'wb+')
            file.write(evt.result.audio)
            file.close()

    translation_recognizer.synthesizing.connect(synthesis_callback)

    print(f'Say something in "{from_language}" and we\'ll translate into "{to_language}".')

    translation_recognition_result = translation_recognizer.recognize_once()
    print(get_result_text(reason=translation_recognition_result.reason, result=translation_recognition_result))

def get_result_text(reason, translation_recognition_result):
    reason_format = {
        speechsdk.ResultReason.TranslatedSpeech:
            f'Recognized "{from_language}": {translation_recognition_result.text}\n' +
            f'Translated into "{to_language}"": {translation_recognition_result.translations[to_language]}',
        speechsdk.ResultReason.RecognizedSpeech: f'Recognized: "{translation_recognition_result.text}"',
        speechsdk.ResultReason.NoMatch: f'No speech could be recognized: {translation_recognition_result.no_match_details}',
        speechsdk.ResultReason.Canceled: f'Speech Recognition canceled: {translation_recognition_result.cancellation_details}'
    }
    return reason_format.get(reason, 'Unable to recognize speech')

translate_speech_to_text()

El ile sentez

Çeviri metninden translations ses sentezlemek için sözlüğü kullanabilirsiniz. Her çeviriyi yineleyip sentezler. Bir SpeechSynthesizer örneği oluştururken, SpeechConfig özelliği istenen sese ayarlanmış speech_synthesis_voice_name nesnesine ihtiyaç vardır.

Aşağıdaki örnek beş dile çevrilir. Her çeviri daha sonra ilgili sinir dilinde bir ses dosyasına sentezlenmiş olur.

import os
import azure.cognitiveservices.speech as speechsdk

speech_key, service_region = os.environ['SPEECH__SERVICE__KEY'], os.environ['SPEECH__SERVICE__REGION']
from_language, to_languages = 'en-US', [ 'de', 'en', 'it', 'pt', 'zh-Hans' ]

def translate_speech_to_text():
    translation_config = speechsdk.translation.SpeechTranslationConfig(
            subscription=speech_key, region=service_region)

    translation_config.speech_recognition_language = from_language
    for lang in to_languages:
        translation_config.add_target_language(lang)

    recognizer = speechsdk.translation.TranslationRecognizer(
            translation_config=translation_config)
    
    print('Say something...')
    translation_recognition_result = translation_recognizer.recognize_once()
    synthesize_translations(result=translation_recognition_result)

def synthesize_translations(translation_recognition_result):
    language_to_voice_map = {
        "de": "de-DE-KatjaNeural",
        "en": "en-US-AriaNeural",
        "it": "it-IT-ElsaNeural",
        "pt": "pt-BR-FranciscaNeural",
        "zh-Hans": "zh-CN-XiaoxiaoNeural"
    }
    print(f'Recognized: "{translation_recognition_result.text}"')

    for language in translation_recognition_result.translations:
        translation = translation_recognition_result.translations[language]
        print(f'Translated into "{language}": {translation}')

        speech_config = speechsdk.SpeechConfig(subscription=speech_key, region=service_region)
        speech_config.speech_synthesis_voice_name = language_to_voice_map.get(language)
        
        audio_config = speechsdk.audio.AudioOutputConfig(filename=f'{language}-translation.wav')
        speech_synthesizer = speechsdk.SpeechSynthesizer(speech_config=speech_config, audio_config=audio_config)
        speech_synthesizer.speak_text_async(translation).get()

translate_speech_to_text()

Konuşma sentezi hakkında daha fazla bilgi için bkz . Konuşma sentezinin temelleri.

Dil belirleme ile çok dilli çeviri

Birçok senaryoda, hangi giriş dillerini belirtebileceğinizi bilmiyor olabilirsiniz. Dil belirlemeyi kullanarak en fazla 10 olası giriş dili algılayabilir ve otomatik olarak hedef dillerinize çevirebilirsiniz.

Eksiksiz bir kod örneği için bkz . dil belirleme.

Başvuru belgeleri | Paketi (NuGet) | GitHub'da ek örnekler

Bu nasıl yapılır kılavuzunda insan konuşmasını tanımayı ve başka bir dile çevirmeyi öğreneceksiniz.

Aşağıdakiler hakkında daha fazla bilgi için konuşma çevirisine genel bakış bölümüne bakın:

Konuşmayı metne çevirme
Konuşmayı birden çok hedef dile çevirme
Doğrudan konuşmadan konuşmaya çeviri gerçekleştirme

Hassas veriler ve ortam değişkenleri

Bu makaledeki örnek kaynak kodu, Konuşma kaynağının anahtarı ve bölgesi gibi hassas verileri depolamak için ortam değişkenlerine bağlıdır. C# kod dosyası, konak makinenin ortam değişkenlerinden atanan iki static readonly string değer içerir: SPEECH__SUBSCRIPTION__KEY ve SPEECH__SERVICE__REGION. Bu alanların her ikisi de sınıf kapsamında olduğundan, sınıfın yöntem gövdeleri içinde erişilebilir:

public class Program
{
    static readonly string SPEECH__SUBSCRIPTION__KEY =
        Environment.GetEnvironmentVariable(nameof(SPEECH__SUBSCRIPTION__KEY));
    
    static readonly string SPEECH__SERVICE__REGION =
        Environment.GetEnvironmentVariable(nameof(SPEECH__SERVICE__REGION));

    public static void Main(string[] args) { }
}

Ortam değişkenleri hakkında daha fazla bilgi için bkz . Ortam değişkenleri ve uygulama yapılandırması.

Önemli

Yapay zeka hizmetleri güvenliği hakkında daha fazla bilgi için bkz . Azure AI hizmetlerine yönelik isteklerin kimliğini doğrulama.

Konuşma çevirisi yapılandırması oluşturma

İpucu

Konuşma tanıma, konuşma sentezi, çeviri veya amaç tanıma gerçekleştirmenize bakılmaksızın, her zaman bir yapılandırma oluşturursunuz.

Bir SpeechTranslationConfig örneğini birkaç şekilde başlatabilirsiniz.

Abonelikle: anahtarı ve ilişkili bölgeyi geçirin.
Bir uç nokta belirleyerek: Konuşma hizmeti uç noktasını girin. Anahtar veya yetkilendirme belirteci isteğe bağlıdır.
Sunucu ile: bir sunucu adresi giriniz. Anahtar veya yetkilendirme belirteci isteğe bağlıdır.
Yetkilendirme belirteci ile: Yetkilendirme belirtecini ve ilişkili bölgeyi iletin.

Şimdi bir anahtar ve bölge kullanarak bir SpeechTranslationConfig örneği nasıl oluşturduğunuza bakalım. Azure portalında Konuşma kaynak anahtarını ve bölgesini alın.

public class Program
{
    static readonly string SPEECH__SUBSCRIPTION__KEY =
        Environment.GetEnvironmentVariable(nameof(SPEECH__SUBSCRIPTION__KEY));
    
    static readonly string SPEECH__SERVICE__REGION =
        Environment.GetEnvironmentVariable(nameof(SPEECH__SERVICE__REGION));

    public static void Main(string[] args)
    {
        try
        {
            TranslateSpeechAsync().Wait();
        }
        catch (Exception ex)
        {
            Console.WriteLine(ex);
        }
    }

    static async Task TranslateSpeechAsync()
    {
        var speechTranslationConfig =
            SpeechTranslationConfig.FromSubscription(SPEECH__SUBSCRIPTION__KEY, SPEECH__SERVICE__REGION);
    }
}

Kaynak dili değiştirme

Konuşma çevirisinin yaygın görevlerinden biri giriş (veya kaynak) dilini belirtmektir. Aşağıdaki örnekte giriş dilini İtalyanca olarak nasıl değiştirdiğiniz gösterilmektedir. Kodunuzda, SpeechTranslationConfig özelliğine SpeechRecognitionLanguage örneğini atayarak etkileşim kurun.

static async Task TranslateSpeechAsync()
{
    var speechTranslationConfig =
        SpeechTranslationConfig.FromSubscription(SPEECH__SUBSCRIPTION__KEY, SPEECH__SERVICE__REGION);

    // Source (input) language
    speechTranslationConfig.SpeechRecognitionLanguage = "it-IT";
}

SpeechRecognitionLanguage özelliği bir dil-yerel ayar biçim dizesi bekler. Desteklenen konuşma çevirisi yerel ayarlarının listesine bakın.

Çeviri dili ekleme

static async Task TranslateSpeechAsync()
{
    var speechTranslationConfig =
        SpeechTranslationConfig.FromSubscription(SPEECH__SUBSCRIPTION__KEY, SPEECH__SERVICE__REGION);

    speechTranslationConfig.SpeechRecognitionLanguage = "it-IT";
    
    speechTranslationConfig.AddTargetLanguage("fr");
    speechTranslationConfig.AddTargetLanguage("de");
}

için yapılan her çağrıda AddTargetLanguageyeni bir hedef çeviri dili belirtilir. Başka bir deyişle, konuşma kaynak dilden tanındığında, sonuçta elde edilen çeviri işleminin bir parçası olarak her hedef çeviri kullanılabilir.

Çeviri tanıyıcıyı başlatma

Bir SpeechTranslationConfig örneği oluşturduktan sonra, sonraki adım TranslationRecognizer'i başlatmaktır. TranslationRecognizer başlattığınızda, speechTranslationConfig örneğinizi geçirmeniz gerekir. Yapılandırma nesnesi, Konuşma hizmetinin isteğinizi doğrulamak için gerektirdiği kimlik bilgilerini sağlar.

Konuşmaları cihazınızın varsayılan mikrofonunu kullanarak tanıyorsanız örneğin TranslationRecognizer şu şekilde görünmesi gerekir:

static async Task TranslateSpeechAsync()
{
    var speechTranslationConfig =
        SpeechTranslationConfig.FromSubscription(SPEECH__SUBSCRIPTION__KEY, SPEECH__SERVICE__REGION);

    var fromLanguage = "en-US";
    var toLanguages = new List<string> { "it", "fr", "de" };
    speechTranslationConfig.SpeechRecognitionLanguage = fromLanguage;
    toLanguages.ForEach(speechTranslationConfig.AddTargetLanguage);

    using var translationRecognizer = new TranslationRecognizer(speechTranslationConfig);
}

Ses giriş cihazını belirtmek istiyorsanız, bir AudioConfig sınıf örneği oluşturmanız ve başlatılırken audioConfig parametresini TranslationRecognizer sağlamanız gerekir.

İpucu

Ses giriş cihazınızın cihaz kimliğini nasıl alacağınızı öğrenin.

İlk olarak, AudioConfig nesnesine aşağıdaki şekilde başvurun:

static async Task TranslateSpeechAsync()
{
    var speechTranslationConfig =
        SpeechTranslationConfig.FromSubscription(SPEECH__SUBSCRIPTION__KEY, SPEECH__SERVICE__REGION);
    
    var fromLanguage = "en-US";
    var toLanguages = new List<string> { "it", "fr", "de" };
    speechTranslationConfig.SpeechRecognitionLanguage = fromLanguage;
    toLanguages.ForEach(speechTranslationConfig.AddTargetLanguage);

    using var audioConfig = AudioConfig.FromDefaultMicrophoneInput();
    using var translationRecognizer = new TranslationRecognizer(speechTranslationConfig, audioConfig);
}

Mikrofon kullanmak yerine ses dosyası sağlamak istiyorsanız yine de bir audioConfig parametre sağlamanız gerekir. Ancak, bir AudioConfig sınıf örneği oluşturduğunuzda, FromDefaultMicrophoneInput yerine FromWavFileInput çağırır ve filename parametresini geçirirsiniz.

static async Task TranslateSpeechAsync()
{
    var speechTranslationConfig =
        SpeechTranslationConfig.FromSubscription(SPEECH__SUBSCRIPTION__KEY, SPEECH__SERVICE__REGION);
    
    var fromLanguage = "en-US";
    var toLanguages = new List<string> { "it", "fr", "de" };
    speechTranslationConfig.SpeechRecognitionLanguage = fromLanguage;
    toLanguages.ForEach(speechTranslationConfig.AddTargetLanguage);

    using var audioConfig = AudioConfig.FromWavFileInput("YourAudioFile.wav");
    using var translationRecognizer = new TranslationRecognizer(speechTranslationConfig, audioConfig);
}

Konuşmayı çevirme

static async Task TranslateSpeechAsync()
{
    var speechTranslationConfig =
        SpeechTranslationConfig.FromSubscription(SPEECH__SUBSCRIPTION__KEY, SPEECH__SERVICE__REGION);
    
    var fromLanguage = "en-US";
    var toLanguages = new List<string> { "it", "fr", "de" };
    speechTranslationConfig.SpeechRecognitionLanguage = fromLanguage;
    toLanguages.ForEach(speechTranslationConfig.AddTargetLanguage);

    using var translationRecognizer = new TranslationRecognizer(speechTranslationConfig);

    Console.Write($"Say something in '{fromLanguage}' and ");
    Console.WriteLine($"we'll translate into '{string.Join("', '", toLanguages)}'.\n");
    
    var result = await translationRecognizer.RecognizeOnceAsync();
    if (result.Reason == ResultReason.TranslatedSpeech)
    {
        Console.WriteLine($"Recognized: \"{result.Text}\":");
        foreach (var element in result.Translations)
        {
            Console.WriteLine($"    TRANSLATED into '{element.Key}': {element.Value}");
        }
    }
}

Konuşmayı metne dönüştürme hakkında daha fazla bilgi için bkz . Konuşma tanımanın temelleri.

Olay tabanlı çeviri

TranslationRecognizer nesnesi bir Recognizing olayı açığa çıkarır. Olay birkaç kez tetiklenir ve ara çeviri sonuçlarını almak için bir mekanizma sunar.

Not

Kaynak dil adayları olmadan çok dilli konuşma çevirisi kullandığınızda ara çeviri sonuçları mevcut değildir.

Aşağıdaki örnek ara çeviri sonuçlarını konsola yazdırır:

using Microsoft.CognitiveServices.Speech;
using Microsoft.CognitiveServices.Speech.Audio;
using Microsoft.CognitiveServices.Speech.Translation;

public class Program
{
    private static readonly string SPEECH__SUBSCRIPTION__KEY = Environment.GetEnvironmentVariable(nameof(SPEECH__SUBSCRIPTION__KEY));
    private static readonly string SPEECH__SERVICE__REGION = Environment.GetEnvironmentVariable(nameof(SPEECH__SERVICE__REGION));

    public static void Main(string[] args)
    {
        try
        {
            EventTranslationAsync().Wait();
        }
        catch (Exception ex)
        {
            Console.WriteLine(ex);
        }
    }

    static async Task EventTranslationAsync()
    {
        var speechTranslationConfig =
            SpeechTranslationConfig.FromSubscription(SPEECH__SUBSCRIPTION__KEY, SPEECH__SERVICE__REGION);

        var fromLanguage = "en-US";
        speechTranslationConfig.SpeechRecognitionLanguage = fromLanguage;
        speechTranslationConfig.AddTargetLanguage("de");
        speechTranslationConfig.AddTargetLanguage("fr");

        var stopTranslation = new TaskCompletionSource<int>(TaskCreationOptions.RunContinuationsAsynchronously);

        using (var audioInput = AudioConfig.FromWavFileInput(@"whatstheweatherlike.wav"))
        {
            using (var translationRecognizer = new TranslationRecognizer(speechTranslationConfig, audioInput))
            {
                // Subscribes to events.
                translationRecognizer.Recognizing += (s, e) =>
                {
                    Console.WriteLine($"RECOGNIZING in '{fromLanguage}': Text={e.Result.Text}");
                    foreach (var element in e.Result.Translations)
                    {
                        Console.WriteLine($"    TRANSLATING into '{element.Key}': {element.Value}");
                    }
                };

                translationRecognizer.Recognized += (s, e) => {
                    if (e.Result.Reason == ResultReason.TranslatedSpeech)
                    {
                        Console.WriteLine($"RECOGNIZED in '{fromLanguage}': Text={e.Result.Text}");
                        foreach (var element in e.Result.Translations)
                        {
                            Console.WriteLine($"    TRANSLATED into '{element.Key}': {element.Value}");
                        }
                    }
                    else if (e.Result.Reason == ResultReason.RecognizedSpeech)
                    {
                        Console.WriteLine($"RECOGNIZED: Text={e.Result.Text}");
                        Console.WriteLine($"    Speech not translated.");
                    }
                    else if (e.Result.Reason == ResultReason.NoMatch)
                    {
                        Console.WriteLine($"NOMATCH: Speech could not be recognized.");
                    }
                };

                translationRecognizer.Canceled += (s, e) =>
                {
                    Console.WriteLine($"CANCELED: Reason={e.Reason}");
                    if (e.Reason == CancellationReason.Error)
                    {
                        Console.WriteLine($"CANCELED: ErrorDetails={e.ErrorDetails}");
                        Console.WriteLine($"CANCELED: Did you set the speech resource key and region values?");
                    }
                    stopTranslation.TrySetResult(0);
                };

                translationRecognizer.SessionStopped += (s, e) =>
                {
                    Console.WriteLine("Session stopped.");
                    stopTranslation.TrySetResult(0);
                };

                // Starts continuous recognition. Uses StopContinuousRecognitionAsync() to stop recognition.
                Console.WriteLine("Start translation...");
                await translationRecognizer.StartContinuousRecognitionAsync();

                // Waits for completion.
                // Use Task.WaitAny to keep the task rooted.
                Task.WaitAny(new[] { stopTranslation.Task });

                // Stops translation.
                await translationRecognizer.StopContinuousRecognitionAsync();
            }
        }
    }
}

Çevirileri sentezle

Başarılı bir konuşma tanıma ve konuşma çevirisinin ardından, sonuç bir sözlükteki tüm çevirileri içerir. Translations Sözlük anahtarı hedef çeviri dili, değer ise çevrilmiş metindir. Tanınan konuşma çevrilebilir ve daha sonra farklı bir dilde (konuşmadan konuşmaya) sentezlenebilir.

Olay tabanlı sentez

Bir VoiceName örnek atayarak sentez sesini belirtin ve ses dosyasını almak için Synthesizing olayını işlemek için bir olay işleyicisi sağlayın. Aşağıdaki örnek çevrilmiş sesi .wav dosyası olarak kaydeder.

Önemli

Olay tabanlı sentez yalnızca tek bir çeviriyle çalışır. Birden çok hedef çeviri dili eklemeyin. Ayrıca, değerin VoiceName hedef çeviri diliyle aynı dil olması gerekir. Örneğin, "de", "de-DE-Hedda" ile eşlenebilir.

static async Task TranslateSpeechAsync()
{
    var speechTranslationConfig =
        SpeechTranslationConfig.FromSubscription(SPEECH__SUBSCRIPTION__KEY, SPEECH__SERVICE__REGION);
    
    var fromLanguage = "en-US";
    var toLanguage = "de";
    speechTranslationConfig.SpeechRecognitionLanguage = fromLanguage;
    speechTranslationConfig.AddTargetLanguage(toLanguage);

    speechTranslationConfig.VoiceName = "de-DE-Hedda";

    using var translationRecognizer = new TranslationRecognizer(speechTranslationConfig);

    translationRecognizer.Synthesizing += (_, e) =>
    {
        var audio = e.Result.GetAudio();
        Console.WriteLine($"Audio synthesized: {audio.Length:#,0} byte(s) {(audio.Length == 0 ? "(Complete)" : "")}");

        if (audio.Length > 0)
        {
            File.WriteAllBytes("YourAudioFile.wav", audio);
        }
    };

    Console.Write($"Say something in '{fromLanguage}' and ");
    Console.WriteLine($"we'll translate into '{toLanguage}'.\n");

    var result = await translationRecognizer.RecognizeOnceAsync();
    if (result.Reason == ResultReason.TranslatedSpeech)
    {
        Console.WriteLine($"Recognized: \"{result.Text}\"");
        Console.WriteLine($"Translated into '{toLanguage}': {result.Translations[toLanguage]}");
    }
}

El ile sentez

Çeviri metninden Translations ses sentezlemek için sözlüğü kullanabilirsiniz. Her çeviriyi yineleyip sentezler. Bir SpeechSynthesizer örneği oluştururken, SpeechConfig özelliği istenen sese ayarlanmış SpeechSynthesisVoiceName nesnesine ihtiyaç vardır.

Aşağıdaki örnek beş dile çevrilir. Her çeviri daha sonra ilgili sinir dilinde bir ses dosyasına sentezlenmiş olur.

static async Task TranslateSpeechAsync()
{
    var speechTranslationConfig =
        SpeechTranslationConfig.FromSubscription(SPEECH__SUBSCRIPTION__KEY, SPEECH__SERVICE__REGION);

    var fromLanguage = "en-US";
    var toLanguages = new List<string> { "de", "en", "it", "pt", "zh-Hans" };
    speechTranslationConfig.SpeechRecognitionLanguage = fromLanguage;
    toLanguages.ForEach(speechTranslationConfig.AddTargetLanguage);

    using var translationRecognizer = new TranslationRecognizer(speechTranslationConfig);

    Console.Write($"Say something in '{fromLanguage}' and ");
    Console.WriteLine($"we'll translate into '{string.Join("', '", toLanguages)}'.\n");

    var result = await translationRecognizer.RecognizeOnceAsync();
    if (result.Reason == ResultReason.TranslatedSpeech)
    {
        var languageToVoiceMap = new Dictionary<string, string>
        {
            ["de"] = "de-DE-KatjaNeural",
            ["en"] = "en-US-AriaNeural",
            ["it"] = "it-IT-ElsaNeural",
            ["pt"] = "pt-BR-FranciscaNeural",
            ["zh-Hans"] = "zh-CN-XiaoxiaoNeural"
        };

        Console.WriteLine($"Recognized: \"{result.Text}\"");

        foreach (var (language, translation) in result.Translations)
        {
            Console.WriteLine($"Translated into '{language}': {translation}");

            var speechConfig =
                SpeechConfig.FromSubscription(
                    SPEECH__SUBSCRIPTION__KEY, SPEECH__SERVICE__REGION);
            speechConfig.SpeechSynthesisVoiceName = languageToVoiceMap[language];

            using var audioConfig = AudioConfig.FromWavFileOutput($"{language}-translation.wav");
            using var speechSynthesizer = new SpeechSynthesizer(speechConfig, audioConfig);
            
            await speechSynthesizer.SpeakTextAsync(translation);
        }
    }
}

Konuşma sentezi hakkında daha fazla bilgi için bkz . Konuşma sentezinin temelleri.

Dil belirleme ile çok dilli çeviri

Aşağıdaki örnek, en-US veya zh-CN'in, AutoDetectSourceLanguageConfig içinde tanımlandıkları için algılanması gerektiğini öngörmektedir. Daha sonra konuşma, de ve fr olarak, AddTargetLanguage() öğesine yapılan çağrılarda belirtildiği gibi çevrilir.

speechTranslationConfig.AddTargetLanguage("de");
speechTranslationConfig.AddTargetLanguage("fr");
var autoDetectSourceLanguageConfig = AutoDetectSourceLanguageConfig.FromLanguages(new string[] { "en-US", "zh-CN" });
var translationRecognizer = new TranslationRecognizer(speechTranslationConfig, autoDetectSourceLanguageConfig, audioConfig);

Eksiksiz bir kod örneği için bkz . dil belirleme.

Kaynak dil adayları olmadan çok dilli konuşma çevirisi

Çok dilli konuşma çevirisi, belirli bir giriş dilinin olmaması ve aynı oturumda dil değişikliklerini işleme gibi çeşitli özelliklerin kilidini açan yeni bir konuşma çevirisi teknolojisi düzeyini uygulamaya koyar. Bu özellikler, ürünlerinize uygulanabilecek yeni bir konuşma çevirisi gücü düzeyi sağlar.

Şu anda konuşma çevirisi ile Dil Kimliği'ni kullandığınızda, nesneyi SpeechTranslationConfig v2 uç noktasından oluşturmanız gerekir. "YourServiceRegion" dizesini Konuşma kaynak bölgenizle ("westus" gibi) değiştirin. "YourSpeechResourceKey" yerine Konuşma kaynak anahtarınızı yazın.

var v2EndpointInString = String.Format("wss://{0}.stt.speech.microsoft.com/speech/universal/v2", "YourServiceRegion");
var v2EndpointUrl = new Uri(v2EndpointInString);
var speechTranslationConfig = SpeechTranslationConfig.FromEndpoint(v2EndpointUrl, "YourSpeechResourceKey");

Çeviri hedef dillerini belirtin. Seçtiğiniz dillerle değiştir. Daha fazla satır ekleyebilirsiniz.

speechTranslationConfig.AddTargetLanguage("de");
speechTranslationConfig.AddTargetLanguage("fr");

Çok dilli konuşma çevirisi ile önemli bir fark, kaynak dili belirtmeniz gerekmemesidir. Bunun nedeni hizmetin kaynak dili otomatik olarak algılamasıdır. AutoDetectSourceLanguageConfig Belirtilen kaynak dil olmadan çok dilli konuşma çevirisi kullanmak istediğinizi hizmete bildirmek için yöntemini kullanarak FromOpenRange nesnesini oluşturun.

AutoDetectSourceLanguageConfig autoDetectSourceLanguageConfig = AutoDetectSourceLanguageConfig.FromOpenRange(); 
var translationRecognizer = new TranslationRecognizer(speechTranslationConfig, autoDetectSourceLanguageConfig, audioConfig);

Konuşma SDK'sı ile eksiksiz bir kod örneği için bkz . GitHub'da konuşma çevirisi örnekleri.

Kişisel sesle gerçek zamanlı konuşma çevirisi için canlı yorumlayıcı kullanma

Canlı Yorumlayıcı, bir giriş dili ayarlamanıza gerek kalmadan konuşulan dili sürekli olarak tanımlar ve konuşmacının stilini ve tonunu koruyan doğal bir sesle düşük gecikmeli konuşma çevirisi sunar.

Canlı Yorumlayıcı API'sini kullanmak için önce kişisel ses erişimine başvurun ve Soru 20 için "Kişisel Ses"i seçin. Kaynak kimliği için lütfen Canlı Yorumlayıcı'yı destekleyen bölgelerden birinde olduğundan emin olun. Geçerli bölgesel kullanılabilirlik için Konuşma hizmeti bölgeleri tablosuna bakın.

Kişisel ses erişimi izni verildikten sonra, Canlı Yorumlayıcı'yı aşağıdaki kodla etkinleştirebilirsiniz:

// Please replace the service region with your region
var v2EndpointInString = String.Format("wss://{0}.stt.speech.microsoft.com/speech/universal/v2", "YourRegion");
var v2EndpointUrl = new Uri(v2EndpointInString);

// Creates an instance of a speech translation config with specified subscription key and service region.
// Please replace the service subscription key with your subscription key
var speechTranslationConfig = SpeechTranslationConfig.FromEndpoint(v2EndpointUrl, "YourSubscriptionKey");

// Translation target language and enable personal voice
speechTranslationConfig.AddTargetLanguage("fr");
speechTranslationConfig.VoiceName = "personal-voice";

// You don't need to define any candidate languages to detect.
var autoDetectSourceLanguageConfig = AutoDetectSourceLanguageConfig.FromOpenRange();

Aşağıda daha ayrıntılı bir örnek verilmiştir:

using Microsoft.CognitiveServices.Speech;
using Microsoft.CognitiveServices.Speech.Audio;
using Microsoft.CognitiveServices.Speech.Translation;
using NAudio.Wave;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Text;
using System.Text.Json;
using System.Threading;
using System.Threading.Tasks;
using System.Xml.Linq;

namespace LiveInterpreterDemo
{
    class Program
    {
        public static async Task LiveInterpreterDemoAsync()
        {
            // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
            // NOTICE!!!, set your test file here
            // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
            string audioFile = "<TEST_FILE>";

            string locale = "zh-CN";
            Console.WriteLine("Start testing for " + audioFile);
            Console.WriteLine("Test file " + audioFile);
            Console.WriteLine("Target locale " + locale);

            // Make sure the output in terminal can be displayed normally, not necessary if you do not want to print result in terminal
            Console.OutputEncoding = Encoding.UTF8;

            // When you use Multilingual Translation with language identification, 
            // you don't need to define any candidate languages to detect, but you must set a v2 endpoint and use
            // SpeechTranslationConfig.FromEndpoint() to create the SpeechTranslationConfig object.
            // This will be fixed in a future version of Speech SDK.

            // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
            // NOTICE!!!, set your region and key here
            // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
            var speechTranslationConfig = SpeechTranslationConfig.FromEndpoint(new Uri("https://<REGION>.stt.speech.microsoft.com/speech/universal/v2"), "<KEY>");
            speechTranslationConfig.AddTargetLanguage(locale);
            speechTranslationConfig.VoiceName = "personal-voice";

            // You don't need to define any candidate languages to detect.
            var autoDetectSourceLanguageConfig = AutoDetectSourceLanguageConfig.FromOpenRange();

            var stopTranslation = new TaskCompletionSource<int>(TaskCreationOptions.RunContinuationsAsynchronously);

            // index of output auido files
            int i = 0;
            Console.WriteLine($"Start time: {DateTime.UtcNow}");

            using (var audioInput = AudioConfig.FromWavFileInput(audioFile))
            {
                using (var recognizer = new TranslationRecognizer(speechTranslationConfig, autoDetectSourceLanguageConfig, audioInput))
                {
                    // Subscribes to events.
                    recognizer.Recognizing += (s, e) =>
                    {
                        var lidResult = e.Result.Properties.GetProperty(PropertyId.SpeechServiceConnection_AutoDetectSourceLanguageResult);

                        Console.WriteLine($"RECOGNIZING in '{lidResult}': Text={e.Result.Text}, Offset={e.Offset}, Duration={e.Result.Duration}");
                        if (e.Result.Reason == ResultReason.TranslatingSpeech)
                        {
                            foreach (var element in e.Result.Translations)
                            {
                                Console.WriteLine($"    TRANSLATING into '{element.Key}': {element.Value}");
                            }

                        }
                    };

                    recognizer.Recognized += (s, e) => {
                        if (e.Result.Reason == ResultReason.TranslatedSpeech)
                        {
                            var lidResult = e.Result.Properties.GetProperty(PropertyId.SpeechServiceConnection_AutoDetectSourceLanguageResult);

                            Console.WriteLine($"RECOGNIZED in '{lidResult}': Text={e.Result.Text}, Offset={e.Offset}, Duration={e.Result.Duration}");
                            foreach (var element in e.Result.Translations)
                            {
                                Console.WriteLine($"    TRANSLATED into '{element.Key}': {element.Value}");
                            }
                        }
                        else if (e.Result.Reason == ResultReason.RecognizedSpeech)
                        {
                            Console.WriteLine($"RECOGNIZED: Text={e.Result.Text}");
                            Console.WriteLine($"    Speech not translated.");
                        }
                        else if (e.Result.Reason == ResultReason.NoMatch)
                        {
                            Console.WriteLine($"NOMATCH: Speech could not be recognized.");
                        }
                    };

                    recognizer.Canceled += (s, e) =>
                    {
                        Console.WriteLine($"CANCELED: Reason={e.Reason}");

                        if (e.Reason == CancellationReason.Error)
                        {
                            Console.WriteLine($"CANCELED: ErrorCode={e.ErrorCode}");
                            Console.WriteLine($"CANCELED: ErrorDetails={e.ErrorDetails}");
                            Console.WriteLine($"CANCELED: Did you update the subscription info?");
                        }

                        stopTranslation.TrySetResult(0);
                    };

                    recognizer.Synthesizing += (_, e) =>
                    {
                        var audio = e.Result.GetAudio();

                        Console.WriteLine($"{e.SessionId} Audio synthesized: {audio.Length:#,0} byte(s) Current time: {DateTime.UtcNow} {(audio.Length == 0 ? "(Complete)" : "")}");

                        if (audio.Length > 0)
                        {
                            File.WriteAllBytes(string.Format("YourAudioFile-{0}.wav", ++i), audio);
                        }

                        if (audio.Length == 0)
                        {
                            stopTranslation.TrySetResult(0);
                        }
                    };

                    Console.WriteLine("Start translation...");
                    await recognizer.StartContinuousRecognitionAsync();

                    // Waits for completion.
                    // Use Task.WaitAny to keep the task rooted.
                    Task.WaitAny(new[] { stopTranslation.Task });

                    // Stops translation.
                    await recognizer.StopContinuousRecognitionAsync();
                }
            }
            Console.WriteLine($"End time: {DateTime.UtcNow}");
        }

        static async Task Main()
        {
            await LiveInterpreterDemoAsync();
        }
    }
}

Konuşma çevirisinde özel çeviri kullanma

Konuşma çevirisindeki özel çeviri özelliği, Azure Özel Çeviri hizmetiyle sorunsuz bir şekilde tümleştirildiğinden daha doğru ve uyarlanmış çeviriler elde edebilirsiniz. Tümleştirme, Azure özel çeviri hizmetinin özelliklerinden doğrudan yararlandığından, tüm özellikler kümesinin doğru şekilde çalıştığından emin olmak için çok hizmetli bir kaynak kullanmanız gerekir. Ayrıntılı yönergeler için lütfen Döküm Araçları için çok hizmetli kaynak oluşturma kılavuzuna bakın.

Ayrıca, özel bir çeviricinin çevrimdışı eğitimi ve "Kategori Kimliği" elde etmek için Hızlı Başlangıç: Özel model oluşturma, dağıtma ve kullanma - Özel Çevirici'de sağlanan adım adım betiği inceleyin.

// Creates an instance of a translation recognizer using speech translation configuration
// You should use the same subscription key, which you used to generate the custom model before.
// V2 endpoint is required for the "Custom Translation" feature. Example: "wss://westcentralus.stt.speech.microsoft.com/speech/universal/v2"

var v2EndpointInString = "wss://westcentralus.stt.speech.microsoft.com/speech/universal/v2";
var v2EndpointUrl = new Uri(v2EndpointInString);
var speechTranslationConfig = SpeechTranslationConfig.FromEndpoint(v2EndpointUrl, "YourSpeechSubscriptionKey");

// Sets source and target language(s).
speechTranslationConfig.SpeechRecognitionLanguage = "en-US";
speechTranslationConfig.AddTargetLanguage("de");

// Set the category id
speechTranslationConfig.SetProperty(PropertyId.SpeechServiceConnection_TranslationCategory, "yourCategoryId");

Başvuru belgeleri | npm Paketi | GitHub'daki ek örnekler | Kitaplık kaynak kodu

Bu nasıl yapılır kılavuzunda insan konuşmasını tanımayı ve başka bir dile çevirmeyi öğreneceksiniz.

Aşağıdakiler hakkında daha fazla bilgi için konuşma çevirisine genel bakış bölümüne bakın:

Konuşmayı metne çevirme
Konuşmayı birden çok hedef dile çevirme
Doğrudan konuşmadan konuşmaya çeviri gerçekleştirme

Çeviri yapılandırması oluşturma

Konuşma SDK'sını kullanarak çeviri hizmetini çağırmak için bir SpeechTranslationConfig örnek oluşturmanız gerekir. Bu sınıf anahtarınız ve ilişkili bölgeniz, uç noktanız, konağınız veya yetkilendirme belirteciniz gibi Konuşma kaynağınızla ilgili bilgileri içerir.

Not

Konuşma tanıma, konuşma sentezi, çeviri veya amaç tanıma gerçekleştirmenize bakılmaksızın, her zaman bir yapılandırma oluşturursunuz.

SpeechTranslationConfig başlatmanın birkaç yolu vardır:

Abonelikle: anahtarı ve ilişkili bölgeyi geçirin.
Bir uç nokta belirleyerek: Konuşma hizmeti uç noktasını girin. Anahtar veya yetkilendirme belirteci isteğe bağlıdır.
Sunucu ile: bir sunucu adresi giriniz. Anahtar veya yetkilendirme belirteci isteğe bağlıdır.
Yetkilendirme belirteci ile: Yetkilendirme belirtecini ve ilişkili bölgeyi iletin.

Şimdi bir anahtar ve bölge kullanarak bir SpeechTranslationConfig örneği nasıl oluşturduğunuza bakalım. Azure portalında Konuşma kaynak anahtarını ve bölgesini alın.

const speechTranslationConfig = SpeechTranslationConfig.fromSubscription("YourSpeechResourceKey", "YourServiceRegion");

Çeviriyi başlatma

Bir SpeechTranslationConfig örneği oluşturduktan sonra, sonraki adım TranslationRecognizer'i başlatmaktır. TranslationRecognizer başlattığınızda, speechTranslationConfig örneğinizi geçirmeniz gerekir. Yapılandırma nesnesi, çeviri hizmetinin isteğinizi doğrulamak için gerektirdiği kimlik bilgilerini sağlar.

Cihazınızın varsayılan mikrofonu aracılığıyla sağlanan konuşmayı çeviriyorsanız şu TranslationRecognizer şekilde görünmelidir:

const translationRecognizer = new TranslationRecognizer(speechTranslationConfig);

Ses giriş cihazını belirtmek istiyorsanız, bir AudioConfig sınıf örneği oluşturmanız ve başlatılırken audioConfig parametresini TranslationRecognizer sağlamanız gerekir.

İpucu

Ses giriş cihazınızın cihaz kimliğini nasıl alacağınızı öğrenin.

AudioConfig nesnesine aşağıdaki şekilde başvurun:

const audioConfig = AudioConfig.fromDefaultMicrophoneInput();
const translationRecognizer = new TranslationRecognizer(speechTranslationConfig, audioConfig);

Mikrofon kullanmak yerine ses dosyası sağlamak istiyorsanız yine de bir audioConfig parametre sağlamanız gerekir. Ancak, bunu yalnızca Node.js hedeflediğinizde yapabilirsiniz. Bir AudioConfig sınıfının örneğini oluşturduğunuzda, fromDefaultMicrophoneInput yerine fromWavFileOutput öğesini çağırarak filename parametresini geçirirsiniz.

const audioConfig = AudioConfig.fromWavFileInput("YourAudioFile.wav");
const translationRecognizer = new TranslationRecognizer(speechTranslationConfig, audioConfig);

Konuşmayı çevirme

JavaScript için Konuşma SDK'sının TranslationRecognizer sınıfı , konuşma çevirisi için kullanabileceğiniz yöntemleri kullanıma sunar:

Tek seferlik çeviri (zaman uyumsuz): Çeviriyi engelleyici olmayan (zaman uyumsuz) modda gerçekleştirir. Tek bir konuşmayı çevirir. Tek bir konuşmanın sonunu, en fazla 15 saniye ses işlenene kadar veya sonundaki sessizliği dinleyerek belirler.
Sürekli çeviri (zaman uyumsuz):Zaman uyumsuz olarak sürekli çeviri işlemi başlatır. Kullanıcı olaylara kaydolup çeşitli uygulama durumlarını işler. Asenkron sürekli çeviriyi durdurmak için stopContinuousRecognitionAsync çağırın.

Konuşma tanıma modunu seçme hakkında daha fazla bilgi edinmek için bkz . Konuşmayı metne dönüştürmeye başlama.

Hedef dil belirtme

Çevirmek için hem kaynak dili hem de en az bir hedef dil belirtmeniz gerekir.

Konuşma çevirisi tablosunda listelenen bir yerel ayarı kullanarak kaynak dil seçebilirsiniz. Çevrilmiş dil seçeneklerinizi aynı bağlantıda bulabilirsiniz.

Hedef diller için seçenekleriniz, metni görüntülemek veya sentezlenmiş çevrilmiş konuşmayı duymak istediğinizde farklılık gösterir. İngilizceden Almancaya çevirmek için çeviri yapılandırma nesnesini değiştirin:

speechTranslationConfig.speechRecognitionLanguage = "en-US";
speechTranslationConfig.addTargetLanguage("de");

Tek seferlik tanıma

recognizeOnceAsync aracılığıyla eşzamansız tek atımlık çeviri örneği verilmiştir.

translationRecognizer.recognizeOnceAsync(result => {
    // Interact with result
});

Sonucu işlemek için kod yazmanız gerekir. Bu örnek, result.reason Almancaya çeviriyi değerlendirir:

translationRecognizer.recognizeOnceAsync(
  function (result) {
    let translation = result.translations.get("de");
    window.console.log(translation);
    translationRecognizer.close();
  },
  function (err) {
    window.console.log(err);
    translationRecognizer.close();
});

Kodunuz, çeviri işlenirken sağlanan güncelleştirmeleri de işleyebilir. Çeviri ilerleme durumu hakkında görsel geri bildirim sağlamak için bu güncelleştirmeleri kullanabilirsiniz. Bu JavaScript Node.js örneği bu tür güncelleştirmeleri gösterir. Aşağıdaki kod, çeviri işlemi sırasında oluşturulan ayrıntıları da görüntüler:

translationRecognizer.recognizing = function (s, e) {
    var str = ("(recognizing) Reason: " + SpeechSDK.ResultReason[e.result.reason] +
            " Text: " +  e.result.text +
            " Translation:");
    str += e.result.translations.get("de");
    console.log(str);
};
translationRecognizer.recognized = function (s, e) {
    var str = "\r\n(recognized)  Reason: " + SpeechSDK.ResultReason[e.result.reason] +
            " Text: " + e.result.text +
            " Translation:";
    str += e.result.translations.get("de");
    str += "\r\n";
    console.log(str);
};

Olay tabanlı çeviri

Olay tabanlı çeviri, tek seferlik tanımadan daha karmaşıktır. Tanıma sonuçlarını almak için recognizing, recognizedve canceled olaylarına abone olmanız gerekir. Çeviriyi durdurmak için stopContinuousRecognitionAsync öğesini çağırmanız gerekir.

Not

Çok dilli konuşma çevirisi kullandığınızda ara çeviri sonuçları kullanılamaz.

Olay tabanlı çevirinin bir ses giriş dosyasında nasıl gerçekleştirildiğini gösteren bir örnek aşağıda verilmiştir. Öncelikle girişi tanımlayıp TranslationRecognizer başlatmayı başlatalım:

const translationRecognizer = new TranslationRecognizer(speechTranslationConfig);

Aşağıdaki kodda, öğesinden TranslationRecognizergönderilen olaylara abone olacaksınız:

recognizing: Ara çeviri sonuçları içeren olaylar için sinyal.
recognized: Son çeviri sonuçlarını içeren olaylar için sinyal. Bu sonuçlar başarılı bir çeviri girişimi olduğunu gösterir.
sessionStopped: Çeviri oturumunun (işlem) sonunu gösteren olaylar için sinyal.
canceled: İptal edilen çeviri sonuçlarını içeren olaylar için sinyal. Bu olaylar, doğrudan iptal sonucu iptal edilen bir çeviri girişimini gösterir. Alternatif olarak, bir aktarım veya protokol hatası olduğunu gösterirler.

translationRecognizer.recognizing = (s, e) => {
    console.log(`TRANSLATING: Text=${e.result.text}`);
};
translationRecognizer.recognized = (s, e) => {
    if (e.result.reason == ResultReason.RecognizedSpeech) {
        console.log(`TRANSLATED: Text=${e.result.text}`);
    }
    else if (e.result.reason == ResultReason.NoMatch) {
        console.log("NOMATCH: Speech could not be translated.");
    }
};
translationRecognizer.canceled = (s, e) => {
    console.log(`CANCELED: Reason=${e.reason}`);
    if (e.reason == CancellationReason.Error) {
        console.log(`"CANCELED: ErrorCode=${e.errorCode}`);
        console.log(`"CANCELED: ErrorDetails=${e.errorDetails}`);
        console.log("CANCELED: Did you set the speech resource key and region values?");
    }
    translationRecognizer.stopContinuousRecognitionAsync();
};
translationRecognizer.sessionStopped = (s, e) => {
    console.log("\n    Session stopped event.");
    translationRecognizer.stopContinuousRecognitionAsync();
};

Her şey kurulu olduğunda startContinuousRecognitionAsync çağırabilirsiniz.

// Starts continuous recognition. Uses stopContinuousRecognitionAsync() to stop recognition.
translationRecognizer.startContinuousRecognitionAsync();
// Something later can call. Stops recognition.
// translationRecognizer.StopContinuousRecognitionAsync();

Kaynak dil seçin

Konuşma çevirisi için sık kullanılan bir görev, giriş (veya kaynak) dilini belirtmektir. Aşağıdaki örnekte giriş dilini İtalyanca olarak nasıl değiştirdiğiniz gösterilmektedir. Kodunuzda örneğinizi SpeechTranslationConfig bulun ve hemen altına aşağıdaki satırı ekleyin:

speechTranslationConfig.speechRecognitionLanguage = "it-IT";

speechRecognitionLanguage özelliği bir dil-yerel ayar biçim dizesi bekler. Desteklenen konuşma çevirisi yerel ayarlarının listesine bakın.

Bir veya daha fazla hedef dil seçme

Konuşma SDK'sı birden çok hedef dile paralel olarak çevrilebilir. Kullanılabilir hedef diller, kaynak dil listesinden biraz farklıdır. Hedef dilleri yerel ayar yerine bir dil kodu kullanarak belirtirsiniz.

Metin hedeflerinin dil kodlarının listesi için dil destek sayfasındaki konuşma çevirisi tablosuna bakın. Sentezlenmiş dillerin çevirisi hakkındaki ayrıntıları da burada bulabilirsiniz.

Aşağıdaki kod, hedef dil olarak Almanca ekler:

speechTranslationConfig.addTargetLanguage("de");

Birden çok hedef dil çevirisi mümkün olduğundan, sonucu incelerken kodunuzun hedef dili belirtmesi gerekir. Aşağıdaki kod Almanca için çeviri sonuçlarını alır:

translationRecognizer.recognized = function (s, e) {
    var str = "\r\n(recognized)  Reason: " +
            sdk.ResultReason[e.result.reason] +
            " Text: " + e.result.text + " Translations:";
    var language = "de";
    str += " [" + language + "] " + e.result.translations.get(language);
    str += "\r\n";
    // show str somewhere
};

Çevirileri sentezle

Başarılı bir konuşma tanıma ve konuşma çevirisinin ardından, sonuç bir sözlükteki tüm çevirileri içerir. translations özelliği, anahtarı hedef çeviri dili ve değeri çevrilmiş metin olarak içeren bir sözlük döndürür. Tanınan konuşma çevrilebilir ve daha sonra farklı bir dilde (konuşmadan konuşmaya) sentezlenebilir.

Olay tabanlı sentez

TranslationRecognizer nesnesi bir synthesizing olayı açığa çıkarır. Olay birkaç kez gerçekleşir ve çeviri tanıma sonucundan sentezlenmiş sesi almak için bir yöntem sunar. Birden çok dile çeviri yapıyorsanız, bkz. El ile sentezleme.

Bir voiceName özelliği atayarak sentez sesini belirtin ve ses almak için synthesizing olay işleyicisi sağlayın. Aşağıdaki örnek çevrilmiş sesi .wav dosyası olarak kaydeder.

Önemli

Olay tabanlı sentez yalnızca tek bir çeviriyle çalışır. Birden çok hedef çeviri dili eklemeyin. Ayrıca, değerin voiceName hedef çeviri diliyle aynı dil olması gerekir. Örneğin, "de", "de-DE-Hedda" ile eşlenebilir.

const speechTranslationConfig = SpeechTranslationConfig.fromSubscription("YourSpeechResourceKey", "YourServiceRegion");

speechTranslationConfig.speechRecognitionLanguage = "en-US";
speechTranslationConfig.addTargetLanguage("de");

// See: https://aka.ms/speech/sdkregion#standard-and-neural-voices
speechTranslationConfig.voiceName = "de-DE-Hedda";

const translationRecognizer = new TranslationRecognizer(speechTranslationConfig);

translationRecognizer.synthesizing = (s, e) => {
    const audio = e.result.audio;
    console.log(`Audio synthesized: ${audio.byteLength} byte(s) ${audio.byteLength === 0 ? "(COMPLETE)" : ""}`);
    
    if (audio.byteLength > 0) {
        // In Node.js, save to file
        const fs = require("fs");
        fs.writeFileSync("translation.wav", Buffer.from(audio));
    }
};

console.log("Say something in English and we'll translate to German...");

translationRecognizer.recognizeOnceAsync(result => {
    if (result.reason === ResultReason.TranslatedSpeech) {
        console.log(`Recognized: "${result.text}"`);
        console.log(`Translated into German: ${result.translations.get("de")}`);
    }
    translationRecognizer.close();
});

El ile sentez

Aşağıdaki örnek beş dile çevrilir. Her çeviri daha sonra ilgili sinir dilinde bir ses dosyasına sentezlenmiş olur.

const speechTranslationConfig = SpeechTranslationConfig.fromSubscription("YourSpeechResourceKey", "YourServiceRegion");

speechTranslationConfig.speechRecognitionLanguage = "en-US";
speechTranslationConfig.addTargetLanguage("de");
speechTranslationConfig.addTargetLanguage("fr");
speechTranslationConfig.addTargetLanguage("it");
speechTranslationConfig.addTargetLanguage("pt");
speechTranslationConfig.addTargetLanguage("zh-Hans");

const translationRecognizer = new TranslationRecognizer(speechTranslationConfig);

console.log("Say something...");

translationRecognizer.recognizeOnceAsync(async result => {
    if (result.reason === ResultReason.TranslatedSpeech) {
        const languageToVoiceMap = {
            "de": "de-DE-KatjaNeural",
            "fr": "fr-FR-DeniseNeural",
            "it": "it-IT-ElsaNeural",
            "pt": "pt-BR-FranciscaNeural",
            "zh-Hans": "zh-CN-XiaoxiaoNeural"
        };

        console.log(`Recognized: "${result.text}"`);

        for (const [language, translation] of result.translations) {
            console.log(`Translated into '${language}': ${translation}`);

            const speechConfig = SpeechConfig.fromSubscription("YourSpeechResourceKey", "YourServiceRegion");
            speechConfig.speechSynthesisVoiceName = languageToVoiceMap[language];

            const audioConfig = AudioConfig.fromAudioFileOutput(`${language}-translation.wav`);
            const speechSynthesizer = new SpeechSynthesizer(speechConfig, audioConfig);

            await new Promise((resolve, reject) => {
                speechSynthesizer.speakTextAsync(
                    translation,
                    synthesisResult => {
                        speechSynthesizer.close();
                        resolve();
                    },
                    error => {
                        speechSynthesizer.close();
                        reject(error);
                    }
                );
            });
        }
    }
    translationRecognizer.close();
});

Konuşma sentezi hakkında daha fazla bilgi için bkz . Konuşma sentezinin temelleri.

Dil belirleme ile çok dilli çeviri

Aşağıdaki örnek, en-US veya zh-CN'in, AutoDetectSourceLanguageConfig içinde tanımlandıkları için algılanması gerektiğini öngörmektedir. Daha sonra konuşma, de ve fr olarak, addTargetLanguage() öğesine yapılan çağrılarda belirtildiği gibi çevrilir.

speechTranslationConfig.addTargetLanguage("de");
speechTranslationConfig.addTargetLanguage("fr");
const autoDetectSourceLanguageConfig = AutoDetectSourceLanguageConfig.fromLanguages(["en-US", "zh-CN"]);
const translationRecognizer = TranslationRecognizer.FromConfig(speechTranslationConfig, autoDetectSourceLanguageConfig, audioConfig);

Eksiksiz bir kod örneği için bkz . dil belirleme.

Başvuru belgeleri | GitHub'da ek örnekler

Bu nasıl yapılır kılavuzunda insan konuşmasını tanımayı ve başka bir dile çevirmeyi öğreneceksiniz.

Aşağıdakiler hakkında daha fazla bilgi için konuşma çevirisine genel bakış bölümüne bakın:

Konuşmayı metne çevirme
Konuşmayı birden çok hedef dile çevirme
Doğrudan konuşmadan konuşmaya çeviri gerçekleştirme

Hassas veriler ve ortam değişkenleri

Bu makaledeki örnek kaynak kodu, Konuşma kaynağının anahtarı ve bölgesi gibi hassas verileri depolamak için ortam değişkenlerine bağlıdır. Java kod dosyası, konak makinenin ortam değişkenlerinden atanan iki static final String değer içerir: SPEECH__SUBSCRIPTION__KEY ve SPEECH__SERVICE__REGION. Bu alanların her ikisi de sınıf kapsamında olduğundan, sınıfın yöntem gövdeleri içinde erişilebilir:

public class App {

    static final String SPEECH__SUBSCRIPTION__KEY = System.getenv("SPEECH__SUBSCRIPTION__KEY");
    static final String SPEECH__SERVICE__REGION = System.getenv("SPEECH__SERVICE__REGION");

    public static void main(String[] args) { }
}

Ortam değişkenleri hakkında daha fazla bilgi için bkz . Ortam değişkenleri ve uygulama yapılandırması.

Önemli

Yapay zeka hizmetleri güvenliği hakkında daha fazla bilgi için bkz . Azure AI hizmetlerine yönelik isteklerin kimliğini doğrulama.

Konuşma çevirisi yapılandırması oluşturma

İpucu

Konuşma tanıma, konuşma sentezi, çeviri veya amaç tanıma gerçekleştirmenize bakılmaksızın, her zaman bir yapılandırma oluşturursunuz.

Bir SpeechTranslationConfig örneğini birkaç şekilde başlatabilirsiniz.

Abonelikle: anahtarı ve ilişkili bölgeyi geçirin.
Bir uç nokta belirleyerek: Konuşma hizmeti uç noktasını girin. Anahtar veya yetkilendirme belirteci isteğe bağlıdır.
Sunucu ile: bir sunucu adresi giriniz. Anahtar veya yetkilendirme belirteci isteğe bağlıdır.
Yetkilendirme belirteci ile: Yetkilendirme belirtecini ve ilişkili bölgeyi iletin.

Şimdi bir anahtar ve bölge kullanarak bir SpeechTranslationConfig örneği nasıl oluşturduğunuza bakalım. Azure portalında Konuşma kaynak anahtarını ve bölgesini alın.

public class App {

    static final String SPEECH__SUBSCRIPTION__KEY = System.getenv("SPEECH__SERVICE__KEY");
    static final String SPEECH__SERVICE__REGION = System.getenv("SPEECH__SERVICE__REGION");

    public static void main(String[] args) {
        try {
            translateSpeech();
            System.exit(0);
        } catch (Exception ex) {
            System.out.println(ex);
            System.exit(1);
        }
    }

    static void translateSpeech() {
        SpeechTranslationConfig speechTranslationConfig = SpeechTranslationConfig.fromSubscription(
            SPEECH__SUBSCRIPTION__KEY, SPEECH__SERVICE__REGION);
    }
}

Kaynak dili değiştirme

Konuşma çevirisinin yaygın görevlerinden biri giriş (veya kaynak) dilini belirtmektir. Aşağıdaki örnekte giriş dilini İtalyanca olarak nasıl değiştirdiğiniz gösterilmektedir. Kodunuzda SpeechTranslationConfig örneğiyle, setSpeechRecognitionLanguage yöntemini çağırarak etkileşim kurun.

static void translateSpeech() {
    SpeechTranslationConfig speechTranslationConfig = SpeechTranslationConfig.fromSubscription(
        SPEECH__SUBSCRIPTION__KEY, SPEECH__SERVICE__REGION);
    
    // Source (input) language
    speechTranslationConfig.setSpeechRecognitionLanguage("it-IT");
}

setSpeechRecognitionLanguage işlevi bir dil-yerel ayar biçim dizesi bekler. Desteklenen konuşma çevirisi yerel ayarlarının listesine bakın.

Çeviri dili ekleme

static void translateSpeech() {
    SpeechTranslationConfig speechTranslationConfig = SpeechTranslationConfig.fromSubscription(
        SPEECH__SUBSCRIPTION__KEY, SPEECH__SERVICE__REGION);
    
    speechTranslationConfig.setSpeechRecognitionLanguage("it-IT");

    // Translate to languages. See https://aka.ms/speech/sttt-languages
    speechTranslationConfig.addTargetLanguage("fr");
    speechTranslationConfig.addTargetLanguage("de");
}

için yapılan her çağrıda addTargetLanguageyeni bir hedef çeviri dili belirtilir. Başka bir deyişle, konuşma kaynak dilden tanındığında, sonuçta elde edilen çeviri işleminin bir parçası olarak her hedef çeviri kullanılabilir.

Çeviri tanıyıcıyı başlatma

Eğer konuşmayı cihazınızın varsayılan mikrofonunu kullanarak TranslationRecognizer tanıyorsanız, aşağıdaki gibi görünmelidir:

static void translateSpeech() {
    SpeechTranslationConfig speechTranslationConfig = SpeechTranslationConfig.fromSubscription(
        SPEECH__SUBSCRIPTION__KEY, SPEECH__SERVICE__REGION);
    
    String fromLanguage = "en-US";
    String[] toLanguages = { "it", "fr", "de" };
    speechTranslationConfig.setSpeechRecognitionLanguage(fromLanguage);
    for (String language : toLanguages) {
        speechTranslationConfig.addTargetLanguage(language);
    }

    try (TranslationRecognizer translationRecognizer = new TranslationRecognizer(speechTranslationConfig)) {
    }
}

Ses giriş cihazını belirtmek istiyorsanız, bir AudioConfig sınıf örneği oluşturmanız ve başlatılırken audioConfig parametresini TranslationRecognizer sağlamanız gerekir.

İpucu

Ses giriş cihazınızın cihaz kimliğini nasıl alacağınızı öğrenin.

İlk olarak, AudioConfig nesnesine aşağıdaki şekilde başvurun:

static void translateSpeech() {
    SpeechTranslationConfig speechTranslationConfig = SpeechTranslationConfig.fromSubscription(
        SPEECH__SUBSCRIPTION__KEY, SPEECH__SERVICE__REGION);
    
    String fromLanguage = "en-US";
    String[] toLanguages = { "it", "fr", "de" };
    speechTranslationConfig.setSpeechRecognitionLanguage(fromLanguage);
    for (String language : toLanguages) {
        speechTranslationConfig.addTargetLanguage(language);
    }

    AudioConfig audioConfig = AudioConfig.fromDefaultMicrophoneInput();
    try (TranslationRecognizer translationRecognizer = new TranslationRecognizer(speechTranslationConfig, audioConfig)) {
        
    }
}

Mikrofon kullanmak yerine ses dosyası sağlamak istiyorsanız yine de bir audioConfig parametre sağlamanız gerekir. Ancak, bir AudioConfig sınıf örneği oluşturduğunuzda, fromDefaultMicrophoneInput yerine fromWavFileInput çağırır ve filename parametresini geçirirsiniz.

static void translateSpeech() {
    SpeechTranslationConfig speechTranslationConfig = SpeechTranslationConfig.fromSubscription(
        SPEECH__SUBSCRIPTION__KEY, SPEECH__SERVICE__REGION);
    
    String fromLanguage = "en-US";
    String[] toLanguages = { "it", "fr", "de" };
    speechTranslationConfig.setSpeechRecognitionLanguage(fromLanguage);
    for (String language : toLanguages) {
        speechTranslationConfig.addTargetLanguage(language);
    }

    AudioConfig audioConfig = AudioConfig.fromWavFileInput("YourAudioFile.wav");
    try (TranslationRecognizer translationRecognizer = new TranslationRecognizer(speechTranslationConfig, audioConfig)) {
        
    }
}

Konuşmayı çevirme

static void translateSpeech() throws ExecutionException, InterruptedException {
    SpeechTranslationConfig speechTranslationConfig = SpeechTranslationConfig.fromSubscription(
        SPEECH__SUBSCRIPTION__KEY, SPEECH__SERVICE__REGION);
    
    String fromLanguage = "en-US";
    String[] toLanguages = { "it", "fr", "de" };
    speechTranslationConfig.setSpeechRecognitionLanguage(fromLanguage);
    for (String language : toLanguages) {
        speechTranslationConfig.addTargetLanguage(language);
    }

    try (TranslationRecognizer translationRecognizer = new TranslationRecognizer(speechTranslationConfig)) {
        System.out.printf("Say something in '%s' and we'll translate...", fromLanguage);

        TranslationRecognitionResult translationRecognitionResult = translationRecognizer.recognizeOnceAsync().get();
        if (translationRecognitionResult.getReason() == ResultReason.TranslatedSpeech) {
            System.out.printf("Recognized: \"%s\"\n", translationRecognitionResult.getText());
            for (Map.Entry<String, String> pair : translationRecognitionResult.getTranslations().entrySet()) {
                System.out.printf("Translated into '%s': %s\n", pair.getKey(), pair.getValue());
            }
        }
    }
}

Konuşmayı metne dönüştürme hakkında daha fazla bilgi için bkz . Konuşma tanımanın temelleri.

Olay tabanlı çeviri

TranslationRecognizer nesnesi bir recognizing olayı açığa çıkarır. Olay birkaç kez tetiklenir ve ara çeviri sonuçlarını almak için bir mekanizma sunar.

Not

Çok dilli konuşma çevirisi kullandığınızda ara çeviri sonuçları kullanılamaz.

Aşağıdaki örnek ara çeviri sonuçlarını konsola yazdırır:

import com.microsoft.cognitiveservices.speech.*;
import com.microsoft.cognitiveservices.speech.audio.AudioConfig;
import com.microsoft.cognitiveservices.speech.translation.*;

import java.util.Map;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Semaphore;

public class TranslationContinuous {
    private static String SPEECH__SUBSCRIPTION__KEY = System.getenv("SPEECH__SUBSCRIPTION__KEY");
    private static String SPEECH__SERVICE__REGION = System.getenv("SPEECH__SERVICE__REGION");

    public static void main(String[] args) throws InterruptedException, ExecutionException {
        SpeechTranslationConfig speechTranslationConfig = SpeechTranslationConfig.fromSubscription(
            SPEECH__SUBSCRIPTION__KEY, SPEECH__SERVICE__REGION);

        String fromLanguage = "en-US";
        speechTranslationConfig.setSpeechRecognitionLanguage(fromLanguage);
        speechTranslationConfig.addTargetLanguage("de");
        speechTranslationConfig.addTargetLanguage("fr");

        AudioConfig audioConfig = AudioConfig.fromWavFileInput("YourAudioFile.wav");
        TranslationRecognizer translationRecognizer = new TranslationRecognizer(speechTranslationConfig, audioConfig);

        Semaphore stopTranslationSemaphore = new Semaphore(0);

        // Subscribes to events
        translationRecognizer.recognizing.addEventListener((s, e) -> {
            System.out.println("RECOGNIZING: Text=" + e.getResult().getText());
            for (Map.Entry<String, String> pair : e.getResult().getTranslations().entrySet()) {
                System.out.printf("    TRANSLATING into '%s': %s\n", pair.getKey(), pair.getValue());
            }
        });

        translationRecognizer.recognized.addEventListener((s, e) -> {
            if (e.getResult().getReason() == ResultReason.TranslatedSpeech) {
                System.out.println("RECOGNIZED: Text=" + e.getResult().getText());
                for (Map.Entry<String, String> pair : e.getResult().getTranslations().entrySet()) {
                    System.out.printf("    TRANSLATED into '%s': %s\n", pair.getKey(), pair.getValue());
                }
            } else if (e.getResult().getReason() == ResultReason.RecognizedSpeech) {
                System.out.println("RECOGNIZED: Text=" + e.getResult().getText());
                System.out.println("    Speech not translated.");
            } else if (e.getResult().getReason() == ResultReason.NoMatch) {
                System.out.println("NOMATCH: Speech could not be recognized.");
            }
        });

        translationRecognizer.canceled.addEventListener((s, e) -> {
            System.out.println("CANCELED: Reason=" + e.getReason());
            if (e.getReason() == CancellationReason.Error) {
                System.out.println("CANCELED: ErrorDetails=" + e.getErrorDetails());
            }
            stopTranslationSemaphore.release();
        });

        translationRecognizer.sessionStopped.addEventListener((s, e) -> {
            System.out.println("Session stopped.");
            stopTranslationSemaphore.release();
        });

        // Starts continuous recognition
        System.out.println("Start translation...");
        translationRecognizer.startContinuousRecognitionAsync().get();

        // Waits for completion
        stopTranslationSemaphore.acquire();

        // Stops translation
        translationRecognizer.stopContinuousRecognitionAsync().get();
    }
}

Çevirileri sentezle

Başarılı bir konuşma tanıma ve konuşma çevirisinin ardından, sonuç bir sözlükteki tüm çevirileri içerir. İşlev, getTranslations anahtarı hedef çeviri dili ve değeri çevrilmiş metin olarak içeren bir sözlük döndürür. Tanınan konuşma çevrilebilir ve daha sonra farklı bir dilde (konuşmadan konuşmaya) sentezlenebilir.

Olay tabanlı sentez

Bir setVoiceName örnek atayarak sentez sesini belirtin ve ses dosyasını almak için synthesizing olayını işlemek için bir olay işleyicisi sağlayın. Aşağıdaki örnek çevrilmiş sesi .wav dosyası olarak kaydeder.

Önemli

Olay tabanlı sentez yalnızca tek bir çeviriyle çalışır. Birden çok hedef çeviri dili eklemeyin. Ayrıca, değerin setVoiceName hedef çeviri diliyle aynı dil olması gerekir. Örneğin, "de", "de-DE-Hedda" ile eşlenebilir.

static void translateSpeech() throws ExecutionException, FileNotFoundException, InterruptedException, IOException {
    SpeechTranslationConfig speechTranslationConfig = SpeechTranslationConfig.fromSubscription(
        SPEECH__SUBSCRIPTION__KEY, SPEECH__SERVICE__REGION);

    String fromLanguage = "en-US";
    String toLanguage = "de";
    speechTranslationConfig.setSpeechRecognitionLanguage(fromLanguage);
    speechTranslationConfig.addTargetLanguage(toLanguage);

    // See: https://aka.ms/speech/sdkregion#standard-and-neural-voices
    speechTranslationConfig.setVoiceName("de-DE-Hedda");

    try (TranslationRecognizer translationRecognizer = new TranslationRecognizer(speechTranslationConfig)) {
        translationRecognizer.synthesizing.addEventListener((s, e) -> {
            byte[] audio = e.getResult().getAudio();
            int size = audio.length;
            System.out.println("Audio synthesized: " + size + " byte(s)" + (size == 0 ? "(COMPLETE)" : ""));

            if (size > 0) {
                try (FileOutputStream file = new FileOutputStream("translation.wav")) {
                    file.write(audio);
                } catch (IOException ex) {
                    ex.printStackTrace();
                }
            }
        });

        System.out.printf("Say something in '%s' and we'll translate...", fromLanguage);

        TranslationRecognitionResult translationRecognitionResult = translationRecognizer.recognizeOnceAsync().get();
        if (translationRecognitionResult.getReason() == ResultReason.TranslatedSpeech) {
            System.out.printf("Recognized: \"%s\"\n", translationRecognitionResult.getText());
            for (Map.Entry<String, String> pair : translationRecognitionResult.getTranslations().entrySet()) {
                String language = pair.getKey();
                String translation = pair.getValue();
                System.out.printf("Translated into '%s': %s\n", language, translation);
            }
        }
    }
}

El ile sentez

İşlev, getTranslations çeviri metninden ses sentezlemek için kullanabileceğiniz bir sözlük döndürür. Her çeviriyi yineleyip sentezler. Bir SpeechSynthesizer örneği oluştururken, SpeechConfig özelliği istenen sese ayarlanmış setSpeechSynthesisVoiceName nesnesine ihtiyaç vardır.

Aşağıdaki örnek beş dile çevrilir. Her çeviri daha sonra ilgili sinir dilinde bir ses dosyasına sentezlenmiş olur.

static void translateSpeech() throws ExecutionException, InterruptedException {
    SpeechTranslationConfig speechTranslationConfig = SpeechTranslationConfig.fromSubscription(
        SPEECH__SUBSCRIPTION__KEY, SPEECH__SERVICE__REGION);
    
    String fromLanguage = "en-US";
    String[] toLanguages = { "de", "en", "it", "pt", "zh-Hans" };
    speechTranslationConfig.setSpeechRecognitionLanguage(fromLanguage);
    for (String language : toLanguages) {
        speechTranslationConfig.addTargetLanguage(language);
    }

    try (TranslationRecognizer translationRecognizer = new TranslationRecognizer(speechTranslationConfig)) {
        System.out.printf("Say something in '%s' and we'll translate...", fromLanguage);

        TranslationRecognitionResult translationRecognitionResult = translationRecognizer.recognizeOnceAsync().get();
        if (translationRecognitionResult.getReason() == ResultReason.TranslatedSpeech) {
            // See: https://aka.ms/speech/sdkregion#standard-and-neural-voices
            Map<String, String> languageToVoiceMap = new HashMap<String, String>();
            languageToVoiceMap.put("de", "de-DE-KatjaNeural");
            languageToVoiceMap.put("en", "en-US-AriaNeural");
            languageToVoiceMap.put("it", "it-IT-ElsaNeural");
            languageToVoiceMap.put("pt", "pt-BR-FranciscaNeural");
            languageToVoiceMap.put("zh-Hans", "zh-CN-XiaoxiaoNeural");

            System.out.printf("Recognized: \"%s\"\n", translationRecognitionResult.getText());
            for (Map.Entry<String, String> pair : translationRecognitionResult.getTranslations().entrySet()) {
                String language = pair.getKey();
                String translation = pair.getValue();
                System.out.printf("Translated into '%s': %s\n", language, translation);

                SpeechConfig speechConfig =
                    SpeechConfig.fromSubscription(SPEECH__SUBSCRIPTION__KEY, SPEECH__SERVICE__REGION);
                speechConfig.setSpeechSynthesisVoiceName(languageToVoiceMap.get(language));

                AudioConfig audioConfig = AudioConfig.fromWavFileOutput(language + "-translation.wav");
                try (SpeechSynthesizer speechSynthesizer = new SpeechSynthesizer(speechConfig, audioConfig)) {
                    speechSynthesizer.SpeakTextAsync(translation).get();
                }
            }
        }
    }
}

Konuşma sentezi hakkında daha fazla bilgi için bkz . Konuşma sentezinin temelleri.

Dil belirleme ile çok dilli çeviri

Aşağıdaki örnek, en-US veya zh-CN'in, AutoDetectSourceLanguageConfig içinde tanımlandıkları için algılanması gerektiğini öngörmektedir. Daha sonra konuşma, de ve fr olarak, addTargetLanguage() öğesine yapılan çağrılarda belirtildiği gibi çevrilir.

speechTranslationConfig.addTargetLanguage("de");
speechTranslationConfig.addTargetLanguage("fr");
AutoDetectSourceLanguageConfig autoDetectSourceLanguageConfig = 
    AutoDetectSourceLanguageConfig.fromLanguages(Arrays.asList("en-US", "zh-CN"));
TranslationRecognizer translationRecognizer = 
    new TranslationRecognizer(speechTranslationConfig, autoDetectSourceLanguageConfig, audioConfig);

Eksiksiz bir kod örneği için bkz . dil belirleme.

Başvuru belgeleri | Paketi (NuGet) | GitHub'da ek örnekler

Bu nasıl yapılır kılavuzunda insan konuşmasını tanımayı ve başka bir dile çevirmeyi öğreneceksiniz.

Aşağıdakiler hakkında daha fazla bilgi için konuşma çevirisine genel bakış bölümüne bakın:

Konuşmayı metne çevirme
Konuşmayı birden çok hedef dile çevirme
Doğrudan konuşmadan konuşmaya çeviri gerçekleştirme

Hassas veriler ve ortam değişkenleri

Bu makaledeki örnek kaynak kodu, Konuşma kaynağının anahtarı ve bölgesi gibi hassas verileri depolamak için ortam değişkenlerine bağlıdır. C++ kod dosyası, konak makinenin ortam değişkenlerinden atanan iki dize değeri içerir: SPEECH__SUBSCRIPTION__KEY ve SPEECH__SERVICE__REGION. Bu alanların her ikisi de sınıf kapsamında olduğundan, sınıfın yöntem gövdeleri içinde erişilebilir:

auto SPEECH__SUBSCRIPTION__KEY = getenv("SPEECH__SUBSCRIPTION__KEY");
auto SPEECH__SERVICE__REGION = getenv("SPEECH__SERVICE__REGION");

Ortam değişkenleri hakkında daha fazla bilgi için bkz . Ortam değişkenleri ve uygulama yapılandırması.

Önemli

Yapay zeka hizmetleri güvenliği hakkında daha fazla bilgi için bkz . Azure AI hizmetlerine yönelik isteklerin kimliğini doğrulama.

Konuşma çevirisi yapılandırması oluşturma

İpucu

Konuşma tanıma, konuşma sentezi, çeviri veya amaç tanıma gerçekleştirmenize bakılmaksızın, her zaman bir yapılandırma oluşturursunuz.

SpeechTranslationConfig başlatmanın birkaç yolu vardır:

Abonelikle: anahtarı ve ilişkili bölgeyi geçirin.
Bir uç nokta belirleyerek: Konuşma hizmeti uç noktasını girin. Anahtar veya yetkilendirme belirteci isteğe bağlıdır.
Sunucu ile: bir sunucu adresi giriniz. Anahtar veya yetkilendirme belirteci isteğe bağlıdır.
Yetkilendirme belirteci ile: Yetkilendirme belirtecini ve ilişkili bölgeyi iletin.

Şimdi bir anahtar ve bölge kullanarak bir SpeechTranslationConfig örneği nasıl oluşturduğunuza bakalım. Azure portalında Konuşma kaynak anahtarını ve bölgesini alın.

auto SPEECH__SUBSCRIPTION__KEY = getenv("SPEECH__SUBSCRIPTION__KEY");
auto SPEECH__SERVICE__REGION = getenv("SPEECH__SERVICE__REGION");

void translateSpeech() {
    auto speechTranslationConfig =
        SpeechTranslationConfig::FromSubscription(SPEECH__SUBSCRIPTION__KEY, SPEECH__SERVICE__REGION);
}

int main(int argc, char** argv) {
    setlocale(LC_ALL, "");
    translateSpeech();
    return 0;
}

Kaynak dili değiştirme

Konuşma çevirisinin yaygın görevlerinden biri giriş (veya kaynak) dilini belirtmektir. Aşağıdaki örnekte giriş dilini İtalyanca olarak nasıl değiştirdiğiniz gösterilmektedir. Kodunuzda SpeechTranslationConfig örneği ile etkileşime geçmek için SetSpeechRecognitionLanguage yöntemini çağırın.

void translateSpeech() {
    auto speechTranslationConfig =
        SpeechTranslationConfig::FromSubscription(SPEECH__SUBSCRIPTION__KEY, SPEECH__SERVICE__REGION);

    // Source (input) language
    speechTranslationConfig->SetSpeechRecognitionLanguage("it-IT");
}

SpeechRecognitionLanguage özelliği bir dil-yerel ayar biçim dizesi bekler. Desteklenen konuşma çevirisi yerel ayarlarının listesine bakın.

Çeviri dili ekleme

void translateSpeech() {
    auto speechTranslationConfig =
        SpeechTranslationConfig::FromSubscription(SPEECH__SUBSCRIPTION__KEY, SPEECH__SERVICE__REGION);

    speechTranslationConfig->SetSpeechRecognitionLanguage("it-IT");

    speechTranslationConfig->AddTargetLanguage("fr");
    speechTranslationConfig->AddTargetLanguage("de");
}

Çeviri tanıyıcıyı başlatma

Bir SpeechTranslationConfig örneği oluşturduktan sonra, sonraki adım TranslationRecognizer'i başlatmaktır. TranslationRecognizer başlattığınızda, translationConfig örneğinizi geçirmeniz gerekir. Yapılandırma nesnesi, Konuşma hizmetinin isteğinizi doğrulamak için gerektirdiği kimlik bilgilerini sağlar.

Eğer konuşmayı cihazınızın varsayılan mikrofonunu kullanarak TranslationRecognizer tanıyorsanız, aşağıdaki gibi görünmelidir:

void translateSpeech() {
    auto speechTranslationConfig =
        SpeechTranslationConfig::FromSubscription(SPEECH__SUBSCRIPTION__KEY, SPEECH__SERVICE__REGION);

    auto fromLanguage = "en-US";
    auto toLanguages = { "it", "fr", "de" };
    speechTranslationConfig->SetSpeechRecognitionLanguage(fromLanguage);
    for (auto language : toLanguages) {
        speechTranslationConfig->AddTargetLanguage(language);
    }

    auto translationRecognizer = TranslationRecognizer::FromConfig(speechTranslationConfig);
}

Ses giriş cihazını belirtmek istiyorsanız, bir AudioConfig sınıf örneği oluşturmanız ve başlatılırken audioConfig parametresini TranslationRecognizer sağlamanız gerekir.

İpucu

Ses giriş cihazınızın cihaz kimliğini nasıl alacağınızı öğrenin.

İlk olarak, AudioConfig nesnesine aşağıdaki şekilde başvurun:

void translateSpeech() {
    auto speechTranslationConfig =
        SpeechTranslationConfig::FromSubscription(SPEECH__SUBSCRIPTION__KEY, SPEECH__SERVICE__REGION);

    auto fromLanguage = "en-US";
    auto toLanguages = { "it", "fr", "de" };
    speechTranslationConfig->SetSpeechRecognitionLanguage(fromLanguage);
    for (auto language : toLanguages) {
        speechTranslationConfig->AddTargetLanguage(language);
    }

    auto audioConfig = AudioConfig::FromDefaultMicrophoneInput();
    auto translationRecognizer = TranslationRecognizer::FromConfig(speechTranslationConfig, audioConfig);
}

Mikrofon kullanmak yerine ses dosyası sağlamak istiyorsanız yine de bir audioConfig parametre sağlamanız gerekir. Ancak, bir AudioConfig sınıf örneği oluşturduğunuzda, FromDefaultMicrophoneInput yerine FromWavFileInput çağırır ve filename parametresini geçirirsiniz.

void translateSpeech() {
    auto speechTranslationConfig =
        SpeechTranslationConfig::FromSubscription(SPEECH__SUBSCRIPTION__KEY, SPEECH__SERVICE__REGION);

    auto fromLanguage = "en-US";
    auto toLanguages = { "it", "fr", "de" };
    speechTranslationConfig->SetSpeechRecognitionLanguage(fromLanguage);
    for (auto language : toLanguages) {
        speechTranslationConfig->AddTargetLanguage(language);
    }

    auto audioConfig = AudioConfig::FromWavFileInput("YourAudioFile.wav");
    auto translationRecognizer = TranslationRecognizer::FromConfig(speechTranslationConfig, audioConfig);
}

Konuşmayı çevirme

void translateSpeech() {
    auto speechTranslationConfig =
        SpeechTranslationConfig::FromSubscription(SPEECH__SUBSCRIPTION__KEY, SPEECH__SERVICE__REGION);

    string fromLanguage = "en-US";
    string toLanguages[3] = { "it", "fr", "de" };
    speechTranslationConfig->SetSpeechRecognitionLanguage(fromLanguage);
    for (auto language : toLanguages) {
        speechTranslationConfig->AddTargetLanguage(language);
    }

    auto translationRecognizer = TranslationRecognizer::FromConfig(speechTranslationConfig);
    cout << "Say something in '" << fromLanguage << "' and we'll translate...\n";

    auto result = translationRecognizer->RecognizeOnceAsync().get();
    if (result->Reason == ResultReason::TranslatedSpeech)
    {
        cout << "Recognized: \"" << result->Text << "\"" << std::endl;
        for (auto pair : result->Translations)
        {
            auto language = pair.first;
            auto translation = pair.second;
            cout << "Translated into '" << language << "': " << translation << std::endl;
        }
    }
}

Konuşmayı metne dönüştürme hakkında daha fazla bilgi için bkz . Konuşma tanımanın temelleri.

Olay tabanlı çeviri

TranslationRecognizer nesnesi bir Recognizing olayı açığa çıkarır. Olay birkaç kez tetiklenir ve ara çeviri sonuçlarını almak için bir mekanizma sunar.

Not

Çok dilli konuşma çevirisi kullandığınızda ara çeviri sonuçları kullanılamaz.

Aşağıdaki örnek ara çeviri sonuçlarını konsola yazdırır:

void translateSpeechContinuous() {
    auto speechTranslationConfig =
        SpeechTranslationConfig::FromSubscription(SPEECH__SUBSCRIPTION__KEY, SPEECH__SERVICE__REGION);

    auto fromLanguage = "en-US";
    auto toLanguage = "de";
    speechTranslationConfig->SetSpeechRecognitionLanguage(fromLanguage);
    speechTranslationConfig->AddTargetLanguage(toLanguage);

    auto audioConfig = AudioConfig::FromWavFileInput("whatstheweatherlike.wav");
    auto translationRecognizer = TranslationRecognizer::FromConfig(speechTranslationConfig, audioConfig);

    // Promise for synchronization of recognition end.
    promise<void> recognitionEnd;

    // Subscribes to events.
    translationRecognizer->Recognizing.Connect([&fromLanguage](const TranslationRecognitionEventArgs& e) {
        cout << "RECOGNIZING in '" << fromLanguage << "': Text=" << e.Result->Text << std::endl;
        for (const auto& pair : e.Result->Translations) {
            cout << "    TRANSLATING into '" << pair.first << "': " << pair.second << std::endl;
        }
    });

    translationRecognizer->Recognized.Connect([&fromLanguage](const TranslationRecognitionEventArgs& e) {
        if (e.Result->Reason == ResultReason::TranslatedSpeech) {
            cout << "RECOGNIZED in '" << fromLanguage << "': Text=" << e.Result->Text << std::endl;
            for (const auto& pair : e.Result->Translations) {
                cout << "    TRANSLATED into '" << pair.first << "': " << pair.second << std::endl;
            }
        }
        else if (e.Result->Reason == ResultReason::RecognizedSpeech) {
            cout << "RECOGNIZED: Text=" << e.Result->Text << std::endl;
            cout << "    Speech not translated." << std::endl;
        }
        else if (e.Result->Reason == ResultReason::NoMatch) {
            cout << "NOMATCH: Speech could not be recognized." << std::endl;
        }
    });

    translationRecognizer->Canceled.Connect([&recognitionEnd](const TranslationRecognitionCanceledEventArgs& e) {
        cout << "CANCELED: Reason=" << (int)e.Reason << std::endl;
        if (e.Reason == CancellationReason::Error) {
            cout << "CANCELED: ErrorDetails=" << e.ErrorDetails << std::endl;
        }
        recognitionEnd.set_value();
    });

    translationRecognizer->SessionStopped.Connect([&recognitionEnd](const SessionEventArgs& e) {
        cout << "SESSION STOPPED" << std::endl;
        recognitionEnd.set_value();
    });

    // Start continuous recognition
    cout << "Start translation..." << std::endl;
    translationRecognizer->StartContinuousRecognitionAsync().get();

    // Wait for completion
    recognitionEnd.get_future().get();

    // Stop recognition
    translationRecognizer->StopContinuousRecognitionAsync().get();
}

Çevirileri sentezle

Olay tabanlı sentez

Bir SetVoiceName örnek atayarak sentez sesini belirtin ve ses dosyasını almak için Synthesizing olayını işlemek için bir olay işleyicisi sağlayın. Aşağıdaki örnek çevrilmiş sesi .wav dosyası olarak kaydeder.

Önemli

Olay tabanlı sentez yalnızca tek bir çeviriyle çalışır. Birden çok hedef çeviri dili eklemeyin. Ayrıca, değerin SetVoiceName hedef çeviri diliyle aynı dil olması gerekir. Örneğin, "de", "de-DE-Hedda" ile eşlenebilir.

void translateSpeech() {
    auto speechTranslationConfig =
        SpeechTranslationConfig::FromSubscription(SPEECH__SUBSCRIPTION__KEY, SPEECH__SERVICE__REGION);

    auto fromLanguage = "en-US";
    auto toLanguage = "de";
    speechTranslationConfig->SetSpeechRecognitionLanguage(fromLanguage);
    speechTranslationConfig->AddTargetLanguage(toLanguage);

    speechTranslationConfig->SetVoiceName("de-DE-Hedda");

    auto translationRecognizer = TranslationRecognizer::FromConfig(speechTranslationConfig);
    translationRecognizer->Synthesizing.Connect([](const TranslationSynthesisEventArgs& e)
        {
            auto audio = e.Result->Audio;
            auto size = audio.size();
            cout << "Audio synthesized: " << size << " byte(s)" << (size == 0 ? "(COMPLETE)" : "") << std::endl;

            if (size > 0) {
                ofstream file("translation.wav", ios::out | ios::binary);
                auto audioData = audio.data();
                file.write((const char*)audioData, sizeof(audio[0]) * size);
                file.close();
            }
        });

    cout << "Say something in '" << fromLanguage << "' and we'll translate...\n";

    auto result = translationRecognizer->RecognizeOnceAsync().get();
    if (result->Reason == ResultReason::TranslatedSpeech)
    {
        cout << "Recognized: \"" << result->Text << "\"" << std::endl;
        for (auto pair : result->Translations)
        {
            auto language = pair.first;
            auto translation = pair.second;
            cout << "Translated into '" << language << "': " << translation << std::endl;
        }
    }
}

El ile sentez

Çeviri metninden Translations ses sentezlemek için sözlüğü kullanabilirsiniz. Her çeviriyi yineleyip sentezler. Bir SpeechSynthesizer örneği oluştururken, SpeechConfig özelliği istenen sese ayarlanmış SetSpeechSynthesisVoiceName nesnesine ihtiyaç vardır.

Aşağıdaki örnek beş dile çevrilir. Her çeviri daha sonra ilgili sinir dilinde bir ses dosyasına sentezlenmiş olur.

void translateSpeech() {
    auto speechTranslationConfig =
        SpeechTranslationConfig::FromSubscription(SPEECH__SUBSCRIPTION__KEY, SPEECH__SERVICE__REGION);

    auto fromLanguage = "en-US";
    auto toLanguages = { "de", "en", "it", "pt", "zh-Hans" };
    speechTranslationConfig->SetSpeechRecognitionLanguage(fromLanguage);
    for (auto language : toLanguages) {
        speechTranslationConfig->AddTargetLanguage(language);
    }

    auto translationRecognizer = TranslationRecognizer::FromConfig(speechTranslationConfig);

    cout << "Say something in '" << fromLanguage << "' and we'll translate...\n";

    auto result = translationRecognizer->RecognizeOnceAsync().get();
    if (result->Reason == ResultReason::TranslatedSpeech)
    {
        map<string, string> languageToVoiceMap;
        languageToVoiceMap["de"] = "de-DE-KatjaNeural";
        languageToVoiceMap["en"] = "en-US-AriaNeural";
        languageToVoiceMap["it"] = "it-IT-ElsaNeural";
        languageToVoiceMap["pt"] = "pt-BR-FranciscaNeural";
        languageToVoiceMap["zh-Hans"] = "zh-CN-XiaoxiaoNeural";

        cout << "Recognized: \"" << result->Text << "\"" << std::endl;
        for (auto pair : result->Translations)
        {
            auto language = pair.first;
            auto translation = pair.second;
            cout << "Translated into '" << language << "': " << translation << std::endl;

            auto speechConfig =
                SpeechConfig::FromSubscription(SPEECH__SUBSCRIPTION__KEY, SPEECH__SERVICE__REGION);
            speechConfig->SetSpeechSynthesisVoiceName(languageToVoiceMap[language]);

            auto audioConfig = AudioConfig::FromWavFileOutput(language + "-translation.wav");
            auto speechSynthesizer = SpeechSynthesizer::FromConfig(speechConfig, audioConfig);

            speechSynthesizer->SpeakTextAsync(translation).get();
        }
    }
}

Konuşma sentezi hakkında daha fazla bilgi için bkz . Konuşma sentezinin temelleri.

Dil belirleme ile çok dilli çeviri

Aşağıdaki örnek, en-US veya zh-CN'in, AutoDetectSourceLanguageConfig içinde tanımlandıkları için algılanması gerektiğini öngörmektedir. Daha sonra konuşma, de öğesine yapılan çağrılarda belirtildiği şekilde fr ve AddTargetLanguage() öğelerine çevrilecektir.

speechTranslationConfig->AddTargetLanguage("de");
speechTranslationConfig->AddTargetLanguage("fr");
auto autoDetectSourceLanguageConfig = AutoDetectSourceLanguageConfig::FromLanguages({ "en-US", "zh-CN" });
auto translationRecognizer = TranslationRecognizer::FromConfig(speechTranslationConfig, autoDetectSourceLanguageConfig, audioConfig);

Eksiksiz bir kod örneği için bkz . dil belirleme.

Başvuru belgeleri | Paketi (Go) | GitHub'da ek örnekler

Bu nasıl yapılır kılavuzunda insan konuşmasını tanımayı ve başka bir dile çevirmeyi öğreneceksiniz.

Aşağıdakiler hakkında daha fazla bilgi için konuşma çevirisine genel bakış bölümüne bakın:

Konuşmayı metne çevirme
Konuşmayı birden çok hedef dile çevirme
Doğrudan konuşmadan konuşmaya çeviri gerçekleştirme

Hassas veriler ve ortam değişkenleri

Bu makaledeki örnek kaynak kodu, Konuşma kaynağının anahtarı ve bölgesi gibi hassas verileri depolamak için ortam değişkenlerine bağlıdır. Go kod dosyası, konak makinenin ortam değişkenlerinden atanan iki değer içerir: SPEECH_KEY ve SPEECH_REGION. Bu değişkenlerin her ikisi de paket kapsamında olduğundan paketin işlevlerinden erişilebilir:

speechKey := os.Getenv("SPEECH_KEY")
speechRegion := os.Getenv("SPEECH_REGION")

Ortam değişkenleri hakkında daha fazla bilgi için bkz . Ortam değişkenleri ve uygulama yapılandırması.

Önemli

Yapay zeka hizmetleri güvenliği hakkında daha fazla bilgi için bkz . Azure AI hizmetlerine yönelik isteklerin kimliğini doğrulama.

Konuşma çevirisi yapılandırması oluşturma

İpucu

Konuşma tanıma, konuşma sentezi, çeviri veya amaç tanıma gerçekleştirmenize bakılmaksızın, her zaman bir yapılandırma oluşturursunuz.

Bir SpeechTranslationConfig örneğini birkaç şekilde başlatabilirsiniz.

Abonelikle: anahtarı ve ilişkili bölgeyi geçirin.
Bir uç nokta belirleyerek: Konuşma hizmeti uç noktasını girin. Anahtar veya yetkilendirme belirteci isteğe bağlıdır.
Sunucu ile: bir sunucu adresi giriniz. Anahtar veya yetkilendirme belirteci isteğe bağlıdır.
Yetkilendirme belirteci ile: Yetkilendirme belirtecini ve ilişkili bölgeyi iletin.

Anahtar ve bölge kullanarak nasıl bir SpeechTranslationConfig örneği oluşturabileceğinize bakalım. Azure portalında Konuşma kaynak anahtarını ve bölgesini alın.

import (
    "fmt"
    "os"

    "github.com/Microsoft/cognitive-services-speech-sdk-go/audio"
    "github.com/Microsoft/cognitive-services-speech-sdk-go/speech"
)

func translateSpeech() {
    speechKey := os.Getenv("SPEECH_KEY")
    speechRegion := os.Getenv("SPEECH_REGION")

    translationConfig, err := speech.NewSpeechTranslationConfigFromSubscription(speechKey, speechRegion)
    if err != nil {
        fmt.Println("Error creating translation config:", err)
        return
    }
    defer translationConfig.Close()
}

Kaynak dili değiştirme

Konuşma çevirisinin yaygın görevlerinden biri giriş (veya kaynak) dilini belirtmektir. Aşağıdaki örnekte giriş dilini İtalyanca olarak nasıl değiştirdiğiniz gösterilmektedir. Kodunuzda SpeechTranslationConfig örneğiyle, SetSpeechRecognitionLanguage yöntemini çağırarak etkileşim kurun.

func translateSpeech() {
    speechKey := os.Getenv("SPEECH_KEY")
    speechRegion := os.Getenv("SPEECH_REGION")

    translationConfig, err := speech.NewSpeechTranslationConfigFromSubscription(speechKey, speechRegion)
    if err != nil {
        fmt.Println("Error creating translation config:", err)
        return
    }
    defer translationConfig.Close()

    // Source (input) language
    translationConfig.SetSpeechRecognitionLanguage("it-IT")
}

SetSpeechRecognitionLanguage yöntemi bir dil yerel ayar biçimi dizesi bekler. Desteklenen konuşma çevirisi yerel ayarlarının listesine bakın.

Çeviri dili ekleme

func translateSpeech() {
    speechKey := os.Getenv("SPEECH_KEY")
    speechRegion := os.Getenv("SPEECH_REGION")

    translationConfig, err := speech.NewSpeechTranslationConfigFromSubscription(speechKey, speechRegion)
    if err != nil {
        fmt.Println("Error creating translation config:", err)
        return
    }
    defer translationConfig.Close()

    translationConfig.SetSpeechRecognitionLanguage("it-IT")

    // Translate to languages. See https://aka.ms/speech/sttt-languages
    translationConfig.AddTargetLanguage("fr")
    translationConfig.AddTargetLanguage("de")
}

Çeviri tanıyıcıyı başlatma

Bir SpeechTranslationConfig örnek oluşturduktan sonra, sonraki adım TranslationRecognizer'i başlatmaktır. TranslationRecognizer başlattığınızda, translationConfig örneğinizi geçirmeniz gerekir. Yapılandırma nesnesi, Konuşma hizmetinin isteğinizi doğrulamak için gerektirdiği kimlik bilgilerini sağlar.

Eğer konuşmayı cihazınızın varsayılan mikrofonunu kullanarak TranslationRecognizer tanıyorsanız, aşağıdaki gibi görünmelidir:

func translateSpeech() {
    speechKey := os.Getenv("SPEECH_KEY")
    speechRegion := os.Getenv("SPEECH_REGION")

    translationConfig, err := speech.NewSpeechTranslationConfigFromSubscription(speechKey, speechRegion)
    if err != nil {
        fmt.Println("Error creating translation config:", err)
        return
    }
    defer translationConfig.Close()

    fromLanguage := "en-US"
    toLanguages := []string{"it", "fr", "de"}

    translationConfig.SetSpeechRecognitionLanguage(fromLanguage)
    for _, language := range toLanguages {
        translationConfig.AddTargetLanguage(language)
    }

    audioConfig, err := audio.NewAudioConfigFromDefaultMicrophoneInput()
    if err != nil {
        fmt.Println("Error creating audio config:", err)
        return
    }
    defer audioConfig.Close()

    translationRecognizer, err := speech.NewTranslationRecognizerFromConfig(translationConfig, audioConfig)
    if err != nil {
        fmt.Println("Error creating translation recognizer:", err)
        return
    }
    defer translationRecognizer.Close()
}

Mikrofon kullanmak yerine ses dosyası sağlamak istiyorsanız yine de bir audioConfig parametre sağlamanız gerekir. Ancak, bir AudioConfig örneği oluşturduğunuzda, NewAudioConfigFromDefaultMicrophoneInput yerine NewAudioConfigFromWavFileInput öğesini çağırıp dosya adını geçirirsiniz.

audioConfig, err := audio.NewAudioConfigFromWavFileInput("YourAudioFile.wav")
if err != nil {
    fmt.Println("Error creating audio config:", err)
    return
}
defer audioConfig.Close()

Konuşmayı çevirme

package main

import (
    "fmt"
    "os"

    "github.com/Microsoft/cognitive-services-speech-sdk-go/audio"
    "github.com/Microsoft/cognitive-services-speech-sdk-go/speech"
)

func main() {
    speechKey := os.Getenv("SPEECH_KEY")
    speechRegion := os.Getenv("SPEECH_REGION")

    translationConfig, err := speech.NewSpeechTranslationConfigFromSubscription(speechKey, speechRegion)
    if err != nil {
        fmt.Println("Error creating translation config:", err)
        return
    }
    defer translationConfig.Close()

    fromLanguage := "en-US"
    toLanguages := []string{"it", "fr", "de"}

    translationConfig.SetSpeechRecognitionLanguage(fromLanguage)
    for _, language := range toLanguages {
        translationConfig.AddTargetLanguage(language)
    }

    audioConfig, err := audio.NewAudioConfigFromDefaultMicrophoneInput()
    if err != nil {
        fmt.Println("Error creating audio config:", err)
        return
    }
    defer audioConfig.Close()

    translationRecognizer, err := speech.NewTranslationRecognizerFromConfig(translationConfig, audioConfig)
    if err != nil {
        fmt.Println("Error creating translation recognizer:", err)
        return
    }
    defer translationRecognizer.Close()

    fmt.Printf("Say something in '%s' and we'll translate...\n", fromLanguage)

    outcome := <-translationRecognizer.RecognizeOnceAsync()
    if outcome.Error != nil {
        fmt.Println("Recognition error:", outcome.Error)
        return
    }

    result := outcome.Result
    defer result.Close()

    translations := result.GetTranslations()
    fmt.Printf("Recognized: \"%s\"\n", result.Text)
    for lang, translation := range translations {
        fmt.Printf("Translated into '%s': %s\n", lang, translation)
    }
}

Konuşmayı metne dönüştürme hakkında daha fazla bilgi için bkz . Konuşma tanımanın temelleri.

Olay tabanlı çeviri

Önceki örnek, tek bir konuşmayı çeviren tek seferlik çeviriyi kullanır. Uzun süre çalışan oturumlar için olay tabanlı çeviri de kullanabilirsiniz. Olay tabanlı çeviri, çeviri sonuçlarını almak için olaylara abone olmanız gerekir.

Not

Çok dilli konuşma çevirisi kullandığınızda ara çeviri sonuçları kullanılamaz.

Aşağıdaki örnekte olay tabanlı çevirinin nasıl kullanılacağı gösterilmektedir:

package main

import (
    "bufio"
    "fmt"
    "os"

    "github.com/Microsoft/cognitive-services-speech-sdk-go/audio"
    "github.com/Microsoft/cognitive-services-speech-sdk-go/speech"
)

func main() {
    speechKey := os.Getenv("SPEECH_KEY")
    speechRegion := os.Getenv("SPEECH_REGION")

    translationConfig, err := speech.NewSpeechTranslationConfigFromSubscription(speechKey, speechRegion)
    if err != nil {
        fmt.Println("Error creating translation config:", err)
        return
    }
    defer translationConfig.Close()

    fromLanguage := "en-US"
    toLanguages := []string{"de", "fr"}

    translationConfig.SetSpeechRecognitionLanguage(fromLanguage)
    for _, language := range toLanguages {
        translationConfig.AddTargetLanguage(language)
    }

    audioConfig, err := audio.NewAudioConfigFromDefaultMicrophoneInput()
    if err != nil {
        fmt.Println("Error creating audio config:", err)
        return
    }
    defer audioConfig.Close()

    translationRecognizer, err := speech.NewTranslationRecognizerFromConfig(translationConfig, audioConfig)
    if err != nil {
        fmt.Println("Error creating translation recognizer:", err)
        return
    }
    defer translationRecognizer.Close()

    // Subscribe to events
    translationRecognizer.Recognizing(func(event speech.TranslationRecognitionEventArgs) {
        fmt.Printf("RECOGNIZING: %s\n", event.Result.Text)
    })

    translationRecognizer.Recognized(func(event speech.TranslationRecognitionEventArgs) {
        if event.Result.Reason == speech.ResultReason.TranslatedSpeech {
            fmt.Printf("RECOGNIZED: %s\n", event.Result.Text)
            for lang, translation := range event.Result.GetTranslations() {
                fmt.Printf("TRANSLATED into '%s': %s\n", lang, translation)
            }
        }
    })

    translationRecognizer.Canceled(func(event speech.TranslationRecognitionCanceledEventArgs) {
        fmt.Printf("CANCELED: Reason=%d\n", event.Reason)
        if event.Reason == speech.CancellationReason.Error {
            fmt.Printf("CANCELED: ErrorDetails=%s\n", event.ErrorDetails)
        }
    })

    translationRecognizer.SessionStopped(func(event speech.SessionEventArgs) {
        fmt.Println("Session stopped.")
    })

    // Start continuous recognition
    err = <-translationRecognizer.StartContinuousRecognitionAsync()
    if err != nil {
        fmt.Println("Error starting continuous recognition:", err)
        return
    }

    fmt.Println("Event based translation started. Press Enter to stop...")
    bufio.NewReader(os.Stdin).ReadBytes('\n')

    // Stop continuous recognition
    err = <-translationRecognizer.StopContinuousRecognitionAsync()
    if err != nil {
        fmt.Println("Error stopping continuous recognition:", err)
        return
    }
}

Çevirileri sentezle

Başarılı bir konuşma tanıma ve çeviriden sonra, sonuç bir haritadaki tüm çevirileri içerir. GetTranslations() yöntemi, anahtar olarak hedef çeviri dilini ve değer olarak çevrilmiş metni içeren bir harita döndürür. Tanınan konuşma çevrilebilir ve daha sonra farklı bir dilde (konuşmadan konuşmaya) sentezlenebilir.

Olay tabanlı sentez

TranslationRecognizer nesnesi Synthesizing geri çağırma işlevini sağlar. Olay birkaç kez gerçekleşir ve çeviri tanıma sonucundan sentezlenmiş sesi almak için bir yöntem sunar. Birden çok dile çeviri yapıyorsanız, bkz. El ile sentezleme.

Yapılandırmada SetVoiceName yöntemini çağırarak sentez sesini belirtin ve ses almak için Synthesizing olayına bir geri çağırma işlevi sağlayın. Aşağıdaki örnek çevrilmiş sesi .wav dosyası olarak kaydeder.

Önemli

package main

import (
    "fmt"
    "os"

    "github.com/Microsoft/cognitive-services-speech-sdk-go/audio"
    "github.com/Microsoft/cognitive-services-speech-sdk-go/speech"
)

func main() {
    speechKey := os.Getenv("SPEECH_KEY")
    speechRegion := os.Getenv("SPEECH_REGION")

    translationConfig, err := speech.NewSpeechTranslationConfigFromSubscription(speechKey, speechRegion)
    if err != nil {
        fmt.Println("Error creating translation config:", err)
        return
    }
    defer translationConfig.Close()

    fromLanguage := "en-US"
    toLanguage := "de"

    translationConfig.SetSpeechRecognitionLanguage(fromLanguage)
    translationConfig.AddTargetLanguage(toLanguage)

    // See: https://aka.ms/speech/sdkregion#standard-and-neural-voices
    translationConfig.SetVoiceName("de-DE-Hedda")

    audioConfig, err := audio.NewAudioConfigFromDefaultMicrophoneInput()
    if err != nil {
        fmt.Println("Error creating audio config:", err)
        return
    }
    defer audioConfig.Close()

    translationRecognizer, err := speech.NewTranslationRecognizerFromConfig(translationConfig, audioConfig)
    if err != nil {
        fmt.Println("Error creating translation recognizer:", err)
        return
    }
    defer translationRecognizer.Close()

    translationRecognizer.Synthesizing(func(event speech.TranslationSynthesisEventArgs) {
        audioData := event.Result.GetAudio()
        size := len(audioData)
        fmt.Printf("Audio synthesized: %d byte(s) %s\n", size, map[bool]string{true: "(COMPLETE)", false: ""}[size == 0])

        if size > 0 {
            file, err := os.Create("translation.wav")
            if err != nil {
                fmt.Println("Error creating file:", err)
                return
            }
            defer file.Close()
            file.Write(audioData)
        }
    })

    fmt.Printf("Say something in '%s' and we'll translate to '%s'...\n", fromLanguage, toLanguage)

    outcome := <-translationRecognizer.RecognizeOnceAsync()
    if outcome.Error != nil {
        fmt.Println("Recognition error:", outcome.Error)
        return
    }

    result := outcome.Result
    defer result.Close()

    if result.Reason == speech.ResultReason.TranslatedSpeech {
        fmt.Printf("Recognized: \"%s\"\n", result.Text)
        translations := result.GetTranslations()
        fmt.Printf("Translated into '%s': %s\n", toLanguage, translations[toLanguage])
    }
}

El ile sentez

Çeviri metninden ses sentezlemek için çeviri eşlemesini kullanabilirsiniz. Her çeviriyi yineleyip sentezler. Bir SpeechSynthesizer örneği oluştururken, SpeechConfig nesnesinin SetSpeechSynthesisVoiceName yöntemi istenen sesle çağrılmalıdır.

Aşağıdaki örnek beş dile çevrilir. Her çeviri daha sonra ilgili sinir dilinde bir ses dosyasına sentezlenmiş olur.

package main

import (
    "fmt"
    "os"

    "github.com/Microsoft/cognitive-services-speech-sdk-go/audio"
    "github.com/Microsoft/cognitive-services-speech-sdk-go/speech"
)

func main() {
    speechKey := os.Getenv("SPEECH_KEY")
    speechRegion := os.Getenv("SPEECH_REGION")

    translationConfig, err := speech.NewSpeechTranslationConfigFromSubscription(speechKey, speechRegion)
    if err != nil {
        fmt.Println("Error creating translation config:", err)
        return
    }
    defer translationConfig.Close()

    fromLanguage := "en-US"
    toLanguages := []string{"de", "fr", "it", "pt", "zh-Hans"}

    translationConfig.SetSpeechRecognitionLanguage(fromLanguage)
    for _, language := range toLanguages {
        translationConfig.AddTargetLanguage(language)
    }

    audioConfig, err := audio.NewAudioConfigFromDefaultMicrophoneInput()
    if err != nil {
        fmt.Println("Error creating audio config:", err)
        return
    }
    defer audioConfig.Close()

    translationRecognizer, err := speech.NewTranslationRecognizerFromConfig(translationConfig, audioConfig)
    if err != nil {
        fmt.Println("Error creating translation recognizer:", err)
        return
    }
    defer translationRecognizer.Close()

    fmt.Println("Say something...")

    outcome := <-translationRecognizer.RecognizeOnceAsync()
    if outcome.Error != nil {
        fmt.Println("Recognition error:", outcome.Error)
        return
    }

    result := outcome.Result
    defer result.Close()

    if result.Reason == speech.ResultReason.TranslatedSpeech {
        languageToVoiceMap := map[string]string{
            "de":      "de-DE-KatjaNeural",
            "fr":      "fr-FR-DeniseNeural",
            "it":      "it-IT-ElsaNeural",
            "pt":      "pt-BR-FranciscaNeural",
            "zh-Hans": "zh-CN-XiaoxiaoNeural",
        }

        fmt.Printf("Recognized: \"%s\"\n", result.Text)
        translations := result.GetTranslations()

        for language, translation := range translations {
            fmt.Printf("Translated into '%s': %s\n", language, translation)

            speechConfig, err := speech.NewSpeechConfigFromSubscription(speechKey, speechRegion)
            if err != nil {
                fmt.Println("Error creating speech config:", err)
                continue
            }

            speechConfig.SetSpeechSynthesisVoiceName(languageToVoiceMap[language])

            outputFile := fmt.Sprintf("%s-translation.wav", language)
            audioOutput, err := audio.NewAudioConfigFromWavFileOutput(outputFile)
            if err != nil {
                fmt.Println("Error creating audio output config:", err)
                speechConfig.Close()
                continue
            }

            synthesizer, err := speech.NewSpeechSynthesizerFromConfig(speechConfig, audioOutput)
            if err != nil {
                fmt.Println("Error creating synthesizer:", err)
                audioOutput.Close()
                speechConfig.Close()
                continue
            }

            <-synthesizer.SpeakTextAsync(translation)

            synthesizer.Close()
            audioOutput.Close()
            speechConfig.Close()
        }
    }
}

Konuşma sentezi hakkında daha fazla bilgi için bkz . Konuşma sentezinin temelleri.

Dil belirleme ile çok dilli çeviri

translationConfig.AddTargetLanguage("de")
translationConfig.AddTargetLanguage("fr")
autoDetectSourceLanguageConfig, err := speech.NewAutoDetectSourceLanguageConfigFromLanguages([]string{"en-US", "zh-CN"})
if err != nil {
    fmt.Println("Error creating auto detect config:", err)
    return
}
defer autoDetectSourceLanguageConfig.Close()

translationRecognizer, err := speech.NewTranslationRecognizerFromAutoDetectSourceLangConfig(translationConfig, autoDetectSourceLanguageConfig, audioConfig)

Eksiksiz bir kod örneği için bkz . dil belirleme.

Kaynakları temizle

Oluşturduğunuz Konuşma kaynağını kaldırmak için Azure portalını veya Azure Komut Satırı Arabirimi'ni (CLI) kullanabilirsiniz.

Başvuru belgeleri | Paketi (indirme) | GitHub'da ek örnekler

Availability

Objective-C için Konuşma SDK'sı konuşma çevirisini destekler, ancak buraya henüz bir kılavuz eklemedik. Başlamak ve kavramlar hakkında bilgi edinmek için lütfen başka bir programlama dili seçin veya bu makalenin başındaki Objective-C başvurusuna ve bağlantılı örneklere bakın.

Bu nasıl yapılır kılavuzunda insan konuşmasını tanımayı ve başka bir dile çevirmeyi öğreneceksiniz.

Aşağıdakiler hakkında daha fazla bilgi için konuşma çevirisine genel bakış bölümüne bakın:

Konuşmayı metne çevirme
Konuşmayı birden çok hedef dile çevirme
Doğrudan konuşmadan konuşmaya çeviri gerçekleştirme

Önkoşullar

Azure aboneliği. Ücretsiz bir tane oluşturabilirsiniz.
Azure portalında Konuşma için bir Dökümhane kaynağı oluşturun.
Konuşma kaynak anahtarını ve bölgesini alın. Konuşma kaynağınız dağıtıldıktan sonra anahtarları görüntülemek ve yönetmek için Kaynağa git'i seçin.

İndirme ve kurma

Bu adımları izleyin ve platformunuzun diğer gereksinimleri için Konuşma CLI'sı hızlı başlangıcına bakın.

Konuşma CLI'sını yüklemek için aşağıdaki .NET CLI komutunu çalıştırın:
```
dotnet tool install --global Microsoft.CognitiveServices.Speech.CLI
```
Konuşma kaynak anahtarınızı ve bölgenizi yapılandırmak için aşağıdaki komutları çalıştırın. SUBSCRIPTION-KEY Konuşma kaynak anahtarınızla ve REGION Konuşma kaynağı bölgenizle değiştirin.
- Terminal
- PowerShell
```
spx config @key --set SUBSCRIPTION-KEY
spx config @region --set REGION
```
```
spx --% config @key --set SUBSCRIPTION-KEY
spx --% config @region --set REGION
```

Kaynak ve hedef dilleri ayarlama

Bu komut, konuşmayı mikrofondan İtalyancadan Fransızcaya çevirmek için Konuşma CLI'sini çağırır:

spx translate --microphone --source it-IT --target fr

Başvuru belgeleri | Paketi (indirme) | GitHub'da ek örnekler

Availability

Swift için Konuşma SDK'sı konuşma çevirisini destekler, ancak buraya henüz bir kılavuz eklemedik. Başlamak ve kavramlar hakkında bilgi edinmek için lütfen başka bir programlama dili seçin veya bu makalenin başından itibaren bağlantılı Swift başvurusuna ve örneklerine bakın.

Sonraki adımlar

Geri Bildirim

Bu sayfayı yararlı buldunuz mu?

Last updated on 2026-03-31