Insanely Fast Whisper: schnelle und effiziente Transkription von Sprache in Text Open-Source-Projekt

insanely-fast-whisper ist ein Audiotranskriptionstool, das das Whisper-Modell von OpenAI mit verschiedenen Optimierungstechniken (z. B. Transformers, Optimum, Flash Attention) kombiniert, um eine Befehlszeilenschnittstelle (CLI) bereitzustellen, die für die schnelle und effiziente Transkription großer Audiomengen entwickelt wurde. Es verwendet das Modell Whisper Large v3 und ist in der Lage, 150 Minuten Audioinhalte in weniger als 98 Sekunden zu transkribieren. Benutzer können weitere Details, Installationsanleitungen und Nutzungshilfen über das GitHub-Repository erfahren.

Multi-Sprecher-Erkennung

pyannote.audio ist ein in Python geschriebenes Open-Source-Toolkit für die Sprechertagebuchführung. Es basiert auf dem PyTorch-Framework für maschinelles Lernen und bietet hochmoderne vortrainierte Modelle und Pipelines zur weiteren Feinabstimmung Ihrer eigenen Daten für eine bessere Leistung.

faster-whisper + pyannote.audio implementiert die Sprechererkennung, indem es einfach die Ergebnisse der beiden Programme kombiniert

Offizielles Lagerhaus: https://github.com/pyannote/pyannote-audio

Funktionsliste

Audiotranskription mit dem Modell Whisper Large v3
Einführung von Transformatoren, Optimum, Flash Attention und anderen Technologien
Bietet eine CLI-Schnittstelle
Unterstützung verschiedener Optimierungstypen und Anzeige von Benchmarks

Hilfe verwenden

Installation: Installation und Konfiguration mit pip
Verwendung: Übergeben Sie Parameter und führen Sie Transkriptionsaufgaben direkt von der Befehlszeile aus
Holen Sie sich Hilfe: Besuchen Sie das GitHub-Repository, um die Dokumentation zu lesen und mit der Community zu sprechen.

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

# Installieren der erforderlichen Bibliotheken

get_ipython().system(‘pip install faster-whisper’)

# Importieren Sie die erforderlichen Bibliotheken

from faster_whisper import available_models

import torch

import ipywidgets as widgets

from IPython.display import display, clear_output

import os # Importieren von Betriebssystembibliotheken zur Handhabung von Dateioperationen

import gc # import Müllsammelbibliothek

# Erkennt automatisch den Gerätetyp und wählt zwischen GPU und CPU

device = “cuda” if torch.cuda.is_available() else “cpu”

model_size = "large-v2" # Standardauswahl der Modellgröße

compute_type = "float16" if device == "cuda" else "float32" # if CPU verwendet wird, dann zu float32 wechseln

# Eine Liste der verfügbaren Modelle erhalten

models_list = available_models()

# Standard-Sprachliste

supported_languages = ['en', 'fr', 'de', 'zh ', '...'] # verwendet die Standardliste der Sprachen

default_languages = 'zh' if 'zh' in supported_languages else supported_languages[0] # Wenn die ein 'zh' in der Liste vorhanden ist, wird es als Standardwert verwendet; andernfalls wird der erste Wert in der Liste verwendet

 

# Erstellen einer GUI-Schnittstelle

model_label = widgets.Label('Modell auswählen:')

model_dropdown = widgets.Dropdown(options=models_list, value=model_size)

language_label = widgets.Label('Sprache:')

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('Rechentyp:')

if device == “cuda”:

    compute_type_options = [‘float16’, ‘int8’]

else:

    compute_type_options = ['float32'] # Wenn CPU, sperren auf 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:') # Neue Bezeichnung für die anfängliche Eingabeaufforderung hinzugefügt

initial_prompt_text = widgets.Text(value=") # Ursprüngliches Eingabefeld für die Eingabeaufforderung hinzugefügt

file_name_text = widgets.Text(description='Dateiname:', value='/content/') # Eingabe des Dateinamens durch den Benutzer

transcribe_button = widgets.Button(description='Transcribe')

output_area = widgets.Output()

 

# Definieren der Übersetzungsfunktion

def transcribe_audio(b):

    with output_area:

        clear_output()

        print("Beginn der Transkription...")

        from faster_whisper import WhisperModel # Dynamischer Import von WhisperModel: Import bei Bedarf, um RAM zu sparen

        try:

            file_name = file_name_text.value # Vom Benutzer eingegebenen Dateinamen verwenden

            initial_prompt = initial_prompt_text.value # Erste Eingabeaufforderung mit Benutzereingabe

            # Sicherstellen, dass das Dokument vorhanden ist

            if not os.path.exists(file_name):

                print(f "Die Datei {Dateiname} existiert nicht, bitte überprüfen Sie, ob der Dateiname und der Pfad korrekt sind.")

                return

            # Erwerb von ausgewählten Modellen

            selected_model = model_dropdown.value

            selected_compute_type = compute_type_dropdown.value

            selected_language = language_dropdown.value

            # Erstellen Sie eine neue Modellinstanz und führen Sie die Übersetzung durch

            model = WhisperModel(selected_model, device=device, compute_type=selected_compute_type)

            try:

                # Übersetztes Audio

                Segmente, info = model.transcribe(Dateiname, beam_size=beam_size_slider.value, language=selected_language, initial_prompt=initial_prompt ) Initiale Prompt-Parameter zu # hinzugefügt

                # Druckergebnisse

                print(“Detected language ‘%s’ with probability %f” % (info.language, info.language_probability))

                for segment in segments:

                    if mode_dropdown.value == ‘normal’:

                        print(“%s ” % (segment.text))

                    elif mode_dropdown.value == ‘timeline’:

                        print(“[%.2fs -> %.2fs] %s” % (segment.start, segment.end, segment.text))

                    sonst: # Untertitel

                        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.end % 1) * 1000))

                        print(“%d\n%s –> %s\n%s\n” % (segment.id, start_time, end_time, segment.text))

            finally:

                # Modellinstanz löschen, um RAM freizugeben

                del model

        except Exception as e:

            print(“An error occurred during transcription:”)

            print(str(e))

        finally:

            # Aufruf der Müllabfuhr

            gc.collect()

        print("Transkription abgeschlossen.")

 

#-Baugruppe GUI-Schnittstelle

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)

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:
if spk != pre_spk and pre_spk is not None and 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
else:
text_cache.append((seg, spk, text))
pre_spk = spk
if len(text_cache) > 0:
merged_spk_text.append(merge_cache(text_cache))
return merged_spk_text

def diarize_text(transcribe_res, diarization_result):
timestamp_texts = get_text_with_timestamp(transcribe_res)
spk_text = add_speaker_info_to_text(timestamp_texts, diarization_result)
res_processed = merge_sentence(spk_text)
return res_processed

def write_to_txt(spk_sent, file):
with open(file, ‘w’) as fp:
for seg, spk, sentence in spk_sent:
line = f'{seg.start:.2f} {seg.end:.2f} {spk} {sentence}\n’
fp.write(line)

 

import torch
import whisper
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

model_path = 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-diarization-3.1″, use_auth_token=”your huggingface token”)
spk_rec_pipeline.to(torch.device(“cuda”))

asr_result, info = asr_model.transcribe(audio, language=”zh”, beam_size=5)
diarization_result = spk_rec_pipeline(audio)

final_result = diarize_text(asr_result, diarization_result)
for segment, spk, sent in final_result:
print(“[%.2fs -> %.2fs] %s %s” % (segment.start, segment.end, sent, spk))

Verwandte Ressourcen

Hauptprojekt: https://github.com/SYSTRAN/faster-whisper

Kurzbezeichnung: https://www.letswrite.tw/colab-faster-whisper/

Video in Untertitel umwandeln: https://github.com/lewangdev/faster-whisper-youtube

Fast Whisper Echtzeit-Sprachtranskription: https://www.kaggle.com/code/xiu0714/faster-whisper

Ein-Klick-Installationspaket

Dieser Inhalt wurde vom Autor versteckt, bitte geben Sie den Verifizierungscode ein, um den Inhalt zu sehen

Captcha:

Bitte achten Sie auf diese Website WeChat öffentliche Nummer, Antwort "CAPTCHA, eine Art von Challenge-Response-Test (Computertechnik)", um den Verifizierungscode zu erhalten. Suchen Sie in WeChat nach "AI-Produktivitätsanwendungen"oder"Artificial9527" oder WeChat Scannen der rechten Seite des QR-Codes kann die Aufmerksamkeit auf diese Website WeChat öffentliche Zahl zu zahlen.