AWS Transcribe
Le service de reconnaissance vocale automatique qui convertit la parole en texte avec précision, permettant d'analyser les contenus audio et de les rendre accessibles et exploitables.
Qu'est-ce qu'AWS Transcribe ?
Imaginez AWS Transcribe comme un assistant qui écoute et retranscrit avec précision tout contenu audio ou vidéo en texte. C'est comme si vous aviez un expert en sténographie ultra-rapide qui note parfaitement chaque mot prononcé, même dans des conditions sonores difficiles.
Traditionnellement, transcrire des fichiers audio était un processus manuel fastidieux, coûteux et sujet aux erreurs. Avec AWS Transcribe, ce travail est automatisé grâce à l'intelligence artificielle avancée, permettant de transformer rapidement des heures de contenu audio en texte exploitable.
Pourquoi est-ce révolutionnaire ?
Accessibilité
Rend le contenu audio accessible aux personnes malentendantes et facilite la recherche dans les médias audio grâce à la conversion en texte.
Automatisation
Élimine le besoin de transcription manuelle, économisant temps et ressources tout en permettant de traiter des volumes importants de contenu.
Analyse avancée
Permet d'analyser les conversations, d'extraire des insights et de détecter les tendances au sein de vos contenus audio.
Multilingue
Prend en charge de nombreuses langues et accents, rendant la solution utilisable à l'échelle mondiale.
En résumé, AWS Transcribe transforme la façon dont les entreprises et les créateurs de contenu travaillent avec les médias audio, en rendant l'information parlée aussi facilement accessible et analysable que le texte écrit.
Fonctionnement technique
AWS Transcribe utilise des modèles d'apprentissage profond avancés pour convertir la parole en texte. Le service s'appuie sur des réseaux de neurones entraînés sur des millions d'heures d'audio dans diverses langues, accents et contextes pour garantir une précision élevée de transcription.
Architecture et fonctionnalités
Transcription par lots (Batch)
Permet de traiter des fichiers audio stockés dans 
Amazon S3, prenant en charge de nombreux formats (MP3, MP4, WAV, FLAC, etc.) avec une durée allant jusqu'à plusieurs heures.
// Exemple d'utilisation de l'SDK AWS avec Node.js pour AWS Transcribe
import { TranscribeClient, StartTranscriptionJobCommand } from "@aws-sdk/client-transcribe";
async function transcribeAudioFile(bucketName, objectKey, jobName, languageCode = "fr-FR") {
// Initialiser le client Transcribe
const client = new TranscribeClient({ region: "eu-west-3" });
// Configuration du job de transcription
const params = {
TranscriptionJobName: jobName,
LanguageCode: languageCode, // Codes disponibles: en-US, fr-FR, es-ES, etc.
MediaFormat: objectKey.split(".").pop(), // Détermine le format à partir de l'extension
Media: {
MediaFileUri: `s3://${bucketName}/${objectKey}`
},
Settings: {
ShowSpeakerLabels: true,
MaxSpeakerLabels: 2, // Nombre de locuteurs distincts attendus
ShowAlternatives: true,
MaxAlternatives: 2 // Proposer jusqu'à 2 alternatives pour chaque mot/phrase
}
};
try {
// Lancer le job de transcription
const command = new StartTranscriptionJobCommand(params);
const response = await client.send(command);
console.log("Job de transcription lancé avec succès:", response);
return response;
} catch (error) {
console.error("Erreur lors du lancement du job de transcription:", error);
throw error;
}
}
// Exemple d'utilisation
transcribeAudioFile(
"my-audio-bucket",
"interviews/entretien-client-2023.mp3",
"entretien-client-2023-transcription"
);Transcription en temps réel (Streaming)
Permet une transcription en direct via WebSocket ou HTTP/2, idéale pour les applications interactives comme les centres d'appels, les assistants virtuels ou le sous-titrage en direct avec 
API Gateway et 
Lambda.
// Exemple d'utilisation de l'SDK AWS avec Node.js pour AWS Transcribe
import { TranscribeClient, StartTranscriptionJobCommand, GetTranscriptionJobCommand } from "@aws-sdk/client-transcribe";
async function transcribeAudioFile(bucketName, objectKey, jobName, languageCode = "fr-FR") {
// Initialiser le client Transcribe
const client = new TranscribeClient({ region: "eu-west-3" });
// Déterminer le format à partir de l'extension
const mediaFormat = objectKey.split(".").pop();
const supportedFormats = ["mp3", "mp4", "wav", "flac", "ogg", "amr", "webm"];
if (!supportedFormats.includes(mediaFormat)) {
throw new Error(`Format non supporté: ${mediaFormat}`);
}
// URI S3 du fichier audio
const mediaUri = `s3://${bucketName}/${objectKey}`;
// Configuration du job de transcription
const params = {
TranscriptionJobName: jobName,
LanguageCode: languageCode,
MediaFormat: mediaFormat,
Media: { MediaFileUri: mediaUri },
Settings: {
// Activer la reconnaissance des locuteurs
ShowSpeakerLabels: true,
MaxSpeakerLabels: 2,
// Activer la détection des informations sensibles (PII)
ContentRedaction: {
RedactionType: "PII",
RedactionOutput: "redacted",
PiiEntityTypes: ["NAME", "ADDRESS", "CREDIT_DEBIT_NUMBER"]
}
}
};
try {
// Lancer le job de transcription
const command = new StartTranscriptionJobCommand(params);
const response = await client.send(command);
console.log(`Job de transcription lancé: ${jobName}`);
// Attendre que le job soit terminé
let isCompleted = false;
let status;
while (!isCompleted) {
const getJobCommand = new GetTranscriptionJobCommand({ TranscriptionJobName: jobName });
status = await client.send(getJobCommand);
const currentStatus = status.TranscriptionJob.TranscriptionJobStatus;
if (currentStatus === 'COMPLETED' || currentStatus === 'FAILED') {
isCompleted = true;
} else {
console.log(`En cours de traitement... Status: ${currentStatus}`);
// Attendre 30 secondes avant de vérifier à nouveau
await new Promise(resolve => setTimeout(resolve, 30000));
}
}
// Récupérer et afficher les résultats si le job est terminé avec succès
if (status.TranscriptionJob.TranscriptionJobStatus === 'COMPLETED') {
const resultUri = status.TranscriptionJob.Transcript.TranscriptFileUri;
console.log(`Transcription terminée avec succès. Résultats disponibles à: ${resultUri}`);
return resultUri;
} else {
const failureReason = status.TranscriptionJob.FailureReason || 'Raison inconnue';
console.log(`Échec de la transcription: ${failureReason}`);
return null;
}
} catch (error) {
console.error("Erreur lors de la transcription:", error);
throw error;
}
}
// Exemple d'utilisation
// transcribeAudioFile(
// "ma-bucket-audio",
// "appels/support-client-15-03-2023.mp3",
// "support-client-15-03-2023-transcription"
// ).catch(console.error);Transcribe Medical
Une variante spécialisée pour la transcription de terminologie médicale, optimisée pour les consultations, les dictées et les notes médicales, avec support pour les termes médicaux spécifiques.
// Exemple de transcription médicale avec AWS Transcribe Medical
import { TranscribeMedicalClient, StartMedicalTranscriptionJobCommand }
from "@aws-sdk/client-transcribe-medical";
async function transcribeMedicalAudio(bucketName, objectKey, jobName) {
// Initialiser le client Transcribe Medical
const client = new TranscribeMedicalClient({ region: "us-east-1" });
// Configuration du job de transcription médicale
const params = {
MedicalTranscriptionJobName: jobName,
LanguageCode: "en-US", // Transcribe Medical prend principalement en charge l'anglais américain
MediaFormat: objectKey.split(".").pop(),
Media: {
MediaFileUri: `s3://${bucketName}/${objectKey}`
},
Specialty: "PRIMARYCARE", // Spécialisation médicale: PRIMARYCARE, CARDIOLOGY, NEUROLOGY, etc.
Type: "CONVERSATION", // Type de contenu: CONVERSATION ou DICTATION
OutputBucketName: bucketName, // Bucket où seront stockés les résultats
Settings: {
ShowSpeakerLabels: true,
MaxSpeakerLabels: 2,
ChannelIdentification: false // À true si l'audio contient des canaux séparés
}
};
try {
// Lancer le job de transcription médicale
const command = new StartMedicalTranscriptionJobCommand(params);
const response = await client.send(command);
console.log("Job de transcription médicale lancé avec succès:", response);
return response;
} catch (error) {
console.error("Erreur lors du lancement du job de transcription médicale:", error);
throw error;
}
}Post-traitement et analyse
Une fois les données transcrites obtenues, divers post-traitements peuvent être appliqués pour extraire plus de valeur, comme la génération de sous-titres, l'analyse de sentiment avec 
AWS Comprehend ou l'extraction d'insights via Lambda.
// Exemple de post-traitement d'une transcription JSON avec Node.js
import fs from 'fs';
import path from 'path';
async function processTranscriptionResult(jsonFilePath) {
// Lire le fichier JSON de résultat
const rawData = fs.readFileSync(jsonFilePath, 'utf8');
const transcriptionResult = JSON.parse(rawData);
// Extraire le texte transcrit
const transcript = transcriptionResult.results.transcripts[0].transcript;
// Extraire les segments par locuteur si disponibles
let speakerSegments = [];
if (transcriptionResult.results.speaker_labels &&
transcriptionResult.results.speaker_labels.segments) {
const segments = transcriptionResult.results.speaker_labels.segments;
const items = transcriptionResult.results.items;
// Créer un mapping pour faciliter l'association des mots aux segments
const wordMap = {};
items.forEach(item => {
if (item.type === 'pronunciation') {
wordMap[item.start_time] = {
word: item.alternatives[0].content,
confidence: parseFloat(item.alternatives[0].confidence)
};
}
});
// Reconstruire la conversation par locuteur
segments.forEach(segment => {
const speakerLabel = segment.speaker_label;
let segmentText = "";
segment.items.forEach(item => {
if (wordMap[item.start_time]) {
segmentText += wordMap[item.start_time].word + " ";
}
});
speakerSegments.push({
speaker: speakerLabel,
startTime: parseFloat(segment.start_time),
endTime: parseFloat(segment.end_time),
text: segmentText.trim()
});
});
}
// Générer un format de sortie structuré
const result = {
fullTranscript: transcript,
speakerSegments: speakerSegments,
metadata: {
jobName: transcriptionResult.jobName,
languageCode: transcriptionResult.results.language_code,
durationSeconds: transcriptionResult.results.duration_seconds || null,
processingTime: new Date().toISOString()
}
};
// Générer des formats de sortie supplémentaires
// 1. Format texte simple
const textOutput = transcript;
fs.writeFileSync(
path.join(path.dirname(jsonFilePath), 'transcript.txt'),
textOutput,
'utf8'
);
// 2. Format SRT (sous-titres)
let srtOutput = "";
let counter = 1;
speakerSegments.forEach(segment => {
// Convertir les timestamps en format SRT (HH:MM:SS,mmm)
const startTime = formatSrtTime(segment.startTime);
const endTime = formatSrtTime(segment.endTime);
srtOutput += `${counter}
`;
srtOutput += `${startTime} --> ${endTime}
`;
srtOutput += `${segment.speaker}: ${segment.text}
`;
counter++;
});
fs.writeFileSync(
path.join(path.dirname(jsonFilePath), 'subtitles.srt'),
srtOutput,
'utf8'
);
// 3. Format JSON structuré
fs.writeFileSync(
path.join(path.dirname(jsonFilePath), 'processed-transcript.json'),
JSON.stringify(result, null, 2),
'utf8'
);
return result;
}
// Fonction utilitaire pour formater les timestamps au format SRT
function formatSrtTime(seconds) {
const hours = Math.floor(seconds / 3600);
const minutes = Math.floor((seconds - (hours * 3600)) / 60);
const secs = Math.floor(seconds - (hours * 3600) - (minutes * 60));
const ms = Math.floor((seconds - Math.floor(seconds)) * 1000);
return `${hours.toString().padStart(2, '0')}:${minutes.toString().padStart(2, '0')}:${secs.toString().padStart(2, '0')},${ms.toString().padStart(3, '0')}`;
}
// Exemple d'utilisation
processTranscriptionResult('./transcriptions/meeting-2023-04-15.json');Fonctionnalités avancées
- Identification des locuteurs (Diarization) - Distingue automatiquement les différents locuteurs dans une conversation
- Vocabulaires personnalisés - Améliore la précision pour les termes spécifiques à un domaine ou des noms propres
- Filtrage de contenu - Peut masquer automatiquement des informations sensibles (PII) comme les numéros de carte de crédit ou les adresses
- Segmentation par canal - Traite séparément les canaux audio pour les conversations téléphoniques
- Détection de langue - Identifie automatiquement la langue parlée dans un enregistrement
- Adaptation au langage - Améliore la précision dans des domaines spécifiques ou pour des accents particuliers
- Sous-titrage à la volée - Génère des sous-titres en temps réel pour le streaming vidéo
Intégration avec d'autres services AWS
AWS Transcribe s'intègre parfaitement avec d'autres services AWS pour créer des solutions complètes :
- Amazon S3 - Pour le stockage des fichiers audio et des résultats de transcription
- Amazon Comprehend - Pour l'analyse de sentiment et l'extraction d'entités du texte transcrit
- Amazon Translate - Pour traduire les transcriptions dans d'autres langues
Amazon Polly - Pour la conversion du texte en parole, permettant de créer un cycle complet- AWS Lambda - Pour automatiser le traitement et l'analyse des transcriptions
- Amazon Connect - Pour l'analyse des appels dans les centres de contact
Cas d'usage
Analyse de centres d'appel
Transcription et analyse des appels clients pour améliorer la formation des agents, identifier les tendances, et extraire des insights sur la satisfaction client et les problèmes récurrents.
Sous-titrage de médias
Création automatique de sous-titres pour vidéos, films et contenus de streaming, améliorant l'accessibilité et permettant le respect des réglementations sur l'accessibilité des médias.
Documentation médicale
Automatisation de la prise de notes médicales, permettant aux professionnels de santé de se concentrer sur les patients plutôt que sur la paperasse, tout en améliorant la précision des dossiers.
Recherche dans les médias
Indexation du contenu audio et vidéo pour permettre la recherche par mots-clés, rendant les archives multimédias aussi faciles à explorer que les documents texte.
Archivage et conformité
Transcription des appels et réunions pour des besoins d'archivage légal et de conformité réglementaire, particulièrement dans les secteurs financier et juridique.
Intelligence des réunions
Transcription automatique des réunions pour générer des comptes-rendus, suivre les actions à entreprendre et permettre aux absents de rattraper efficacement ce qu'ils ont manqué.
