Split-Sprach-Audiodatei über Wörter in Python

Question

Ich fühle mich wie das ist ein ziemlich häufiges Problem, aber ich habe noch keine passende Antwort gefunden. Ich habe viele Audiodateien der menschlichen Sprache, die ich gerne zerbrechen würde, was man heuristisch machen kann, indem man sich Pausen in der Wellenform ansieht, aber kann mir jemand auf eine Funktion/Bibliothek in Python verweisen, die das automatisch macht?

Answer 1

Sie könnten Audiolab betrachten Es bietet eine anständige API, um die Sprachproben in numpy Arrays zu konvertieren. Das Audiolab-Modul verwendet die Bibliothek libsndfile C++, um das Heavy-Lifting durchzuführen.

Sie können die Arrays analysieren, um die niedrigeren Werte für die Pausen zu finden.

Answer 2

Eine einfachere Methode ist die Verwendung des Moduls pydub. Die jüngste Hinzufügung von silent utilities macht das ganze schwere Heben wie setting up silence threahold, setting up silence length. usw. und vereinfacht den Code deutlich im Gegensatz zu anderen genannten Methoden.

Hier eine Demo-Implementierung, inspiriert von here

Setup:

ich mit gesprochenen Englisch Briefen von A zu Z in der Datei "a-z.wav", um eine Audiodatei hatte. Im aktuellen Arbeitsverzeichnis wurde ein Unterverzeichnis splitAudio angelegt. Nach dem Ausführen des Demo-Codes wurden die Dateien in 26 separate Dateien aufgeteilt, wobei jede Audiodatei jede Silbe enthielt.

Beobachtungen: Einige der Silben wurden abgeschnitten, möglicherweise Änderung der folgenden Parameter benötigen,
min_silence_len=500
silence_thresh=-16

Eine abzustimmen eigene Anforderung des einen dieser wollen kann.

Demo-Code:

from pydub import AudioSegment 
from pydub.silence import split_on_silence 

sound_file = AudioSegment.from_wav("a-z.wav") 
audio_chunks = split_on_silence(sound_file, 
    # must be silent for at least half a second 
    min_silence_len=500, 

    # consider it silent if quieter than -16 dBFS 
    silence_thresh=-16 
) 

for i, chunk in enumerate(audio_chunks): 

    out_file = ".//splitAudio//chunk{0}.wav".format(i) 
    print "exporting", out_file 
    chunk.export(out_file, format="wav") 

Ausgang:

Python 2.7.9 (default, Dec 10 2014, 12:24:55) [MSC v.1500 32 bit (Intel)] on win32 
Type "copyright", "credits" or "license()" for more information. 
>>> ================================ RESTART ================================ 
>>> 
exporting .//splitAudio//chunk0.wav 
exporting .//splitAudio//chunk1.wav 
exporting .//splitAudio//chunk2.wav 
exporting .//splitAudio//chunk3.wav 
exporting .//splitAudio//chunk4.wav 
exporting .//splitAudio//chunk5.wav 
exporting .//splitAudio//chunk6.wav 
exporting .//splitAudio//chunk7.wav 
exporting .//splitAudio//chunk8.wav 
exporting .//splitAudio//chunk9.wav 
exporting .//splitAudio//chunk10.wav 
exporting .//splitAudio//chunk11.wav 
exporting .//splitAudio//chunk12.wav 
exporting .//splitAudio//chunk13.wav 
exporting .//splitAudio//chunk14.wav 
exporting .//splitAudio//chunk15.wav 
exporting .//splitAudio//chunk16.wav 
exporting .//splitAudio//chunk17.wav 
exporting .//splitAudio//chunk18.wav 
exporting .//splitAudio//chunk19.wav 
exporting .//splitAudio//chunk20.wav 
exporting .//splitAudio//chunk21.wav 
exporting .//splitAudio//chunk22.wav 
exporting .//splitAudio//chunk23.wav 
exporting .//splitAudio//chunk24.wav 
exporting .//splitAudio//chunk25.wav 
exporting .//splitAudio//chunk26.wav 
>>> 

Answer 3

Verwendung IBM STT. Mit timestamps=true erhalten Sie das Wort zerbrechen zusammen mit, wenn das System erkennt, dass sie gesprochen wurden.

Es gibt viele andere coole Funktionen wie word_alternatives_threshold, um andere Möglichkeiten der Wörter und word_confidence zu bekommen, um das Vertrauen zu erhalten, mit dem das System das Wort vorhersagt. Stellen Sie word_alternatives_threshold zwischen (0,1 und 0,01) ein, um eine echte Idee zu erhalten.

Dies erfordert die Anmeldung, wonach Sie den Benutzernamen und das Passwort verwenden können.

Der IBM STT ist bereits Teil des Spracherkennungsmoduls, aber um das Wort Zeitstempel zu erhalten, müssen Sie die Funktion ändern.

Ein extrahiert und modifizierte Form wie folgt aussieht:

def extracted_from_sr_recognize_ibm(audio_data, username=IBM_USERNAME, password=IBM_PASSWORD, language="en-US", show_all=False, timestamps=False, 
           word_confidence=False, word_alternatives_threshold=0.1): 
    assert isinstance(username, str), "``username`` must be a string" 
    assert isinstance(password, str), "``password`` must be a string" 

    flac_data = audio_data.get_flac_data(
     convert_rate=None if audio_data.sample_rate >= 16000 else 16000, # audio samples should be at least 16 kHz 
     convert_width=None if audio_data.sample_width >= 2 else 2 # audio samples should be at least 16-bit 
    ) 
    url = "https://stream-fra.watsonplatform.net/speech-to-text/api/v1/recognize?{}".format(urlencode({ 
     "profanity_filter": "false", 
     "continuous": "true", 
     "model": "{}_BroadbandModel".format(language), 
     "timestamps": "{}".format(str(timestamps).lower()), 
     "word_confidence": "{}".format(str(word_confidence).lower()), 
     "word_alternatives_threshold": "{}".format(word_alternatives_threshold) 
    })) 
    request = Request(url, data=flac_data, headers={ 
     "Content-Type": "audio/x-flac", 
     "X-Watson-Learning-Opt-Out": "true", # prevent requests from being logged, for improved privacy 
    }) 
    authorization_value = base64.standard_b64encode("{}:{}".format(username, password).encode("utf-8")).decode("utf-8") 
    request.add_header("Authorization", "Basic {}".format(authorization_value)) 

    try: 
     response = urlopen(request, timeout=None) 
    except HTTPError as e: 
     raise sr.RequestError("recognition request failed: {}".format(e.reason)) 
    except URLError as e: 
     raise sr.RequestError("recognition connection failed: {}".format(e.reason)) 
    response_text = response.read().decode("utf-8") 
    result = json.loads(response_text) 

    # return results 
    if show_all: return result 
    if "results" not in result or len(result["results"]) < 1 or "alternatives" not in result["results"][0]: 
     raise Exception("Unknown Value Exception") 

    transcription = [] 
    for utterance in result["results"]: 
     if "alternatives" not in utterance: 
      raise Exception("Unknown Value Exception. No Alternatives returned") 
     for hypothesis in utterance["alternatives"]: 
      if "transcript" in hypothesis: 
       transcription.append(hypothesis["transcript"]) 
    return "\n".join(transcription)