AWS Polly

Le service de synthèse vocale qui transforme le texte en parole naturelle dans de nombreuses langues et voix, permettant de rendre vos applications, sites web et contenus digitaux plus accessibles et engageants.

Retour aux compétences Documentation officielle

Pour les non-initiés

Qu'est-ce qu'AWS Polly ?

Imaginez pouvoir transformer instantanément n'importe quel texte écrit en discours prononcé par une voix humaine naturelle. C'est exactement ce que fait AWS Polly : il donne une voix à vos mots.

AWS Polly est comme un orateur virtuel polyglotte que vous pouvez intégrer à vos applications, sites web ou contenus. Il peut lire des textes dans de nombreuses langues et accents, avec des voix masculines ou féminines qui sonnent incroyablement naturelles grâce à la technologie de synthèse vocale basée sur l'intelligence artificielle.

Pourquoi est-ce si utile ?

Accessibilité

Permet aux personnes malvoyantes d'accéder à du contenu écrit, et aide également les personnes ayant des difficultés de lecture ou d'apprentissage.

Engagement amélioré

Les contenus audio captent mieux l'attention que les textes, rendant vos applications et sites plus engageants pour les utilisateurs.

Multilinguisme

Prend en charge plus de 20 langues, permettant d'atteindre facilement un public international sans nécessiter de multiples enregistrements par des doubleurs.

Rentabilité

Beaucoup moins coûteux et plus rapide que l'enregistrement en studio avec des voix professionnelles, tout en maintenant une qualité exceptionnelle.

En résumé, AWS Polly transforme la façon dont nous interagissons avec le contenu digital en le rendant plus accessible, engageant et personnalisé. Que ce soit pour des applications mobiles, des systèmes de réponse vocale, ou la narration de contenus, Polly offre une solution simple et efficace pour donner une voix humaine à vos applications.

Pour les développeurs

Fonctionnement technique

AWS Polly est un service TTS (Text-to-Speech) qui utilise des technologies avancées d'apprentissage automatique pour synthétiser une parole naturelle à partir de texte. Polly offre deux types de voix : les voix standard et les voix neurales, ces dernières utilisant des réseaux de neurones profonds pour produire une parole encore plus naturelle.

Utilisation et intégration

Synthèse vocale de base

L'API Polly permet de convertir facilement du texte en parole avec un simple appel de fonction en Node.js, en spécifiant le texte, la voix souhaitée et le format de sortie.

Synthèse vocale avec Node.js et AWS SDK

// Exemple d'utilisation de l'SDK AWS avec Node.js pour AWS Polly
import { PollyClient, SynthesizeSpeechCommand } from "@aws-sdk/client-polly";
import { writeFile } from "fs/promises";

async function synthesizeSpeech(text, voiceId = "Lea", outputFormat = "mp3") {
  // Initialiser le client Polly
  const client = new PollyClient({ region: "eu-west-3" });
  
  // Configuration de la synthèse vocale
  const params = {
    Text: text,
    OutputFormat: outputFormat, // mp3, ogg_vorbis, pcm
    VoiceId: voiceId, // Lea, Mathieu, etc. pour le français
    Engine: "neural", // standard ou neural
    LanguageCode: "fr-FR" // Optionnel, utile pour la prononciation
  };

  try {
    // Exécuter la commande de synthèse
    const command = new SynthesizeSpeechCommand(params);
    const response = await client.send(command);
    
    // Récupérer l'audio sous forme de flux
    const audioStream = response.AudioStream;
    
    // Écrire dans un fichier
    const outputFileName = `speech-${Date.now()}.${outputFormat}`;
    await writeFile(outputFileName, Buffer.from(await audioStream.transformToByteArray()));
    
    console.log(`Audio généré avec succès: ${outputFileName}`);
    return outputFileName;
    
  } catch (error) {
    console.error("Erreur lors de la synthèse vocale:", error);
    throw error;
  }
}

// Exemple d'utilisation
synthesizeSpeech(
  "Bonjour, je suis Lea, une voix synthétique créée par AWS Polly. Je peux lire n'importe quel texte avec une intonation naturelle.",
  "Lea",
  "mp3"
);

Exemples avancés en NodeJs

Exploration des fonctionnalités avancées comme la comparaison de voix et l'utilisation du langage de balisage SSML pour contrôler précisément la prononciation et l'intonation.

Exemples avancés avec NodeJs

// Exemple d'utilisation de AWS SDK avec Node.js pour AWS Polly
import { PollyClient, SynthesizeSpeechCommand } from "@aws-sdk/client-polly";
import { writeFile } from "fs/promises";
import { createWriteStream } from "fs";
import { Readable } from "stream";

async function synthesizeSpeech(text, voiceId = "Lea", outputFormat = "mp3", engine = "neural") {
  // Initialiser le client Polly
  const client = new PollyClient({ region: "eu-west-3" });
  
  // Générer l'audio
  const params = {
    Text: text,
    OutputFormat: outputFormat,
    VoiceId: voiceId,
    Engine: engine  // 'standard' ou 'neural'
  };
  
  try {
    const command = new SynthesizeSpeechCommand(params);
    const response = await client.send(command);
    
    // Écrire le flux audio dans un fichier
    const outputFile = `speech-${Date.now()}.${outputFormat}`;
    
    if (response.AudioStream) {
      await writeFile(outputFile, Buffer.from(await response.AudioStream.transformToByteArray()));
      console.log(`Audio généré avec succès: ${outputFile}`);
      return outputFile;
    } else {
      console.log("Erreur: Aucun flux audio n'a été retourné");
      return null;
    }
  } catch (error) {
    console.error("Erreur lors de la synthèse vocale:", error);
    throw error;
  }
}

// Exemple d'utilisation avec formatage SSML avancé
async function synthesizeWithSSML() {
  const ssmlText = `
  <speak>
    Voici les dernières informations du jour:
    <break time="300ms"/>
    Les chercheurs ont annoncé une découverte majeure dans le domaine de 
    <prosody rate="slow" volume="x-loud">l'intelligence artificielle</prosody>.
    <break time="500ms"/>
    La météo du jour sera ensoleillée avec quelques 
    nuages dans l'après-midi.
    <break time="300ms"/>
    Et maintenant, passons au <emphasis level="strong">sport</emphasis>.
  </speak>
  `;
  
  return await synthesizeSpeech(ssmlText, "Lea", "mp3", "neural");
}

// Exemple avec différentes voix
async function voiceComparison() {
  const text = "Bonjour, comment allez-vous aujourd'hui?";
  const voices = [
    ["Lea", "neural"],
    ["Mathieu", "neural"],
    ["Céline", "standard"],
    ["Chantal", "standard"]
  ];
  
  const results = [];
  for (const [voiceId, engine] of voices) {
    const outputFile = await synthesizeSpeech(
      text,
      voiceId,
      "mp3",
      engine
    );
    results.push({ voiceId, engine, outputFile });
  }
  
  return results;
}

// Exécuter les exemples
async function runExamples() {
  await synthesizeSpeech("Bonjour, je suis Lea, une voix synthétique créée par AWS Polly.");
  await synthesizeWithSSML();
  const voiceResults = await voiceComparison();
  console.log("Comparaison des voix:", voiceResults);
}

SSML (Speech Synthesis Markup Language)

Polly prend en charge le SSML, qui permet un contrôle précis de la synthèse vocale, y compris les pauses, l'intonation, la vitesse, le volume et la prononciation de mots spécifiques.

Utilisation de SSML avec AWS Polly

// Exemple d'utilisation de SSML (Speech Synthesis Markup Language) avec AWS Polly
import { PollyClient, SynthesizeSpeechCommand } from "@aws-sdk/client-polly";
import { writeFile } from "fs/promises";

async function synthesizeWithSSML(outputFormat = "mp3") {
  // Initialiser le client Polly
  const client = new PollyClient({ region: "eu-west-3" });
  
  // Texte SSML avec balises pour controler l'intonation, le rythme, etc.
  const ssmlText = `
    <speak>
      Bonjour et bienvenue sur notre application.
      <break time="300ms"/>
      
      <prosody rate="slow" pitch="low">
        Nous sommes ravis de vous accueillir.
      </prosody>
      
      <break time="500ms"/>
      
      <emphasis level="strong">
        Attention: cette information est importante.
      </emphasis>
      
      <break time="300ms"/>
      
      Le prix de ce produit est de <say-as interpret-as="cardinal">42</say-as> euros.
      
      <break time="200ms"/>
      
      Cet événement aura lieu le <say-as interpret-as="date" format="dmy">15/07/2023</say-as>.
      
      <break time="300ms"/>
      
      <prosody volume="x-loud" rate="90%">
        Nous vous remercions pour votre attention!
      </prosody>
    </speak>
  `;

  // Configuration de la synthèse vocale
  const params = {
    Text: ssmlText,
    TextType: "ssml", // Indiquer qu'on utilise du SSML plutôt que du texte brut
    OutputFormat: outputFormat,
    VoiceId: "Lea",
    Engine: "neural"
  };

  try {
    // Exécuter la commande de synthèse
    const command = new SynthesizeSpeechCommand(params);
    const response = await client.send(command);
    
    // Récupérer et écrire l'audio dans un fichier
    const audioStream = response.AudioStream;
    const outputFileName = `ssml-speech-${Date.now()}.${outputFormat}`;
    await writeFile(outputFileName, Buffer.from(await audioStream.transformToByteArray()));
    
    console.log(`Audio avec SSML généré avec succès: ${outputFileName}`);
    return outputFileName;
    
  } catch (error) {
    console.error("Erreur lors de la synthèse vocale avec SSML:", error);
    throw error;
  }
}

Intégration web

Intégrer AWS Polly dans une application web basée sur React permet aux utilisateurs de convertir du texte en parole directement dans le navigateur, créant ainsi des expériences interactives riches.

Intégration dans une application React

// Exemple d'intégration d'AWS Polly dans une application web avec React
import React, { useState, useEffect } from 'react';
import { PollyClient, SynthesizeSpeechCommand } from "@aws-sdk/client-polly";

// Composant de synthèse vocale
const TextToSpeech = () => {
  const [text, setText] = useState('');
  const [voice, setVoice] = useState('Lea');
  const [engine, setEngine] = useState('neural');
  const [isLoading, setIsLoading] = useState(false);
  const [audioUrl, setAudioUrl] = useState(null);
  const [voices, setVoices] = useState([]);
  const [error, setError] = useState(null);
  
  // Récupérer la liste des voix disponibles au chargement du composant
  useEffect(() => {
    const fetchVoices = async () => {
      try {
        const client = new PollyClient({ region: "eu-west-3" });
        const { Voices } = await client.send(new DescribeVoicesCommand({
          LanguageCode: "fr-FR"
        }));
        
        setVoices(Voices || []);
      } catch (err) {
        console.error("Erreur lors de la récupération des voix:", err);
        setError("Impossible de charger les voix disponibles");
      }
    };
    
    fetchVoices();
  }, []);
  
  // Fonction de synthèse vocale
  const synthesizeSpeech = async () => {
    if (!text.trim()) {
      setError("Veuillez entrer du texte à convertir");
      return;
    }
    
    setIsLoading(true);
    setError(null);
    setAudioUrl(null);
    
    try {
      // Dans une application réelle, cet appel serait délégué à un serveur pour des raisons de sécurité
      // Ici nous montrons le concept, mais en production il faudrait utiliser une API backend
      const client = new PollyClient({ region: "eu-west-3" });
      
      const command = new SynthesizeSpeechCommand({
        Text: text,
        OutputFormat: "mp3",
        VoiceId: voice,
        Engine: engine
      });
      
      const response = await client.send(command);
      
      // Convertir le flux audio en URL pour la lecture
      const blob = new Blob(
        [await response.AudioStream.transformToByteArray()],
        { type: "audio/mpeg" }
      );
      const url = URL.createObjectURL(blob);
      
      setAudioUrl(url);
    } catch (err) {
      console.error("Erreur lors de la synthèse vocale:", err);
      setError(`Erreur: ${err.message}`);
    } finally {
      setIsLoading(false);
    }
  };
  
  return (
    <div className="max-w-md mx-auto p-6 bg-white rounded-lg shadow-md">
      <h2 className="text-2xl font-bold mb-4">Synthèse vocale AWS Polly</h2>
      
      {error && (
        <div className="mb-4 p-3 bg-red-100 text-red-700 rounded">
          {error}
        </div>
      )}
      
      <div className="mb-4">
        <label className="block mb-2 font-medium">Texte à convertir:</label>
        <textarea
          className="w-full p-2 border rounded focus:ring focus:ring-blue-300"
          rows="4"
          value={text}
          onChange={(e) => setText(e.target.value)}
          placeholder="Entrez votre texte ici..."
        />
      </div>
      
      <div className="grid grid-cols-2 gap-4 mb-4">
        <div>
          <label className="block mb-2 font-medium">Voix:</label>
          <select
            className="w-full p-2 border rounded"
            value={voice}
            onChange={(e) => setVoice(e.target.value)}
          >
            {voices.map((v) => (
              <option key={v.Id} value={v.Id}>
                {v.Name} ({v.Gender})
              </option>
            ))}
          </select>
        </div>
        
        <div>
          <label className="block mb-2 font-medium">Moteur:</label>
          <select
            className="w-full p-2 border rounded"
            value={engine}
            onChange={(e) => setEngine(e.target.value)}
          >
            <option value="neural">Neural</option>
            <option value="standard">Standard</option>
          </select>
        </div>
      </div>
      
      <button
        onClick={synthesizeSpeech}
        disabled={isLoading}
        className="w-full bg-blue-500 hover:bg-blue-600 text-white font-medium py-2 px-4 rounded disabled:opacity-50"
      >
        {isLoading ? "Génération en cours..." : "Générer l'audio"}
      </button>
      
      {audioUrl && (
        <div className="mt-6">
          <h3 className="font-medium mb-2">Audio généré:</h3>
          <audio controls className="w-full">
            <source src={audioUrl} type="audio/mpeg" />
            Votre navigateur ne supporte pas l'élément audio.
          </audio>
          <div className="mt-2 text-sm text-gray-600">
            <a href={audioUrl} download="audio.mp3" className="text-blue-500 hover:underline">
              Télécharger le fichier audio
            </a>
          </div>
        </div>
      )}
    </div>
  );
};

export default TextToSpeech;

Caractéristiques principales

Voix neurales - Des voix de haute qualité utilisant des réseaux de neurones avancés pour une parole plus naturelle
Support SSML - Contrôle précis de l'intonation, des pauses, de la prononciation et plus
Lexiques personnalisés - Définition de prononciations spécifiques pour certains mots ou acronymes
Format long - Synthèse de textes de grande taille, idéale pour la narration de livres audio ou d'articles longs
Marqueurs de parole - Permet la synchronisation précise avec des animations ou des sous-titres
Multi-formats - Génération d'audio en MP3, OGG Vorbis ou PCM selon les besoins
Cache de synthèse - Stockage des résultats fréquemment utilisés pour optimiser les coûts et les performances

Langues et voix disponibles

AWS Polly propose une large variété de voix dans de nombreuses langues :

Français - Lea, Mathieu, Céline, Chantal (avec voix neurales disponibles)
Anglais - Multiple accents (américain, britannique, australien, indien)
Espagnol - Multiple accents (castillan, mexicain)
Allemand - Plusieurs voix masculines et féminines
Italien - Plusieurs voix masculines et féminines
Autres langues - Portugais, Chinois, Japonais, Arabe, Hindi, et bien d'autres

Chaque voix a ses propres caractéristiques et est optimisée pour sa langue maternelle, mais peut aussi prononcer des mots dans d'autres langues.

Applications concrètes

Cas d'usage

Solutions d'accessibilité

Lecture automatique d'articles, livres ou documents pour les personnes malvoyantes ou ayant des difficultés de lecture, transformant tout contenu textuel en expérience audio.

Centres de contact

Systèmes de réponse vocale interactive (IVR) et chatbots vocaux qui peuvent générer des réponses dynamiques basées sur les données en temps réel, offrant une expérience utilisateur plus naturelle.

Contenu éducatif

Conversion de manuels scolaires, articles et ressources pédagogiques en format audio pour faciliter l'apprentissage auditif et offrir des options d'accessibilité aux étudiants.

Narration de vidéos

Génération de voix off pour vidéos explicatives, publicités ou tutoriels, permettant d'ajuster facilement le script sans nécessiter de nouveaux enregistrements en studio.

Applications mobiles

Intégration de la lecture vocale dans les applications mobiles pour la navigation GPS, les notifications, les assistants personnels ou la lecture d'articles et de messages.

Notifications et alertes

Transformation de notifications écrites en alertes vocales personnalisées pour les applications d'urgence, les systèmes de sécurité ou les notifications importantes.