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

Importfackel

ipywidgets als Widgets importieren

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”  # 默认选择模型大小

compute_type = “float16” if device == “cuda” else “float32”  # 如果使用CPU，则切换到float32

# Eine Liste der verfügbaren Modelle erhalten

models_list = available_models()

# Standard-Sprachliste

supported_languages = [‘en’, ‘fr’, ‘de’, ‘zh’, ‘…’]  # 使用默认的语言列表

default_language = ‘zh’ if ‘zh’ in supported_languages else supported_languages[0]  # 如果列表中有’zh’，则使用它作为默认值；否则使用列表中的第一个值

 

# Erstellen einer GUI-Schnittstelle

model_label = widgets.Label(‘选择模型:’)

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

language_label = widgets.Label(‘语言:’)

language_dropdown = widgets.Dropdown(options=supported_languages, value=default_language)

beam_size_label = widgets.Label(‘Beam大小:’)

beam_size_slider = widgets.IntSlider(value=5, min=1, max=10, step=1)

compute_type_label = widgets.Label(‘计算类型:’)

if device == “cuda”:

    compute_type_options = [‘float16’, ‘int8’]

sonst.

    compute_type_options = [‘float32’]  # 如果是CPU，则锁定为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_text = widgets.Text(value=”)  # 新增的初始提示输入框

file_name_text = widgets.Text(description=’文件名:’, value=’/content/’)  # 允许用户输入文件名

transcribe_button = widgets.Button(description=’转译’)

output_area = widgets.Output()

 

# Definieren der Übersetzungsfunktion

def transcribe_audio(b).

    mit output_area.

        clear_output()

        print(“开始转录…”)

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

        versuchen.

            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):: if not os.path.exists(file_name).

                print(f”文件 {file_name} 不存在，请检查文件名和路径是否正确。”)

                return

            # Erwerb von ausgewählten Modellen

            ausgewähltes_Modell = 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=Gerät, compute_type=selected_compute_type)

            versuchen.

                # Ü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))

                für Segment in Segmente:

                    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))

            endlich.

                # Modellinstanz löschen, um RAM freizugeben

                Del-Modell

        außer Ausnahme wie e.

            print(“An error occurred during transcription:”)

            print(str(e))

        endlich.

            # Aufruf der Müllabfuhr

            gc.collect()

        print(“转录完成。”)

 

#-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 zeitstempel_texte

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(Anfang, Ende), spk, Satz

PUNC_SENT_END = [‘,’, ‘.’, ‘?’, ‘!’, “，”, “。”, “？”, “！”]

def merge_sentence(spk_text).
merged_spk_text = []
pre_spk = Keine
text_cache = []
für seg, spk, text in spk_text:
wenn spk ! = pre_spk und pre_spk ist nicht None und len(text_cache) > 0:.
merged_spk_text.append(merge_cache(text_cache))
text_cache = [(seg, spk, text)]
pre_spk = spk

elif text und len(text) > 0 und 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
sonst.
text_cache.append((seg, spk, text))
pre_spk = spk
wenn 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).
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(Zeile)

 

Importfackel
importieren Flüstern
numpy als np importieren
von pydub import AudioSegment
von loguru importieren 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)
diarisation_result = spk_rec_pipeline(audio)

final_result = diarize_text(asr_result, diarisation_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"Künstlich9527" oder WeChat Scannen der rechten Seite des QR-Codes kann die Aufmerksamkeit auf diese Website WeChat öffentliche Zahl zu zahlen.