Comment reconnaître et traduire la parole

Article
09/20/2024

Documentation de référence | Package (NuGet) | Exemples supplémentaires sur GitHub

Dans ce guide pratique, vous allez apprendre à reconnaître les paroles humaines et à les traduire dans une autre langue.

Consultez la Vue d’ensemble de la traduction vocale pour plus d’informations sur :

Traduction de la parole en texte
Traduction de la parole en plusieurs langues cibles
Réalisation d’une traduction directe de la parole en parole

Données sensibles et variables d’environnement

L’exemple de code source de cet article dépend de variables d’environnement pour le stockage des données sensibles, par exemple la clé et la région des ressources Speech. La classe Program contient deux valeurs static readonly string qui sont affectées à partir des variables d’environnement des ordinateurs hôtes : SPEECH__SUBSCRIPTION__KEY et SPEECH__SERVICE__REGION. Ces deux champs ayant pour portée la classe, ils sont accessibles dans le corps des méthodes de la classe :

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

    static Task Main() => Task.CompletedTask;
}

Pour plus d’informations sur les variables d’environnement, consultez Variables d’environnement et configuration de l’application.

Important

Si vous utilisez une clé API, stockez-la en toute sécurité dans un autre emplacement, par exemple dans Azure Key Vault. N'incluez pas la clé API directement dans votre code et ne la diffusez jamais publiquement.

Pour plus d’informations sur la sécurité des services IA, consultez Authentifier les requêtes auprès des Azure AI services.

Création d’une configuration de traduction vocale

Pour appeler le service Speech à l’aide du SDK Speech, vous devez créer une instance SpeechTranslationConfig. Celle-ci comprend des informations sur votre abonnement, telles que votre clé et la région, le point de terminaison, l’hôte ou le jeton d’autorisation associés.

Conseil

Quand vous procédez à une reconnaissance vocale, une synthèse vocale, une traduction ou une reconnaissance intentionnelle, vous devez toujours créer une configuration.

Vous pouvez initialiser SpeechTranslationConfig de plusieurs façons :

Avec un abonnement : transmettez une clé et la région associée.
Avec un point de terminaison : transmettez un point de terminaison de service Speech. Une clé ou un jeton d’autorisation est facultatif.
Avec un hôte : transmettez une adresse d’hôte. Une clé ou un jeton d’autorisation est facultatif.
Avec un jeton d’autorisation : transmettez un jeton d’autorisation et la région associée.

Voyons comment créer une instance SpeechTranslationConfig à l’aide d’une clé et d’une région. Obtenez la clé et la région de la ressource Speech sur le portail Azure.

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

    static Task Main() => TranslateSpeechAsync();

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

Changer la langue source

L’une des tâches courantes de la traduction vocale consiste à spécifier la langue d’entrée (ou source). L’exemple suivant montre comment définir la langue d’entrée sur l’italien. Dans votre code, interagissez avec l’instance SpeechTranslationConfig en l’affectant à la propriété SpeechRecognitionLanguage :

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

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

La propriété SpeechRecognitionLanguage attend une chaîne au format langue-paramètres régionaux. Reportez-vous à la liste des paramètres régionaux de traduction vocale pris en charge.

Ajouter une langue de traduction

Une autre tâche courante de la traduction vocale consiste à spécifier les langues de traduction cibles. Au moins une langue est requise, même s’il est possible d’en spécifier plusieurs. Dans l’extrait de code suivant, le français et l’allemand sont définis comme langues de traduction cibles.

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

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

À chaque appel à AddTargetLanguage, une nouvelle langue de traduction cible est spécifiée. En d’autres termes, lorsqu’un message est reconnu dans la langue source, chaque traduction cible est disponible dans le cadre de l’opération de traduction qui en résulte.

Initialisation d’un moteur de reconnaissance de traduction

Une fois que vous avez créé une instance SpeechTranslationConfig, l’étape suivante consiste à initialiser TranslationRecognizer. Lorsque vous initialisez TranslationRecognizer, vous devez lui transmettre votre instance speechTranslationConfig. L’objet de configuration fournit les informations d’identification dont le service Speech a besoin pour valider la demande.

Si vous effectuez une reconnaissance vocale en utilisant le microphone par défaut de votre appareil, voici à quoi doit ressembler l’instance TranslationRecognizer :

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

Si vous souhaitez spécifier le périphérique d’entrée audio, vous devez créer une instance de classe AudioConfig et fournir le paramètre audioConfig lors de l’initialisation de TranslationRecognizer.

Conseil

Découvrez comment obtenir l’ID de votre périphérique d’entrée audio.

Commencez par référencer l’objet AudioConfig comme suit :

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

Si vous souhaitez fournir un fichier audio au lieu d’utiliser un microphone, vous devez quand même fournir un paramètre audioConfig. Toutefois, quand vous créez une instance de classe AudioConfig, au lieu d’appeler FromDefaultMicrophoneInput, vous appelez FromWavFileInput et transmettrez le paramètre filename :

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

Traduction vocale

Pour effectuer une traduction vocale, le kit SDK Speech utilise un microphone ou une entrée de type fichier audio. La reconnaissance vocale se produit avant la traduction vocale. Une fois que tous les objets sont initialisés, appelez la fonction recognize_once et récupérez le résultat :

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

Pour plus d’informations sur la conversion de parole en texte, consultez les notions de base sur la reconnaissance vocale.

Traduction basée sur les événements

L’objet TranslationRecognizer expose un événement Recognizing. L’événement se déclenche plusieurs fois et fournit un mécanisme permettant de récupérer les résultats intermédiaires de la traduction.

Remarque

Les résultats de la traduction intermédiaire ne sont pas disponibles lorsque vous utilisez traduction vocale multilocataire.

L’exemple suivant imprime les résultats de la traduction intermédiaire dans la console :

using (var audioInput = AudioConfig.FromWavFileInput(@"whatstheweatherlike.wav"))
{
    using (var translationRecognizer = new TranslationRecognizer(config, 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.");
            }
        };

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

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

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

Synthèse des traductions

À l’issue d’une reconnaissance et d’une traduction vocales, le résultat contient toutes les traductions dans un dictionnaire. La clé de dictionnaire Translations correspond à la langue de traduction cible et la valeur au texte traduit. Le texte obtenu après reconnaissance vocale peut être traduit, puis synthétisé dans une autre langue (conversion de la parole en parole).

Synthèse basée sur les événements

L’objet TranslationRecognizer expose un événement Synthesizing. Celui-ci se déclenche plusieurs fois et fournit un mécanisme permettant de récupérer les données audio synthétisées à partir du résultat de la reconnaissance de traduction. Si vous effectuez une traduction dans plusieurs langues, consultez Synthèse manuelle.

Spécifiez la voix de synthèse en affectant une instance VoiceName, puis fournissez un gestionnaire d’événements pour l’événement Synthesizing pour récupérer l’audio. L’exemple suivant enregistre l’audio traduit sous la forme d’un fichier . wav.

Important

La synthèse basée sur les événements fonctionne uniquement avec une seule traduction. N’ajoutez pas plusieurs langues de traduction cibles. En outre, la valeur VoiceName doit être identique à la langue de traduction cible. Par exemple, "de" peut être associé à "de-DE-Hedda".

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]}");
    }
}

Synthèse manuelle

Vous pouvez utiliser le dictionnaire Translations pour synthétiser l’audio à partir du texte de traduction. Itérez au sein des différentes traductions pour les synthétiser. Lors de la création d’une instance SpeechSynthesizer, la propriété SpeechSynthesisVoiceName de l’objet SpeechConfig doit être définie sur la voix souhaitée.

L’exemple suivant est traduit dans cinq langues. Chaque traduction est ensuite synthétisée dans un fichier audio dans le langage neuronal correspondant.

static async Task TranslateSpeechAsync()
{
    var speechTranslationConfig =
        SpeechTranslationConfig.FromSubscription(SPEECH__SERVICE__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__SERVICE__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);
        }
    }
}

Pour plus d’informations sur la synthèse vocale, consultez Informations de base sur la synthèse vocale.

Traduction multilingue avec identification de la langue

Dans de nombreux scénarios, il se peut que vous ne sachiez pas quelles langues d’entrée spécifier. Grâce à l’identification de la langue, vous pouvez détecter jusqu’à dix langues d’entrée possibles et traduire automatiquement dans vos langues cibles.

L’exemple suivant prévoit que en-US ou zh-CN doit être détecté, car ils sont définis dans AutoDetectSourceLanguageConfig. Ensuite, le message est traduit en de et fr comme indiqué dans les appels à AddTargetLanguage().

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

Pour obtenir un exemple de code complet, consultez Identification de la langue.

Traduction vocale multilingue sans candidats à la langue source

La traduction vocale multilingue met en œuvre un nouveau niveau de technologie de traduction vocale qui débloque diverses capacités, notamment l’absence de langue d’entrée spécifiée et la gestion des changements de langue au cours d’une même session. Ces fonctionnalités permettent d’atteindre un nouveau niveau de puissance de traduction vocale qui peut être mis en œuvre dans vos produits.

Actuellement, lorsque vous utilisez l’ID de langue avec la traduction vocale, vous devez créer l’objet SpeechTranslationConfig à partir du point de terminaison v2. Remplacez la chaîne « YourServiceRegion » par votre région de ressource Speech (par exemple, « westus »). Remplacez « YourSubscriptionKey » par votre clé de ressource Speech.

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

Spécifiez les langues cibles de traduction. Remplacez par les langues de votre choix. Vous pouvez en ajouter d’autres lignes.

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

Un différentiateur clé avec la traduction vocale multilingue est que vous n’avez pas besoin de spécifier la langue source. Cela est dû au fait que le service détecte automatiquement la langue source. Créez l’objet AutoDetectSourceLanguageConfig avec la méthode fromOpenRange pour informer le service que vous souhaitez utiliser la traduction vocale multilingue sans langue source spécifiée.

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

Pour obtenir un exemple de code complet avec le Kit de développement logiciel (SDK) Speech, consultez exemples de traduction vocale sur GitHub.

Utilisation de la traduction personnalisée dans la traduction vocale

La fonctionnalité de traduction personnalisée de la traduction vocale s’intègre parfaitement au service de traduction personnalisée Azure, ce qui vous permet d’obtenir des traductions plus précises et mieux adaptées. Comme l’intégration exploite directement les fonctionnalités du service de traduction personnalisée Azure, vous devez utiliser une ressource multiservice pour garantir le bon fonctionnement de l’ensemble des fonctionnalités. Pour des instructions détaillées, veuillez consulter le guide sur Créer une ressource multiservice pour les services Azure AI.

En outre, pour la formation hors connexion d’un traducteur personnalisé et l’obtention d’un « ID de catégorie », veuillez vous référer au script étape par étape fourni dans le Guide de démarrage rapide : Générer, déployer et utiliser un modèle personnalisé – Traducteur personnalisé.

// 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"

try (SpeechTranslationConfig config = SpeechTranslationConfig.fromEndpoint(URI.create(endpointUrl), speechSubscriptionKey)) {

            // Sets source and target language(s).
           ….

            // Set the category id
            config.setCustomModelCategoryId("yourCategoryId");

       ….
}

Documentation de référence | Package (NuGet) | Exemples supplémentaires sur GitHub

Dans ce guide pratique, vous allez apprendre à reconnaître les paroles humaines et à les traduire dans une autre langue.

Consultez la Vue d’ensemble de la traduction vocale pour plus d’informations sur :

Traduction de la parole en texte
Traduction de la parole en plusieurs langues cibles
Réalisation d’une traduction directe de la parole en parole

Données sensibles et variables d’environnement

L’exemple de code source de cet article dépend de variables d’environnement pour le stockage des données sensibles, par exemple la clé et la région des ressources Speech. Le fichier de code C++ contient deux valeurs de chaîne qui sont affectées à partir des variables d’environnement des ordinateurs hôtes : SPEECH__SUBSCRIPTION__KEY et SPEECH__SERVICE__REGION. Ces deux champs ayant pour portée la classe, ils sont accessibles dans le corps des méthodes de la classe :

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

Pour plus d’informations sur les variables d’environnement, consultez Variables d’environnement et configuration de l’application.

Important

Pour plus d’informations sur la sécurité des services IA, consultez Authentifier les requêtes auprès des Azure AI services.

Création d’une configuration de traduction vocale

Conseil

Quand vous procédez à une reconnaissance vocale, une synthèse vocale, une traduction ou une reconnaissance intentionnelle, vous devez toujours créer une configuration.

Vous pouvez initialiser SpeechTranslationConfig de plusieurs façons :

Avec un abonnement : transmettez une clé et la région associée.
Avec un point de terminaison : transmettez un point de terminaison de service Speech. Une clé ou un jeton d’autorisation est facultatif.
Avec un hôte : transmettez une adresse d’hôte. Une clé ou un jeton d’autorisation est facultatif.
Avec un jeton d’autorisation : transmettez un jeton d’autorisation et la région associée.

Voyons comment créer une instance SpeechTranslationConfig à l’aide d’une clé et d’une région. Obtenez la clé et la région de la ressource Speech sur le portail Azure.

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

Changer la langue source

L’une des tâches courantes de la traduction vocale consiste à spécifier la langue d’entrée (ou source). L’exemple suivant montre comment définir la langue d’entrée sur l’italien. Dans votre code, interagissez avec l’instance SpeechTranslationConfig en appelant la méthode SetSpeechRecognitionLanguage.

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

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

La propriété SpeechRecognitionLanguage attend une chaîne au format langue-paramètres régionaux. Reportez-vous à la liste des paramètres régionaux de traduction vocale pris en charge.

Ajouter une langue de traduction

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

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

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

Initialisation d’un moteur de reconnaissance de traduction

Une fois que vous avez créé une instance SpeechTranslationConfig, l’étape suivante consiste à initialiser TranslationRecognizer. Lorsque vous initialisez TranslationRecognizer, vous devez lui transmettre votre instance translationConfig. L’objet de configuration fournit les informations d’identification dont le service Speech a besoin pour valider la demande.

Si vous effectuez une reconnaissance vocale en utilisant le microphone par défaut de votre appareil, voici à quoi doit ressembler l’instance TranslationRecognizer :

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

Conseil

Découvrez comment obtenir l’ID de votre périphérique d’entrée audio.

Commencez par référencer l’objet AudioConfig comme suit :

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

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

Traduction vocale

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

Pour plus d’informations sur la conversion de parole en texte, consultez les notions de base sur la reconnaissance vocale.

Synthèse des traductions

Synthèse basée sur les événements

Spécifiez la voix de synthèse en affectant une instance SetVoiceName, puis fournissez un gestionnaire d’événements pour l’événement Synthesizing pour récupérer l’audio. L’exemple suivant enregistre l’audio traduit sous la forme d’un fichier . wav.

Important

La synthèse basée sur les événements fonctionne uniquement avec une seule traduction. N’ajoutez pas plusieurs langues de traduction cibles. En outre, la valeur SetVoiceName doit être identique à la langue de traduction cible. Par exemple, "de" peut être associé à "de-DE-Hedda".

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

Synthèse manuelle

Vous pouvez utiliser le dictionnaire Translations pour synthétiser l’audio à partir du texte de traduction. Itérez au sein des différentes traductions pour les synthétiser. Lors de la création d’une instance SpeechSynthesizer, la propriété SetSpeechSynthesisVoiceName de l’objet SpeechConfig doit être définie sur la voix souhaitée.

L’exemple suivant est traduit dans cinq langues. Chaque traduction est ensuite synthétisée dans un fichier audio dans le langage neuronal correspondant.

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

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

Pour plus d’informations sur la synthèse vocale, consultez Informations de base sur la synthèse vocale.

Traduction multilingue avec identification de la langue

L’exemple suivant prévoit que en-US ou zh-CN doit être détecté, car ils sont définis dans AutoDetectSourceLanguageConfig. Ensuite, le message sera traduit en de et fr comme indiqué dans les appels à AddTargetLanguage().

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

Pour obtenir un exemple de code complet, consultez Identification de la langue.

Documentation de référence | Package (Go) | Exemples supplémentaires sur GitHub

Le SDK Speech pour Go ne prend pas en charge la traduction vocale. Sélectionnez un autre langage de programmation, ou la référence Go et des exemples liés au début de cet article.

Documentation de référence | Exemples supplémentaires sur GitHub

Dans ce guide pratique, vous allez apprendre à reconnaître les paroles humaines et à les traduire dans une autre langue.

Consultez la Vue d’ensemble de la traduction vocale pour plus d’informations sur :

Traduction de la parole en texte
Traduction de la parole en plusieurs langues cibles
Réalisation d’une traduction directe de la parole en parole

Données sensibles et variables d’environnement

L’exemple de code source de cet article dépend de variables d’environnement pour le stockage des données sensibles, par exemple la clé et la région des ressources Speech. Le fichier de code Java contient deux valeurs static final String qui sont affectées à partir des variables d’environnement des ordinateurs hôtes : SPEECH__SUBSCRIPTION__KEY et SPEECH__SERVICE__REGION. Ces deux champs ayant pour portée la classe, ils sont accessibles dans le corps des méthodes de la classe :

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) { }
}

Pour plus d’informations sur les variables d’environnement, consultez Variables d’environnement et configuration de l’application.

Important

Pour plus d’informations sur la sécurité des services IA, consultez Authentifier les requêtes auprès des Azure AI services.

Création d’une configuration de traduction vocale

Conseil

Quand vous procédez à une reconnaissance vocale, une synthèse vocale, une traduction ou une reconnaissance intentionnelle, vous devez toujours créer une configuration.

Vous pouvez initialiser une instance SpeechTranslationConfig de plusieurs façons :

Avec un abonnement : transmettez une clé et la région associée.
Avec un point de terminaison : transmettez un point de terminaison de service Speech. Une clé ou un jeton d’autorisation est facultatif.
Avec un hôte : transmettez une adresse d’hôte. Une clé ou un jeton d’autorisation est facultatif.
Avec un jeton d’autorisation : transmettez un jeton d’autorisation et la région associée.

Voyons comment créer une instance SpeechTranslationConfig à l’aide d’une clé et d’une région. Obtenez la clé et la région de la ressource Speech sur le portail Azure.

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

Changer la langue source

L’une des tâches courantes de la traduction vocale consiste à spécifier la langue d’entrée (ou source). L’exemple suivant montre comment définir la langue d’entrée sur l’italien. Dans votre code, interagissez avec l’instance SpeechTranslationConfig en appelant la méthode setSpeechRecognitionLanguage :

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

La fonction setSpeechRecognitionLanguage attend une chaîne au format langue-paramètres régionaux. Reportez-vous à la liste des paramètres régionaux de traduction vocale pris en charge.

Ajouter une langue de traduction

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

À chaque appel à addTargetLanguage, une nouvelle langue de traduction cible est spécifiée. En d’autres termes, lorsqu’un message est reconnu dans la langue source, chaque traduction cible est disponible dans le cadre de l’opération de traduction qui en résulte.

Initialisation d’un moteur de reconnaissance de traduction

Si vous effectuez une reconnaissance vocale en utilisant le microphone par défaut de votre appareil, voici à quoi doit ressembler l’instance TranslationRecognizer :

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)) {
    }
}

Conseil

Découvrez comment obtenir l’ID de votre périphérique d’entrée audio.

Commencez par référencer l’objet AudioConfig comme suit :

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)) {
        
    }
}

Si vous souhaitez fournir un fichier audio au lieu d’utiliser un microphone, vous devez quand même fournir un paramètre audioConfig. Toutefois, quand vous créez une instance de classe AudioConfig, au lieu d’appeler fromDefaultMicrophoneInput, vous appelez fromWavFileInput et transmettrez le paramètre filename :

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)) {
        
    }
}

Traduction vocale

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

Pour plus d’informations sur la conversion de parole en texte, consultez les notions de base sur la reconnaissance vocale.

Synthèse des traductions

À l’issue d’une reconnaissance et d’une traduction vocales, le résultat contient toutes les traductions dans un dictionnaire. La fonction getTranslations retourne un dictionnaire dont la clé correspond à la langue de traduction cible et la valeur au texte traduit. Le texte obtenu après reconnaissance vocale peut être traduit, puis synthétisé dans une autre langue (conversion de la parole en parole).

Synthèse basée sur les événements

L’objet TranslationRecognizer expose un événement synthesizing. Celui-ci se déclenche plusieurs fois et fournit un mécanisme permettant de récupérer les données audio synthétisées à partir du résultat de la reconnaissance de traduction. Si vous effectuez une traduction dans plusieurs langues, consultez Synthèse manuelle.

Spécifiez la voix de synthèse en affectant une instance setVoiceName, puis fournissez un gestionnaire d’événements pour l’événement synthesizing pour récupérer l’audio. L’exemple suivant enregistre l’audio traduit sous la forme d’un fichier . wav.

Important

La synthèse basée sur les événements fonctionne uniquement avec une seule traduction. N’ajoutez pas plusieurs langues de traduction cibles. En outre, la valeur setVoiceName doit être identique à la langue de traduction cible. Par exemple, "de" peut être associé à "de-DE-Hedda".

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

Synthèse manuelle

La fonction getTranslations retourne un dictionnaire qui peut être utilisé pour synthétiser l’audio à partir du texte de traduction. Itérez au sein des différentes traductions pour les synthétiser. Lors de la création d’une instance SpeechSynthesizer, la propriété setSpeechSynthesisVoiceName de l’objet SpeechConfig doit être définie sur la voix souhaitée.

L’exemple suivant est traduit dans cinq langues. Chaque traduction est ensuite synthétisée dans un fichier audio dans le langage neuronal correspondant.

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

Pour plus d’informations sur la synthèse vocale, consultez Informations de base sur la synthèse vocale.

Documentation de référence | Package (npm) | Exemples supplémentaires sur GitHub | Code source de la bibliothèque

Dans ce guide pratique, vous allez apprendre à reconnaître les paroles humaines et à les traduire dans une autre langue.

Consultez la Vue d’ensemble de la traduction vocale pour plus d’informations sur :

Traduction de la parole en texte
Traduction de la parole en plusieurs langues cibles
Réalisation d’une traduction directe de la parole en parole

Créer une configuration de traduction

Pour appeler le service de traduction à l’aide du Kit SDK Speech, vous devez créer une instance SpeechTranslationConfig. Celle-ci comprend des informations sur votre abonnement, telles que votre clé et la région, le point de terminaison, l’hôte ou le jeton d’autorisation associés.

Notes

Quand vous procédez à une reconnaissance vocale, une synthèse vocale, une traduction ou une reconnaissance intentionnelle, vous devez toujours créer une configuration.

Vous pouvez initialiser SpeechTranslationConfig de plusieurs façons :

Avec un abonnement : transmettez une clé et la région associée.
Avec un point de terminaison : transmettez un point de terminaison de service Speech. Une clé ou un jeton d’autorisation est facultatif.
Avec un hôte : transmettez une adresse d’hôte. Une clé ou un jeton d’autorisation est facultatif.
Avec un jeton d’autorisation : transmettez un jeton d’autorisation et la région associée.

Voyons comment créer une instance SpeechTranslationConfig à l’aide d’une clé et d’une région. Obtenez la clé et la région de la ressource Speech sur le portail Azure.

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

Initialiser un traducteur

Si vous traduisez une entrée vocale obtenue via le microphone par défaut de votre appareil, voici à quoi doit ressembler TranslationRecognizer :

const translationRecognizer = new TranslationRecognizer(speechTranslationConfig);

Conseil

Découvrez comment obtenir l’ID de votre périphérique d’entrée audio.

Référencez l’objet AudioConfig comme suit :

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

Si vous souhaitez fournir un fichier audio au lieu d’utiliser un microphone, vous devez quand même fournir un paramètre audioConfig. Toutefois, vous ne pouvez le faire que lorsque vous ciblez Node.js. Quand vous créez une instance de classe AudioConfig, au lieu d’appeler fromDefaultMicrophoneInput, vous appelez fromWavFileOutput et transmettrez le paramètre filename :

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

Traduction vocale

La classe TranslationRecognizer pour le Kit SDK Speech pour JavaScript expose les méthodes que vous pouvez utiliser pour la traduction vocale :

Traduction unique (asynchrone) : effectue la traduction en mode sans blocage (asynchrone). Cette méthode permet de traduire un énoncé unique. Elle détermine la fin d’un énoncé unique par la détection du silence à la fin, ou après que 15 secondes d’audio ont été traitées.
Traduction continue (asynchrone) : lance de façon asynchrone une opération de traduction continue. L’utilisateur s’inscrit à des événements et gère divers états d’application. Pour arrêter la traduction continue asynchrone, appelez stopContinuousRecognitionAsync.

Pour en savoir plus sur la façon de choisir un mode de reconnaissance vocale, consultez l’article Prise en main de la reconnaissance vocale.

Spécifier une langue cible

Pour traduire, vous devez spécifier une langue source et au moins une langue cible.

Vous pouvez choisir une langue source à l’aide des paramètres régionaux indiqués dans la Table de traduction vocale. Recherchez dans le même lien vos options de langue cible de traduction.

Vos options pour les langues cibles diffèrent lorsque vous souhaitez afficher du texte ou entendre la traduction synthétisée. Pour traduire de l’anglais en allemand, modifiez l’objet de configuration de traduction :

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

Reconnaissance unique

Voici un exemple de traduction unique asynchrone via recognizeOnceAsync :

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

Vous devrez écrire du code pour gérer le résultat. Cet exemple évalue result.reason pour une traduction en allemand :

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

Votre code peut également gérer les mises à jour fournies pendant le traitement de la traduction. Vous pouvez utiliser ces mises à jour pour fournir un retour visuel sur la progression de la traduction. Cet exemple de Node.js JavaScript illustre ces types de mises à jour. Le code suivant affiche également les détails générés pendant le processus de traduction :

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

Traduction continue

La traduction continue est un peu plus complexe que la reconnaissance unique. Pour obtenir les résultats de la reconnaissance, vous devez vous abonner aux événements recognizing, recognized et canceled. Pour arrêter la traduction, vous devez appeler stopContinuousRecognitionAsync.

Voici un exemple de traduction continue sur un fichier d’entrée audio. Commençons par définir l’entrée et initialiser TranslationRecognizer :

const translationRecognizer = new TranslationRecognizer(speechTranslationConfig);

Dans le code suivant, vous vous abonnez aux événements envoyés depuis TranslationRecognizer :

recognizing : signal pour les événements contenant des résultats de traduction intermédiaires.
recognized : signal pour les événements contenant des résultats de traduction finalisés. Ces résultats indiquent une tentative de traduction réussie.
sessionStopped : signal pour les événements indiquant la fin d’une session (opération) de traduction.
canceled : signal pour les événements contenant des résultats de traduction annulés. Ces événements indiquent une tentative de traduction qui a été annulée à la suite d’une annulation directe. Ils peuvent également indiquer un échec de transport ou de protocole.

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

Tout étant configuré, vous pouvez appeler startContinuousRecognitionAsync :

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

Choisir une langue source

Une des tâches courantes de la traduction vocale consiste à spécifier la langue d’entrée (ou source). L’exemple suivant montre comment définir la langue d’entrée sur l’italien. Dans votre code, recherchez votre instance SpeechTranslationConfig, puis ajoutez la ligne suivante directement en dessous :

speechTranslationConfig.speechRecognitionLanguage = "it-IT";

La propriété speechRecognitionLanguage attend une chaîne au format langue-paramètres régionaux. Reportez-vous à la liste des paramètres régionaux de traduction vocale pris en charge.

Choisir une ou plusieurs langues cibles

Le kit SDK Speech peut traduire en parallèle vers plusieurs langues cibles. Les langues cibles disponibles diffèrent légèrement de la liste de langues sources. Vous spécifiez les langues cibles à l’aide d’un code de langue, plutôt que de paramètres régionaux.

Pour accéder à la liste des codes de langue pour les cibles de texte, consultez la table de traduction vocale dans la page de prise en charge des langues. Vous pouvez également y trouver des détails sur la traduction dans des langues synthétisées.

Le code suivant ajoute l’allemand comme langue cible :

speechTranslationConfig.addTargetLanguage("de");

Étant donné que des traductions vers plusieurs langues cibles sont possibles, votre code doit spécifier la langue cible lors de l’examen du résultat. Le code suivant obtient des résultats de traduction pour l’allemand :

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

Documentation de référence | Package (téléchargement) | Exemples supplémentaires sur GitHub

Le SDK Speech pour Objective-C prend en charge la traduction vocale, mais nous n’avons pas encore inclus de guide ici. Sélectionnez un autre langage de programmation pour commencer et découvrir les concepts, ou consultez les informations de référence sur Objective-C et les exemples liés au début de cet article.

Documentation de référence | Package (téléchargement) | Exemples supplémentaires sur GitHub

Le SDK Speech pour Swift prend en charge la traduction vocale, mais nous n’avons pas encore inclus de guide ici. Sélectionnez un autre langage de programmation pour commencer et découvrir les concepts, ou consultez les informations de référence sur Swift et les exemples liés au début de cet article.

Documentation de référence | Package (PyPi) | Exemples supplémentaires sur GitHub

Dans ce guide pratique, vous allez apprendre à reconnaître les paroles humaines et à les traduire dans une autre langue.

Consultez la Vue d’ensemble de la traduction vocale pour plus d’informations sur :

Traduction de la parole en texte
Traduction de la parole en plusieurs langues cibles
Réalisation d’une traduction directe de la parole en parole

Données sensibles et variables d’environnement

L’exemple de code source de cet article dépend de variables d’environnement pour le stockage des données sensibles, par exemple la clé et la région d’abonnement de la ressource Speech. Le fichier de code Python contient deux valeurs qui sont affectées à partir des variables d’environnement des ordinateurs hôtes : SPEECH__SUBSCRIPTION__KEY et SPEECH__SERVICE__REGION. Ces deux variables ayant une portée globale, elles sont accessibles dans la définition de fonction du fichier de code :

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

Pour plus d’informations sur les variables d’environnement, consultez Variables d’environnement et configuration de l’application.

Important

Pour plus d’informations sur la sécurité des services IA, consultez Authentifier les requêtes auprès des Azure AI services.

Création d’une configuration de traduction vocale

Conseil

Quand vous procédez à une reconnaissance vocale, une synthèse vocale, une traduction ou une reconnaissance intentionnelle, vous devez toujours créer une configuration.

Vous pouvez initialiser SpeechTranslationConfig de plusieurs façons :

Avec un abonnement : transmettez une clé et la région associée.
Avec un point de terminaison : transmettez un point de terminaison de service Speech. Une clé ou un jeton d’autorisation est facultatif.
Avec un hôte : transmettez une adresse d’hôte. Une clé ou un jeton d’autorisation est facultatif.
Avec un jeton d’autorisation : transmettez un jeton d’autorisation et la région associée.

Voyons comment créer une instance SpeechTranslationConfig à l’aide d’une clé et d’une région. Obtenez la clé et la région de la ressource Speech sur le portail Azure.

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

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

Changer la langue source

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

La propriété speech_recognition_language attend une chaîne au format langue-paramètres régionaux. Reportez-vous à la liste des paramètres régionaux de traduction vocale pris en charge.

Ajouter une langue de traduction

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")

À chaque appel à add_target_language, une nouvelle langue de traduction cible est spécifiée. En d’autres termes, lorsqu’un message est reconnu dans la langue source, chaque traduction cible est disponible dans le cadre de l’opération de traduction qui en résulte.

Initialisation d’un moteur de reconnaissance de traduction

Une fois que vous avez créé une instance SpeechTranslationConfig, l’étape suivante consiste à initialiser TranslationRecognizer. Lorsque vous initialisez TranslationRecognizer, vous devez lui transmettre votre instance translation_config. L’objet de configuration fournit les informations d’identification dont le service Speech a besoin pour valider la demande.

Si vous effectuez une reconnaissance vocale en utilisant le microphone par défaut de votre appareil, voici à quoi doit ressembler l’instance TranslationRecognizer :

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)

Si vous souhaitez spécifier le périphérique d’entrée audio, vous devez créer une instance de classe AudioConfig et fournir le paramètre audio_config lors de l’initialisation de TranslationRecognizer.

Conseil

Découvrez comment obtenir l’ID de votre périphérique d’entrée audio.

Commencez par référencer l’objet AudioConfig comme suit :

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)

Si vous souhaitez fournir un fichier audio au lieu d’utiliser un microphone, vous devez quand même fournir un paramètre audioConfig. Toutefois, quand vous créez une instance de classe AudioConfig, au lieu d’appeler use_default_microphone=True, vous appelez filename="path-to-file.wav" et fournissez le paramètre filename :

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)

Traduction vocale

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

Pour plus d’informations sur la conversion de parole en texte, consultez les notions de base sur la reconnaissance vocale.

Synthèse des traductions

À l’issue d’une reconnaissance et d’une traduction vocales, le résultat contient toutes les traductions dans un dictionnaire. La clé de dictionnaire translations correspond à la langue de traduction cible et la valeur au texte traduit. Le texte obtenu après reconnaissance vocale peut être traduit, puis synthétisé dans une autre langue (conversion de la parole en parole).

Synthèse basée sur les événements

Spécifiez la voix de synthèse en affectant une instance voice_name, puis fournissez un gestionnaire d’événements pour l’événement Synthesizing pour récupérer l’audio. L’exemple suivant enregistre l’audio traduit sous la forme d’un fichier . wav.

Important

La synthèse basée sur les événements fonctionne uniquement avec une seule traduction. N’ajoutez pas plusieurs langues de traduction cibles. En outre, la valeur voice_name doit être identique à la langue de traduction cible. Par exemple, "de" peut être associé à "de-DE-Hedda".

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

Synthèse manuelle

Vous pouvez utiliser le dictionnaire translations pour synthétiser l’audio à partir du texte de traduction. Itérez au sein des différentes traductions pour les synthétiser. Lors de la création d’une instance SpeechSynthesizer, la propriété speech_synthesis_voice_name de l’objet SpeechConfig doit être définie sur la voix souhaitée.

L’exemple suivant est traduit dans cinq langues. Chaque traduction est ensuite synthétisée dans un fichier audio dans le langage neuronal correspondant.

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

Pour plus d’informations sur la synthèse vocale, consultez Informations de base sur la synthèse vocale.

Traduction multilingue avec identification de la langue

Pour obtenir un exemple de code complet, consultez Identification de la langue.

Informations de référence sur l’API REST de reconnaissance vocale | Informations de référence sur l’API REST de reconnaissance vocale pour l’audio court | Exemples supplémentaires sur GitHub

Vous pouvez utiliser l’API REST pour la traduction vocale, mais nous n’avons pas encore inclus de guide ici. Sélectionnez un autre langage de programmation pour commencer et découvrir les concepts.

Dans ce guide pratique, vous allez apprendre à reconnaître les paroles humaines et à les traduire dans une autre langue.

Consultez la Vue d’ensemble de la traduction vocale pour plus d’informations sur :

Traduction de la parole en texte
Traduction de la parole en plusieurs langues cibles
Réalisation d’une traduction directe de la parole en parole

Prérequis

Un abonnement Azure. Vous pouvez en créer un gratuitement.
Créer une ressource Speech dans le portail Azure.
Obtenez la clé de ressource et la région Speech. Une fois votre ressource vocale déployée, sélectionnez Accéder à la ressource pour afficher et gérer les clés.

Télécharger et installer

Suivez ces étapes et consultez le guide de démarrage rapide de l’interface CLI Speech pour connaître les autres conditions requises pour votre plateforme.

Exécutez la commande CLI .NET suivante pour installer l’interface CLI Speech :
```
dotnet tool install --global Microsoft.CognitiveServices.Speech.CLI
```
Exécutez les commandes suivantes pour configurer la clé et la région de votre ressource Speech. Remplacez SUBSCRIPTION-KEY par la clé de la ressource Speech et remplacez REGION par la région de la ressource Speech.
- Terminal
- PowerShell
```
spx config @key --set SUBSCRIPTION-KEY
spx config @region --set REGION
```
```
spx --% config @key --set SUBSCRIPTION-KEY
spx --% config @region --set REGION
```

Définir la langue source et la langue cible

Cette commande appelle l’interface CLI Speech pour convertir la parole du microphone de l’italien vers le français :

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

Partage via

Comment reconnaître et traduire la parole

Données sensibles et variables d’environnement

Création d’une configuration de traduction vocale

Changer la langue source

Ajouter une langue de traduction

Initialisation d’un moteur de reconnaissance de traduction

Traduction vocale

Traduction basée sur les événements

Synthèse des traductions

Synthèse basée sur les événements

Synthèse manuelle

Traduction multilingue avec identification de la langue

Traduction vocale multilingue sans candidats à la langue source

Utilisation de la traduction personnalisée dans la traduction vocale

Données sensibles et variables d’environnement

Création d’une configuration de traduction vocale

Changer la langue source

Ajouter une langue de traduction

Initialisation d’un moteur de reconnaissance de traduction

Traduction vocale

Synthèse des traductions

Synthèse basée sur les événements

Synthèse manuelle

Traduction multilingue avec identification de la langue

Données sensibles et variables d’environnement

Création d’une configuration de traduction vocale

Changer la langue source

Ajouter une langue de traduction

Initialisation d’un moteur de reconnaissance de traduction

Traduction vocale

Synthèse des traductions

Synthèse basée sur les événements

Synthèse manuelle

Créer une configuration de traduction

Initialiser un traducteur

Traduction vocale

Spécifier une langue cible

Reconnaissance unique

Traduction continue

Choisir une langue source

Choisir une ou plusieurs langues cibles

Données sensibles et variables d’environnement

Création d’une configuration de traduction vocale

Changer la langue source

Ajouter une langue de traduction

Initialisation d’un moteur de reconnaissance de traduction

Traduction vocale

Synthèse des traductions

Synthèse basée sur les événements

Synthèse manuelle

Traduction multilingue avec identification de la langue

Prérequis

Télécharger et installer

Définir la langue source et la langue cible

Étapes suivantes

Commentaires

Ressources supplémentaires