Whisper transcription_and_diarization speaker identification
1.0.0
So verwenden Sie Openais -Flüster
Whisper ist ein hochmodernes Spracherkennungssystem von OpenAI, das auf 680.000 Stunden mehrsprachiger und multitasking beaufsichtigter Daten aus dem Web geschult wurde. Dieser große und vielfältige Datensatz führt zu einer verbesserten Robustheit gegenüber Akzenten, Hintergrundrauschen und technischer Sprache. Darüber hinaus ermöglicht es Transkription in mehreren Sprachen sowie Übersetzung von diesen Sprachen ins Englische. OpenAI veröffentlichte die Modelle und den Code als Grundlage für den Aufbau nützlicher Anwendungen, die die Spracherkennung nutzen.
Ein großer Nachteil von Whisper ist jedoch, dass es Ihnen nicht sagen kann, wer in einem Gespräch spricht. Das ist ein Problem bei der Analyse von Gesprächen. Hier kommt die Diarisierung ins Spiel. Diarisierung ist der Prozess der Ermittlung, wer in einem Gespräch spricht.
In diesem Tutorial lernen Sie, wie Sie die Lautsprecher identifizieren und sie dann mit den Transkriptionen von Whisper abschließen. Wir werden pyannote-audio verwenden, um dies zu erreichen. Fangen wir an!
Zunächst müssen wir die Audiodatei vorbereiten. Wir werden den ersten 20 Minuten des Lex Fridmans -Podcasts mit Yann Download verwenden. Um das Video herunterzuladen und das Audio zu extrahieren, werden wir yt-dlp -Paket verwenden.
! pip install -U yt-dlpWir werden auch FFMPEG installiert
! wget -O - -q https://github.com/yt-dlp/FFmpeg-Builds/releases/download/latest/ffmpeg-master-latest-linux64-gpl.tar.xz | xz -qdc | tar -xJetzt können wir über die Befehlszeile den tatsächlichen Download und die Audioextraktion durchführen.
! yt-dlp -xv --ffmpeg-location ffmpeg-master-latest-linux64-gpl/bin --audio-format wav -o download.wav -- https://youtu.be/SGzMElJ11Cc Jetzt haben wir die download.wav -Datei in unserem Arbeitsverzeichnis. Lassen Sie uns die ersten 20 Minuten des Audios schneiden. Wir können das PyDub -Paket dafür mit nur wenigen Codezeilen verwenden.
! pip install pydub from pydub import AudioSegment
t1 = 0 * 1000 # works in milliseconds
t2 = 20 * 60 * 1000
newAudio = AudioSegment . from_wav ( "download.wav" )
a = newAudio [ t1 : t2 ]
a . export ( "audio.wav" , format = "wav" ) audio.wav ist jetzt die ersten 20 Minuten der Audiodatei.
pyannote.audio ist ein Open-Source-Toolkit, das in Python für die Sprecherdurchfall geschrieben wurde. Basierend auf dem Framework für maschinelles Lernen von Pytorch lernt es eine Reihe von trainierbaren End-to-End-Bausteinen, die kombiniert und gemeinsam optimiert werden können, um Lautsprecherdiarisierungsleitungen aufzubauen. pyannote.audio wird außerdem mit vorbereiteten Modellen und Pipelines geliefert, die eine Vielzahl von Domänen für die Erkennung von Sprachaktivitäten, die Segmentierung von Sprechern, eine überlappende Spracherkennung und die Einbettung von Sprechern für die meisten von ihnen abdecken.
Installieren von Pyannote und Ausführen auf dem Video -Audio, um die Durchfälle zu generieren.
! pip install pyannote.audio from pyannote . audio import Pipeline
pipeline = Pipeline . from_pretrained ( 'pyannote/speaker-diarization' ) DEMO_FILE = { 'uri' : 'blabal' , 'audio' : 'audio.wav' }
dz = pipeline ( DEMO_FILE )
with open ( "diarization.txt" , "w" ) as text_file :
text_file . write ( str ( dz ))Lassen Sie uns dies ausdrucken, um zu sehen, wie es aussieht.
print(*list(dz.itertracks(yield_label = True))[:10], sep="n")
Die Ausgabe:
(<Segment(2.03344, 36.8128)>, 0, 'SPEAKER_00')
(<Segment(38.1122, 51.3759)>, 0, 'SPEAKER_00')
(<Segment(51.8653, 90.2053)>, 1, 'SPEAKER_01')
(<Segment(91.2853, 92.9391)>, 1, 'SPEAKER_01')
(<Segment(94.8628, 116.497)>, 0, 'SPEAKER_00')
(<Segment(116.497, 124.124)>, 1, 'SPEAKER_01')
(<Segment(124.192, 151.597)>, 1, 'SPEAKER_01')
(<Segment(152.018, 179.12)>, 1, 'SPEAKER_01')
(<Segment(180.318, 194.037)>, 1, 'SPEAKER_01')
(<Segment(195.016, 207.385)>, 0, 'SPEAKER_00')
Das sieht schon ziemlich gut aus, aber lassen Sie uns die Daten ein wenig reinigen:
def millisec ( timeStr ):
spl = timeStr . split ( ":" )
s = ( int )(( int ( spl [ 0 ]) * 60 * 60 + int ( spl [ 1 ]) * 60 + float ( spl [ 2 ]) ) * 1000 )
return s
import re
dz = open ( 'diarization.txt' ). read (). splitlines ()
dzList = []
for l in dz :
start , end = tuple ( re . findall ( '[0-9]+:[0-9]+:[0-9]+.[0-9]+' , string = l ))
start = millisec ( start ) - spacermilli
end = millisec ( end ) - spacermilli
lex = not re . findall ( 'SPEAKER_01' , string = l )
dzList . append ([ start , end , lex ])
print ( * dzList [: 10 ], sep = ' n ' ) [33, 34812, True]
[36112, 49375, True]
[49865, 88205, False]
[89285, 90939, False]
[92862, 114496, True]
[114496, 122124, False]
[122191, 149596, False]
[150018, 177119, False]
[178317, 192037, False]
[193015, 205385, True]
Jetzt haben wir die Diarisierungsdaten in einer Liste. Die ersten beiden Zahlen sind die Start- und Endzeit des Lautsprechersegments in Millisekunden. Die dritte Nummer ist ein Boolescher, der uns sagt, ob der Sprecher Lex ist oder nicht.
Als nächstes werden wir die Audio -Segements gemäß der Diarisierung mit einem Abstandshalter als Trennzeichen anschließen.
from pydub import AudioSegment
import re
sounds = spacer
segments = []
dz = open ( 'diarization.txt' ). read (). splitlines ()
for l in dz :
start , end = tuple ( re . findall ( '[0-9]+:[0-9]+:[0-9]+.[0-9]+' , string = l ))
start = int ( millisec ( start )) #milliseconds
end = int ( millisec ( end )) #milliseconds
segments . append ( len ( sounds ))
sounds = sounds . append ( audio [ start : end ], crossfade = 0 )
sounds = sounds . append ( spacer , crossfade = 0 )
sounds . export ( "dz.wav" , format = "wav" ) #Exports to a wav file in the current path. print ( segments [: 8 ])[2000, 38779, 54042, 94382, 98036, 121670, 131297, 160702]Als nächstes werden wir Whisper verwenden, um die verschiedenen Segmente der Audiodatei zu transkribieren. Wichtig: Es gibt einen Versionskonflikt mit Pyannote.audio, was zu einem Fehler führt. Unsere Problemumgehung ist es, zuerst Pyannote zu laufen und dann zu flüstern. Sie können den Fehler sicher ignorieren.
Installieren von Open AI Whisper.
! pip install git+https://github.com/openai/whisper.git Ausführen von Open AI Whisper auf der vorbereiteten Audiodatei. Es schreibt die Transkription in eine Datei. Sie können die Modellgröße an Ihre Anforderungen anpassen. Sie können alle Modelle auf der Modellkarte auf GitHub finden.
! whisper dz.wav --language en --model base [00:00.000 --> 00:04.720] The following is a conversation with Yann LeCun,
[00:04.720 --> 00:06.560] his second time on the podcast.
[00:06.560 --> 00:11.160] He is the chief AI scientist at Meta, formerly Facebook,
[00:11.160 --> 00:15.040] professor at NYU, touring award winner,
[00:15.040 --> 00:17.600] one of the seminal figures in the history
[00:17.600 --> 00:20.460] of machine learning and artificial intelligence,
...
Um mit .vtt-Dateien zu arbeiten, müssen wir die WebVTT-Py-Bibliothek installieren.
! pip install -U webvtt-pySchauen wir uns die Daten an:
import webvtt
captions = [[( int )( millisec ( caption . start )), ( int )( millisec ( caption . end )), caption . text ] for caption in webvtt . read ( 'dz.wav.vtt' )]
print ( * captions [: 8 ], sep = ' n ' ) [0, 4720, 'The following is a conversation with Yann LeCun,']
[4720, 6560, 'his second time on the podcast.']
[6560, 11160, 'He is the chief AI scientist at Meta, formerly Facebook,']
[11160, 15040, 'professor at NYU, touring award winner,']
[15040, 17600, 'one of the seminal figures in the history']
[17600, 20460, 'of machine learning and artificial intelligence,']
[20460, 23940, 'and someone who is brilliant and opinionated']
[23940, 25400, 'in the best kind of way,']
...
Als nächstes werden wir jede Transkriptionslinie mit einigen Durchfällen übereinstimmen und alles anweisen, indem wir eine HTML -Datei generieren. Um das richtige Timing zu erhalten, sollten wir uns um die Teile im Original -Audio kümmern, die sich in keinem Diarisierungssegment befanden. Wir haben ein neues DIV für jedes Segment in unserem Audio an.
# we need this fore our HTML file (basicly just some styling)
preS = '<!DOCTYPE html>n<html lang="en">n <head>n <meta charset="UTF-8">n <meta name="viewport" content="width=device-width, initial-scale=1.0">n <meta http-equiv="X-UA-Compatible" content="ie=edge">n <title>Lexicap</title>n <style>n body {n font-family: sans-serif;n font-size: 18px;n color: #111;n padding: 0 0 1em 0;n }n .l {n color: #050;n }n .s {n display: inline-block;n }n .e {n display: inline-block;n }n .t {n display: inline-block;n }n #player {nttposition: sticky;ntttop: 20px;nttfloat: right;nt}n </style>n </head>n <body>n <h2>Yann LeCun: Dark Matter of Intelligence and Self-Supervised Learning | Lex Fridman Podcast #258</h2>n <div id="player"></div>n <script>n var tag = document.createElement('script');n tag.src = "https://www.youtube.com/iframe_api";n var firstScriptTag = document.getElementsByTagName('script')[0];n firstScriptTag.parentNode.insertBefore(tag, firstScriptTag);n var player;n function onYouTubeIframeAPIReady() {n player = new YT.Player('player', {n height: '210',n width: '340',n videoId: 'SGzMElJ11Cc',n });n }n function setCurrentTime(timepoint) {n player.seekTo(timepoint);n player.playVideo();n }n </script><br>n'
postS = 't</body>n</html>'
from datetime import timedelta
html = list(preS)
for i in range(len(segments)):
idx = 0
for idx in range(len(captions)):
if captions[idx][0] >= (segments[i] - spacermilli):
break;
while (idx < (len(captions))) and ((i == len(segments) - 1) or (captions[idx][1] < segments[i+1])):
c = captions[idx]
start = dzList[i][0] + (c[0] -segments[i])
if start < 0:
start = 0
idx += 1
start = start / 1000.0
startStr = '{0:02d}:{1:02d}:{2:02.2f}'.format((int)(start // 3600),
(int)(start % 3600 // 60),
start % 60)
html.append('ttt<div class="c">n')
html.append(f'tttt<a class="l" href="#{startStr}" id="{startStr}">link</a> |n')
html.append(f'tttt<div class="s"><a href="javascript:void(0);" onclick=setCurrentTime({int(start)})>{startStr}</a></div>n')
html.append(f'tttt<div class="t">{"[Lex]" if dzList[i][2] else "[Yann]"} {c[2]}</div>n')
html.append('ttt</div>nn')
html.append(postS)
s = "".join(html)
with open("lexicap.html", "w") as text_file:
text_file.write(s)
print(s)
Auf Lablab Discord diskutieren wir dieses Repo und viele andere Themen, die sich auf künstliche Intelligenz beziehen! Checkout bevorstehende künstliche Intelligenz -Hackathons Event
