Insanely Fast Whisper : projet open source de transcription rapide et efficace de la parole en texte

Dernières ressources sur l'IAMise à jour il y a 7 mois Cercle de partage de l'IA

2.4K 00

Introduction générale

insanely-fast-whisper est un outil de transcription audio qui combine le modèle Whisper d'OpenAI avec diverses techniques d'optimisation (par exemple Transformers, Optimum, Flash Attention) pour fournir une interface de ligne de commande (CLI) conçue pour transcrire de grandes quantités d'audio rapidement et efficacement. Il utilise le modèle Whisper Large v3 et est capable de transcrire 150 minutes de contenu audio en moins de 98 secondes. Les utilisateurs peuvent obtenir plus de détails, des guides d'installation et une aide à l'utilisation via le dépôt GitHub.

reconnaissance de plusieurs locuteurs
pyannote.audio est une boîte à outils open source pour la diarisation du locuteur écrite en Python. Basé sur le cadre d'apprentissage machine PyTorch, il propose des modèles pré-entraînés de pointe et des pipelines pour affiner vos propres données afin d'obtenir de meilleures performances.
faster-whisper + pyannote.audio implémente la reconnaissance du locuteur, en fait, en combinant simplement les résultats des deux méthodes.
Entrepôt officiel : https://github.com/pyannote/pyannote-audio

Liste des fonctions

Transcription audio à l'aide du modèle Whisper Large v3
Adoption des technologies Transformer, Optimum, Flash Attention et autres
Fournit une interface CLI
Prise en charge de différents types d'optimisation et présentation de données de référence

Utiliser l'aide

Installation : Installation et configuration avec pip
Utilisation : Passer des paramètres et exécuter des tâches de transcription directement à partir de la ligne de commande
Obtenir de l'aide : visitez le dépôt GitHub pour lire la documentation et discuter avec la communauté.

https://github.com/SYSTRAN/faster-whisper项目编写的code google colab

# Installation des bibliothèques nécessaires
get_ipython().system('pip install faster-whisper')
# Importer les bibliothèques nécessaires
from faster_whisper import available_models
torche d'importation
import ipywidgets en tant que widgets
from IPython.display import display, clear_output
import os # Importer les bibliothèques du système d'exploitation pour gérer les opérations sur les fichiers
import gc # import bibliothèque de collecte des déchets
# Détecte automatiquement le type d'appareil et sélectionne le GPU ou le CPU
device = "cuda" if torch.cuda.is_available() else "cpu"
model_size = "large-v2" # Sélection par défaut de la taille du modèle
compute_type = "float16" if device == "cuda" else "float32" # Passage à float32 si le CPU est utilisé
# Obtenir la liste des modèles disponibles
liste_des_modèles = modèles_disponibles()
# Liste des langues par défaut
supported_languages = ['en', 'fr', 'de', 'zh', '...'] # utilise la liste de langues par défaut
default_language = 'zh' if 'zh' in supported_languages else supported_languages[0] # Si 'zh' figure dans la liste, l'utiliser comme valeur par défaut ; sinon, utiliser la première valeur de la liste.

# Création d'une interface GUI
model_label = widgets.Label('Select model:')
model_dropdown = widgets.Dropdown(options=models_list, value=model_size)
language_label = widgets.Label('Language:')
language_dropdown = widgets.Dropdown(options=supported_languages, value=default_language)
beam_size_label = widgets.Label('Beam size:')
beam_size_slider = widgets.IntSlider(value=5, min=1, max=10, step=1)
compute_type_label = widgets.Label('Compute type:')
si device == "cuda".
options de type de calcul = ['float16', 'int8']
d'autre part.
compute_type_options = ['float32'] # Si CPU, verrouillage sur float32
compute_type_dropdown = widgets.Dropdown(options=compute_type_options, value=compute_type)
mode_label = widgets.Label('Format Mode:')
mode_dropdown = widgets.Dropdown(options=['normal', 'timeline', 'subtitle'], value='normal')
initial_prompt_label = widgets.Label('Initial Prompt:') # Ajout d'une nouvelle étiquette pour l'invite initiale
initial_prompt_text = widgets.Text(value='') # Ajout d'une zone de saisie pour l'invite initiale
file_name_text = widgets.Text(description='File name:', value='/content/') # Permettre à l'utilisateur de saisir le nom du fichier
transcribe_button = widgets.Button(description='Transcribe')
output_area = widgets.Output()

# Définition de la fonction de traduction
def transcribe_audio(b).
avec output_area.
clear_output()
print("Début de la transcription...")
from faster_whisper import WhisperModel # Importation dynamique de WhisperModel : importation si nécessaire pour économiser de la RAM
essayer.
file_name = file_name_text.value # Utiliser le nom de fichier saisi par l'utilisateur
initial_prompt = initial_prompt_text.value # Invite initiale utilisant les données de l'utilisateur
# S'assurer de l'existence du document
if not os.path.exists(nom_de_fichier): : if not os.path.exists(nom_de_fichier).
print(f "Le fichier {nom_du_fichier} n'existe pas, veuillez vérifier que le nom du fichier et le chemin d'accès sont corrects")
retour
# Acquisition de modèles sélectionnés
modèle_sélectionné = modèle_dropdown.valeur
selected_compute_type = compute_type_dropdown.value
selected_language = language_dropdown.value
# Créer une nouvelle instance de modèle et effectuer la traduction
model = WhisperModel(selected_model, device=device, compute_type=selected_compute_type)
essayer.
# Audio traduit
segments, info = model.transcribe(file_name, beam_size=beam_size_slider.value, language=selected_language, initial_prompt=initial_prompt ) Paramètres d'invite initiale ajoutés à #
# Résultats d'impression
print("Langue détectée '%s' avec probabilité %f" % (info.language, info.language_probability))
pour segment dans segments :
si mode_dropdown.value == 'normal'.
print("%s " % (segment.texte))
elif mode_dropdown.value == 'timeline'.
print("[%.2fs -> %.2fs] %s" % (segment.start, segment.end, segment.text))
else : sous-titre #
start_time = "{:02d}:{:02d}:{:02d},{:03d}".format(int(segment.start // 3600), int((segment.start % 3600) // 60), int(segment.start % 60), int((segment.start % 1) * 1000))
end_time = "{:02d}:{:02d}:{:02d},{:03d}".format(int(segment.end // 3600), int((segment.end % 3600) // 60), int(segment.end % 60), int((segment. segment.end % 1) * 1000))
print("%d\nTP1T --> %s\nTP1T\n" % (segment.id, start_time, end_time, segment.text))
enfin.
# Supprimer l'instance de modèle pour libérer de la RAM
modèle del
sauf Exception comme e.
print("Une erreur s'est produite pendant la transcription :")
print(str(e))
enfin.
# Appel à la collecte des ordures ménagères
gc.collect()
print("Transcription terminée.")

Interface GUI de l'assemblage #
display(model_label, model_dropdown, language_label, language_dropdown, beam_size_label, beam_size_slider, compute_type_label, compute_ type_dropdown, mode_label, mode_dropdown, initial_prompt_label, initial_prompt_text, file_name_text, transcribe_button, output_area)
transcribe_button.on_click(transcribe_audio)

Exemple de reconnaissance d'un code à plusieurs locuteurs

from pyannote.core import Segment
def get_text_with_timestamp(transcribe_res).
timestamp_texts = []for item in transcribe_res.
start = item.start
end = item.end
text = item.text.strip()
timestamp_texts.append((Segment(start, end), text))
return timestamp_texts
def add_speaker_info_to_text(timestamp_texts, ann): :
spk_text = []for seg, text in timestamp_texts :
spk = ann.crop(seg).argmax()
spk_text.append((seg, spk, text))
return spk_text
def merge_cache(text_cache).
sentence = ''.join([item[-1] for item in text_cache])
spk = text_cache[0][1]start = round(text_cache[0][0].start, 1)
end = round(text_cache[-1][0].end, 1)
return Segment(start, end), spk, sentence
PUNC_SENT_END = [',', '.' , ' ? , '!' , ",", "." , " ?" , " !"]
def merge_sentence(spk_text).
merged_spk_text = []pre_spk = None
text_cache = []for seg, spk, text in spk_text :
si spk ! = pre_spk et pre_spk n'est pas None et len(text_cache) > 0 :.
merged_spk_text.append(merge_cache(text_cache))
text_cache = [(seg, spk, text)]pre_spk = spk
elif text and len(text) > 0 and text[-1] in PUNC_SENT_END :
text_cache.append((seg, spk, text))
merged_spk_text.append(merge_cache(text_cache))
text_cache = []pre_spk = spk
d'autre part.
text_cache.append((seg, spk, text))
pre_spk = spk
si len(text_cache) > 0.
merged_spk_text.append(merge_cache(text_cache))
return merged_spk_text
def diarize_text(transcribe_res, diarisation_result).
timestamp_texts = get_text_with_timestamp(transcribe_res)
spk_text = add_speaker_info_to_text(timestamp_texts, diarisation_result)
res_processed = merge_sentence(spk_text)
return res_processed
def write_to_txt(spk_sent, file).
avec open(file, 'w') as fp.
pour seg, spk, sentence dans spk_sent.
line = f'{seg.start :.2f} {seg.end :.2f} {spk} {sentence}\n'
fp.write(line)

torche d'importation
l'importation chuchoter
import numpy as np
from pydub import AudioSegment
from loguru import logger
from faster_whisper import WhisperModel
from pyannote.audio import Pipeline
from pyannote.audio import Audio
from common.error.import ErrorCode
chemin_modèle = config["asr"]["faster-whisper-large-v3"]
# Test Audio : https://isv-data.oss-cn-hangzhou.aliyuncs.com/ics/MaaS/ASR/test_audio/asr_speaker_demo.wav
audio = ". /test/asr/data/asr_speaker_demo.wav"
asr_model = WhisperModel(model_path, device="cuda", compute_type="float16")
spk_rec_pipeline = Pipeline.from_pretrained("pyannote/speaker-diarisation-3.1", use_auth_token="your huggingface jeton")
spk_rec_pipeline.to(torch.device("cuda"))
asr_result, info = asr_model.transcribe(audio, language="zh", beam_size=5)
résultat de la diarisation = spk_rec_pipeline(audio)
résultat final = diarize_text(asr_result, diarisation_result)
pour segment, spk, sent dans final_result :
print("[%.2fs -> %.2fs] %s %s" % (segment.start, segment.end, sent, spk))