AWS Comprehend
Le service d'analyse textuelle qui utilise le machine learning pour extraire insights, sentiments, entités et thèmes des textes, révélant ainsi la valeur cachée dans vos données non structurées.
Qu'est-ce qu'AWS Comprehend ?
Imaginez avoir des milliers d'emails clients, de commentaires sur les réseaux sociaux, ou d'avis sur vos produits. Comment extraire rapidement des informations utiles de cette masse de texte ? C'est exactement ce que fait AWS Comprehend : il lit et comprend ces textes pour vous, comme le ferait un assistant humain qui analyserait tous ces documents, mais en quelques secondes seulement.
AWS Comprehend est comme un lecteur super-intelligent qui peut rapidement parcourir n'importe quel texte et vous dire de quoi il parle, qui est mentionné, s'il exprime des sentiments positifs ou négatifs, et quelles sont les phrases importantes à retenir.
Ce que Comprehend peut faire pour vous
Analyse des sentiments
Détecter si un commentaire est positif, négatif, neutre ou mitigé, permettant d'identifier rapidement les clients mécontents nécessitant une attention immédiate.
Reconnaissance d'entités
Identifier automatiquement les personnes, lieux, organisations, dates, quantités et autres informations clés mentionnées dans le texte.
Extraction de phrases clés
Repérer les expressions et phrases les plus importantes dans un document, comme un résumé automatique des points essentiels.
Classification de documents
Classer automatiquement les textes par thème ou catégorie, permettant par exemple de trier les demandes clients selon le service concerné.
En résumé, AWS Comprehend transforme le texte brut en données structurées et exploitables, sans nécessiter d'expertise en intelligence artificielle. Il permet aux entreprises de découvrir des tendances, d'automatiser le traitement des documents et d'améliorer les interactions avec les clients, le tout à grande échelle.
Fonctionnement technique
AWS Comprehend est un service de traitement du langage naturel (NLP) entièrement géré qui utilise l'apprentissage automatique pour extraire des informations et des insights à partir de textes non structurés. Comprehend propose à la fois des API pré-entraînées pour les tâches NLP courantes et des capacités d'entraînement de modèles personnalisés.
Fonctionnalités principales et exemples
Analyse de sentiment
L'API de sentiment détermine si un texte exprime un sentiment positif, négatif, neutre ou mixte, et fournit un score de confiance pour chaque catégorie. Particulièrement utile pour l'analyse de feedback client.
// Exemple d'utilisation de l'SDK AWS avec Node.js pour l'analyse de sentiment
import { ComprehendClient, DetectSentimentCommand } from "@aws-sdk/client-comprehend";
async function analyzeSentiment(text, languageCode = "fr") {
// Initialiser le client Comprehend
const client = new ComprehendClient({ region: "eu-west-3" });
// Configuration de la requête
const params = {
Text: text,
LanguageCode: languageCode // fr, en, es, de, it, pt, ar, hi, ja, ko, zh, zh-TW
};
try {
// Exécuter la commande d'analyse de sentiment
const command = new DetectSentimentCommand(params);
const response = await client.send(command);
// Traiter la réponse
const { Sentiment, SentimentScore } = response;
console.log(`Sentiment détecté: ${Sentiment}`);
console.log("Scores détaillés:", SentimentScore);
return { Sentiment, SentimentScore };
} catch (error) {
console.error("Erreur lors de l'analyse de sentiment:", error);
throw error;
}
}
// Exemple d'utilisation
const reviews = [
"Ce produit a dépassé toutes mes attentes. Je le recommande vivement !",
"Service correct, mais les délais de livraison pourraient être améliorés.",
"Terrible expérience. Je ne commanderai plus jamais sur ce site."
];
async function analyzeCustomerFeedback() {
for (const review of reviews) {
console.log("
Texte:", review);
const result = await analyzeSentiment(review);
// Interprétation des résultats
let feedback = "";
if (result.Sentiment === "POSITIVE") {
feedback = "Client satisfait";
} else if (result.Sentiment === "NEGATIVE") {
feedback = "Client mécontent - nécessite suivi";
} else if (result.Sentiment === "MIXED") {
feedback = "Sentiment mitigé - à analyser en détail";
} else {
feedback = "Sentiment neutre";
}
console.log(feedback);
}
}
analyzeCustomerFeedback();Extraction d'entités
Cette fonctionnalité identifie des éléments clés comme les personnes, lieux, dates, organisations et expressions numériques mentionnés dans le texte, avec leurs scores de confiance.
// Exemple d'extraction d'entités avec AWS Comprehend
import { ComprehendClient, DetectEntitiesCommand } from "@aws-sdk/client-comprehend";
async function extractEntities(text, languageCode = "fr") {
// Initialiser le client Comprehend
const client = new ComprehendClient({ region: "eu-west-3" });
// Configuration de la requête
const params = {
Text: text,
LanguageCode: languageCode
};
try {
// Exécuter la commande d'extraction d'entités
const command = new DetectEntitiesCommand(params);
const response = await client.send(command);
// Traiter les entités détectées
const { Entities } = response;
// Regrouper les entités par type
const entityTypes = {};
Entities.forEach(entity => {
if (!entityTypes[entity.Type]) {
entityTypes[entity.Type] = [];
}
entityTypes[entity.Type].push({
text: entity.Text,
score: entity.Score
});
});
return entityTypes;
} catch (error) {
console.error("Erreur lors de l'extraction d'entités:", error);
throw error;
}
}
// Exemple d'utilisation
const newsArticle = `Le 15 mai 2023, la société TechVision, basée à Paris, a annoncé le lancement
de son nouveau logiciel d'IA. Le CEO, Jean Dupont, a déclaré que cette innovation
pourrait révolutionner le marché européen. L'événement s'est déroulé à la Tour Eiffel
et a rassemblé plus de 200 personnes, dont plusieurs représentants d'Apple et de Google.`;
async function analyzeNewsArticle() {
console.log("Texte:", newsArticle);
const entities = await extractEntities(newsArticle);
// Afficher les entités par type
console.log("
Entités détectées:")
for (const [type, items] of Object.entries(entities)) {
console.log(`
${type}:`);
items.forEach(item => {
console.log(`- ${item.text} (confiance: ${(item.score * 100).toFixed(2)}%)`);
});
}
}
analyzeNewsArticle();Extraction de phrases clés et analyse complète
L'API de phrases clés identifie les expressions importantes qui indiquent le contenu et les thèmes d'un texte. En utilisant 
Node.js, cet exemple montre également comment combiner plusieurs analyses pour une compréhension plus complète.
// Exemple d'extraction de phrases clés avec Node.js et AWS SDK
import { ComprehendClient, DetectKeyPhrasesCommand, DetectSentimentCommand, DetectEntitiesCommand, DetectDominantLanguageCommand } from "@aws-sdk/client-comprehend";
async function extractKeyPhrases(text, languageCode = "fr") {
// Initialiser le client Comprehend
const client = new ComprehendClient({ region: "eu-west-3" });
// Configuration de la requête
const params = {
Text: text,
LanguageCode: languageCode
};
try {
// Exécuter la commande d'extraction de phrases clés
const command = new DetectKeyPhrasesCommand(params);
const response = await client.send(command);
// Traiter les résultats
const keyPhrases = response.KeyPhrases.map(phrase => ({
text: phrase.Text,
score: phrase.Score
}));
// Trier par score de confiance décroissant
keyPhrases.sort((a, b) => b.score - a.score);
return keyPhrases;
} catch (error) {
console.error("Erreur lors de l'extraction des phrases clés:", error);
throw error;
}
}
// Exemple d'utilisation avec analyse de document
async function analyzeDocument() {
const document = `
L'intelligence artificielle transforme rapidement de nombreux secteurs d'activité.
Les entreprises qui adoptent des solutions basées sur l'IA voient souvent une
amélioration significative de leur productivité et une réduction des coûts.
Cependant, l'adoption de ces technologies pose aussi des questions éthiques
importantes concernant la vie privée et l'avenir du travail. Les régulateurs
du monde entier travaillent sur des cadres législatifs pour encadrer ces innovations.
`;
console.log("Analyse du document...
");
// Extraire les phrases clés
const phrases = await extractKeyPhrases(document);
console.log("Phrases clés identifiées:");
phrases.slice(0, 10).forEach((phrase, index) => {
console.log(`${index + 1}. ${phrase.text} (score: ${phrase.score.toFixed(4)})`);
});
// Bâtir un résumé avec les phrases clés principales
if (phrases.length) {
const topPhrases = phrases.slice(0, 3).map(phrase => phrase.text);
const summary = topPhrases.join(" ");
console.log(`
Résumé généré: ${summary}`);
}
}
// Analyse combinée (sentiment + phrases clés + entités)
async function comprehensiveAnalysis(text, languageCode = "fr") {
const client = new ComprehendClient({ region: "eu-west-3" });
console.log("Effectuant une analyse complète...
");
try {
// 1. Sentiment
const sentimentCommand = new DetectSentimentCommand({
Text: text,
LanguageCode: languageCode
});
const sentimentResponse = await client.send(sentimentCommand);
// 2. Phrases clés
const keyPhrasesCommand = new DetectKeyPhrasesCommand({
Text: text,
LanguageCode: languageCode
});
const keyPhrasesResponse = await client.send(keyPhrasesCommand);
// 3. Entités
const entitiesCommand = new DetectEntitiesCommand({
Text: text,
LanguageCode: languageCode
});
const entitiesResponse = await client.send(entitiesCommand);
// 4. Langage dominant (peut être utile pour les textes multilingues)
const languageCommand = new DetectDominantLanguageCommand({
Text: text
});
const languageResponse = await client.send(languageCommand);
// Rassembler tous les résultats
const results = {
sentiment: {
overall: sentimentResponse.Sentiment,
scores: sentimentResponse.SentimentScore
},
key_phrases: keyPhrasesResponse.KeyPhrases.map(phrase => phrase.Text),
entities: {}
};
// Regrouper les entités par type
entitiesResponse.Entities.forEach(entity => {
if (!results.entities[entity.Type]) {
results.entities[entity.Type] = [];
}
results.entities[entity.Type].push({
text: entity.Text,
score: entity.Score
});
});
// Déterminer la langue dominante
const languages = languageResponse.Languages;
if (languages && languages.length) {
const topLanguage = languages.reduce((prev, current) =>
(prev.Score > current.Score) ? prev : current
);
results.dominant_language = {
language_code: topLanguage.LanguageCode,
score: topLanguage.Score
};
}
return results;
} catch (error) {
console.error("Erreur lors de l'analyse complète:", error);
throw error;
}
}
// Exemple d'utilisation
async function runExamples() {
await analyzeDocument();
// Exemple d'analyse complète
const sampleText = `
Amazon a annoncé aujourd'hui une nouvelle mise à jour de son service AWS Comprehend.
Le PDG Andy Jassy a expliqué que cette mise à jour améliorera la précision de 15%.
L'équipe de développement basée à Seattle a travaillé pendant 6 mois sur cette nouvelle version.
Les clients de secteurs comme la finance et la santé devraient particulièrement en bénéficier.
`;
const results = await comprehensiveAnalysis(sampleText);
console.log(JSON.stringify(results, null, 2));
}Modèles personnalisés
Au-delà des modèles génériques, Comprehend permet de créer des classificateurs personnalisés ou des extracteurs d'entités adaptés à votre domaine spécifique, en utilisant des données stockées dans 
S3, pour des tâches comme la classification de tickets support.
// Exemple de création et d'utilisation d'un modèle personnalisé avec AWS Comprehend
import { ComprehendClient, CreateDocumentClassifierCommand, DescribeDocumentClassifierCommand, StartDocumentClassificationJobCommand } from "@aws-sdk/client-comprehend";
import { S3Client, PutObjectCommand } from "@aws-sdk/client-s3";
import fs from 'fs/promises';
// Fonction pour créer un jeu de données d'entraînement
async function prepareTrainingData() {
// Format CSV pour l'entraînement de classificateur:
// CLASS,TEXT
const trainingData = [
"SUPPORT,J'ai un problème avec mon compte et je n'arrive pas à me connecter",
"SUPPORT,Comment puis-je réinitialiser mon mot de passe ?",
"SUPPORT,L'application ne répond plus quand j'essaie de soumettre un formulaire",
"FACTURATION,Je souhaite savoir pourquoi j'ai été facturé deux fois ce mois-ci",
"FACTURATION,Pouvez-vous m'envoyer une copie de ma dernière facture",
"FACTURATION,Je voudrais modifier mes informations de paiement",
"COMMERCIAL,Je souhaite en savoir plus sur vos tarifs entreprise",
"COMMERCIAL,Proposez-vous des réductions pour les commandes en volume ?",
"COMMERCIAL,J'aimerais programmer une démonstration de votre produit"
];
// Ajouter l'en-tête
const csvContent = "CLASS,TEXT
" + trainingData.join("
");
// Écrire dans un fichier temporaire
await fs.writeFile('./training_data.csv', csvContent, 'utf8');
return './training_data.csv';
}
// Fonction pour télécharger le fichier d'entraînement vers S3
async function uploadToS3(filePath, bucketName, objectKey) {
const s3Client = new S3Client({ region: "eu-west-3" });
const fileContent = await fs.readFile(filePath, 'utf8');
const command = new PutObjectCommand({
Bucket: bucketName,
Key: objectKey,
Body: fileContent,
ContentType: 'text/csv'
});
await s3Client.send(command);
return `s3://${bucketName}/${objectKey}`;
}
// Fonction pour créer un classificateur de documents
async function createCustomClassifier(trainingDataS3Uri, bucketName) {
const comprehendClient = new ComprehendClient({ region: "eu-west-3" });
const classifierName = `support-ticket-classifier-${Date.now()}`;
const outputS3Uri = `s3://${bucketName}/comprehend/output/`;
const command = new CreateDocumentClassifierCommand({
DocumentClassifierName: classifierName,
DataAccessRoleArn: "arn:aws:iam::ACCOUNT_ID:role/ComprehendServiceRole", // Remplacer par votre rôle IAM
InputDataConfig: {
DataFormat: "CSV",
S3Uri: trainingDataS3Uri
},
LanguageCode: "fr",
OutputDataConfig: {
S3Uri: outputS3Uri
}
});
const response = await comprehendClient.send(command);
console.log(`Classificateur ${classifierName} en cours de création. ARN: ${response.DocumentClassifierArn}`);
return {
classifierName,
classifierArn: response.DocumentClassifierArn
};
}
// Fonction pour suivre l'état du classificateur
async function waitForClassifierReady(classifierArn) {
const comprehendClient = new ComprehendClient({ region: "eu-west-3" });
console.log("Attente de la création du classificateur (cela peut prendre 30+ minutes)...");
let status = "IN_PROGRESS";
while (status === "IN_PROGRESS" || status === "SUBMITTED") {
// Vérifier l'état toutes les 5 minutes
await new Promise(resolve => setTimeout(resolve, 5 * 60 * 1000));
const command = new DescribeDocumentClassifierCommand({
DocumentClassifierArn: classifierArn
});
const response = await comprehendClient.send(command);
status = response.DocumentClassifierProperties.Status;
console.log(`État actuel: ${status}`);
if (status === "TRAINED") {
console.log("Classificateur prêt à être utilisé!");
return true;
} else if (status === "FAILED") {
console.error("Erreur lors de la création du classificateur:", response.DocumentClassifierProperties.Message);
return false;
}
}
return false;
}
// Fonction pour utiliser le classificateur sur un nouveau texte
async function classifyTickets(classifierArn, bucketName) {
const comprehendClient = new ComprehendClient({ region: "eu-west-3" });
// Créer un fichier de test
const testData = [
"J'ai besoin d'aide pour mettre à jour mes données de carte bancaire",
"Pouvez-vous me montrer comment fonctionne votre solution ?",
"Je n'arrive pas à accéder à mon compte depuis hier soir"
];
// Écrire chaque ligne dans un fichier texte (un document par ligne)
const testFileName = './test_tickets.txt';
await fs.writeFile(testFileName, testData.join('
'), 'utf8');
// Uploader vers S3
const testS3Uri = await uploadToS3(testFileName, bucketName, 'comprehend/input/test_tickets.txt');
// Lancer le job de classification
const jobName = `classification-job-${Date.now()}`;
const outputS3Uri = `s3://${bucketName}/comprehend/output/`;
const command = new StartDocumentClassificationJobCommand({
DocumentClassifierArn: classifierArn,
InputDataConfig: {
S3Uri: testS3Uri,
InputFormat: "ONE_DOC_PER_LINE"
},
OutputDataConfig: {
S3Uri: outputS3Uri
},
DataAccessRoleArn: "arn:aws:iam::ACCOUNT_ID:role/ComprehendServiceRole", // Remplacer par votre rôle IAM
JobName: jobName
});
const response = await comprehendClient.send(command);
console.log(`Job de classification lancé. ARN: ${response.JobId}`);
console.log(`Une fois terminé, les résultats seront disponibles à: ${outputS3Uri}`);
return response.JobId;
}
// Fonction principale
async function main() {
try {
const bucketName = "my-comprehend-bucket"; // Remplacer par votre bucket S3
// 1. Préparer les données d'entraînement
console.log("Préparation des données d'entraînement...");
const trainingFilePath = await prepareTrainingData();
// 2. Uploader vers S3
console.log("Téléversement des données vers S3...");
const trainingS3Uri = await uploadToS3(trainingFilePath, bucketName, 'comprehend/training/support_data.csv');
// 3. Créer le classificateur personnalisé
console.log("Création du classificateur personnalisé...");
const { classifierArn } = await createCustomClassifier(trainingS3Uri, bucketName);
// 4. Attendre que le classificateur soit prêt (peut prendre 30+ minutes)
const isReady = await waitForClassifierReady(classifierArn);
if (isReady) {
// 5. Utiliser le classificateur
console.log("Classification de nouveaux tickets...");
await classifyTickets(classifierArn, bucketName);
}
} catch (error) {
console.error("Erreur:", error);
}
}Autres fonctionnalités avancées
- Détection de PII - Identification d'informations personnelles identifiables comme les noms, adresses, numéros de téléphone ou de cartes de crédit dans les documents
- Analyse par lots - Traitement simultané de grandes quantités de documents pour des analyses à grande échelle
- Analyse en temps réel - API synchrone pour les applications nécessitant des réponses immédiates
- Détection de langues - Identification automatique de la langue principale d'un texte parmi plus de 100 langues
- Modèles spécialisés par secteur - Solutions optimisées pour des domaines comme la santé (Comprehend Medical) ou la finance
- Intégration native avec S3 - Pour l'analyse de larges corpus de documents stockés dans Amazon S3
Considérations techniques
- Limites de taille - 5 Ko par appel pour les API synchrones, et jusqu'à 100 Ko pour certaines API asynchrones
- Langues supportées - L'ensemble complet des fonctionnalités est disponible pour l'anglais, avec un support variable pour d'autres langues comme le français, l'espagnol, l'allemand, l'italien et le portugais
- Sécurité et conformité - Toutes les données sont chiffrées en transit et au repos, et Comprehend est conforme aux normes comme HIPAA, SOC, PCI DSS et GDPR
- Modèle de tarification - Basé sur la quantité de texte traité, avec des coûts variables selon les fonctionnalités utilisées
Comprehend s'intègre parfaitement avec d'autres services AWS comme 
Lambda pour le traitement événementiel, S3 pour le stockage des documents, 
Transcribe pour l'analyse de contenu audio transcrit, ou 
Bedrock pour des pipelines d'IA plus complexes, permettant la création de solutions complètes d'analyse textuelle.
Cas d'usage
Analyse de feedback client
Traitement automatique des avis, commentaires et enquêtes de satisfaction pour identifier les tendances, les problèmes récurrents et les opportunités d'amélioration des produits ou services.
Routage intelligent des demandes
Classification automatique des emails et tickets de support pour les acheminer vers les services ou experts appropriés, réduisant les délais de traitement et améliorant la qualité des réponses.
Conformité et protection des données
Identification et redaction automatique des informations personnelles (PII) dans les documents, contribuant au respect des réglementations comme le RGPD ou la HIPAA et à la protection des données sensibles.
Analyse de médias sociaux
Surveillance et analyse des mentions de marque, tendances et réactions des consommateurs sur les plateformes sociales, permettant une réponse rapide aux crises potentielles et l'identification d'opportunités marketing.
Enrichissement des données client
Analyse des interactions clients pour créer des profils plus riches et personnalisés, améliorant la segmentation, le ciblage et les expériences personnalisées.
Indexation et recherche avancée
Amélioration des systèmes de recherche documentaire en extrayant et indexant automatiquement les entités et concepts clés, rendant les archives et bases de connaissances beaucoup plus accessibles.
