BetterWhisperX : reconnaissance vocale automatique séparée du locuteur, fournissant des horodatages très précis au niveau des mots.

Introduction générale

BetterWhisperX est une version optimisée du projet WhisperX qui vise à fournir des services de reconnaissance automatique de la parole (ASR) efficaces et précis. BetterWhisperX intègre un certain nombre de technologies avancées, notamment l'alignement forcé au niveau des phonèmes, le traitement par lots basé sur l'activité vocale et la séparation des locuteurs. L'outil prend non seulement en charge la transcription à grande vitesse (jusqu'à 70 fois la vitesse en temps réel lors de l'utilisation du modèle large-v2), mais il fournit également un horodatage précis au niveau des mots et une reconnaissance de plusieurs locuteurs. Le système utilise faster-whisper comme backend, ce qui nécessite moins de mémoire GPU pour traiter même les grands modèles, offrant ainsi un rapport performance/efficacité très élevé.

Liste des fonctions

• Conversion rapide de la parole en texteLa transcription en temps réel : Utilisation du grand modèle large-v2, qui permet une transcription en temps réel 70x.
• Horodatage au niveau des motsLe logiciel de gestion de l'information : fournit des horodatages précis au niveau des mots grâce à l'alignement wav2vec2.
• reconnaissance de plusieurs locuteurs: Séparation et étiquetage des locuteurs avec pyannote-audio.
• Détection de l'activité vocaleLe projet a permis de réduire les erreurs d'identification et le traitement par lots, sans augmentation significative du taux d'erreur.
• inférence par lotsLes services de traitement par lots permettent d'améliorer l'efficacité du traitement.
• la compatibilitéPrise en charge de PyTorch 2.0 et de Python 3.10 pour un large éventail d'environnements.

Utiliser l'aide

Procédure d'utilisation détaillée

1. Préparation des fichiers audioLe format du fichier audio doit être WAV ou MP3 et la qualité du son doit être claire.
2. Modèles de chargementLe modèle est sélectionné en fonction des besoins (par exemple, grand-v2) et chargé en mémoire.
3. Effectuer la transcriptionTranscription : Appeler la fonction de transcription pour effectuer le traitement de la parole en texte et obtenir les résultats préliminaires de la transcription.
4. Horodatage alignéAlignement de l'horodatage au niveau du mot des résultats de la transcription à l'aide de la fonction align pour garantir l'exactitude de l'horodatage.
5. séparation des haut-parleursAppeler la fonction diarize pour la reconnaissance de plusieurs locuteurs afin d'obtenir l'étiquette et le fragment de discours correspondant à chaque locuteur.
6. Résultat SortieEnregistrer le résultat final dans un fichier texte ou au format JSON pour un traitement et une analyse ultérieurs.

1. préparation à l'environnement

1. Exigences du système :
   • Environnement Python 3.10 (mamba ou conda est recommandé pour créer un environnement virtuel)
   • Prise en charge de CUDA et cuDNN (nécessaire pour l'accélération GPU)
   • Boîte à outils FFmpeg
2. Étapes de l'installation :

# 创建 Python 环境
mamba create -n whisperx python=3.10
mamba activate whisperx
# 安装 CUDA 和 cuDNN
mamba install cuda cudnn
# 安装 BetterWhisperX
pip install git+https://github.com/federicotorrielli/BetterWhisperX.git

2. utilisation de base

1. Utilisation de la ligne de commande :

# 基础转录（英语）
whisperx audio.wav
# 使用大模型和更高精度
whisperx audio.wav --model large-v2 --align_model WAV2VEC2_ASR_LARGE_LV60K_960H --batch_size 4
# 启用说话人分离
whisperx audio.wav --model large-v2 --diarize --highlight_words True
# CPU 模式（适用于 Mac OS X）
whisperx audio.wav --compute_type int8

2. Appels de code Python :

import whisperx
import gc
device = "cuda"
audio_file = "audio.mp3"
batch_size = 16  # GPU 内存不足时可降低
compute_type = "float16"  # 内存不足可改用 "int8"
# 1. 加载模型并转录
model = whisperx.load_model("large-v2", device, compute_type=compute_type)
audio = whisperx.load_audio(audio_file)
result = model.transcribe(audio, batch_size=batch_size)
# 2. 音素对齐
model_a, metadata = whisperx.load_align_model(language_code=result["language"], device=device)
result = whisperx.align(result["segments"], model_a, metadata, audio, device)
# 3. 说话人分离（需要 Hugging Face token）
diarize_model = whisperx.DiarizationPipeline(use_auth_token=YOUR_HF_TOKEN, device=device)
diarize_segments = diarize_model(audio)
result = whisperx.assign_word_speakers(diarize_segments, result)

3) Recommandations pour l'optimisation des performances

1. Optimisation de la mémoire du GPU :
   • Réduire la taille des lots (batch_size)
   • Utilisation de modèles plus petits (par exemple, une base au lieu d'une grande)
   • Sélectionner le type de calcul de la légèreté (int8)
2. Support multilingue :
   • Langues prises en charge par défaut : anglais, français, allemand, espagnol, italien, japonais, chinois, néerlandais, ukrainien, portugais
   • Spécifiez la langue à utiliser :--language de(Exemple en allemand)

4) Précautions

• Les horodatages peuvent ne pas être suffisamment précis pour les caractères spéciaux (par exemple, les chiffres, les symboles monétaires).
• La reconnaissance des scènes où plusieurs personnes parlent en même temps peut être inefficace.
• La séparation des enceintes est encore en cours d'optimisation
• Des jetons d'accès à Hugging Face sont nécessaires pour utiliser la fonction de séparation du locuteur.
• Assurer la compatibilité des pilotes GPU et des versions CUDA