it-swarm.com.de

Aufgeteilte Sprach-Audiodatei für Wörter in Python

Ich denke, dass dies ein ziemlich häufiges Problem ist, aber ich habe noch keine passende Antwort gefunden. Ich habe viele Audiodateien menschlicher Sprache, die ich gerne mit Worten unterbrechen möchte. Dies kann heuristisch durch Anzeigen von Pausen in der Wellenform erfolgen. Kann mir jemand eine Funktion/Bibliothek in Python zeigen, die dies automatisch tut? 

14
user3059201

Ein einfacher Weg, dies zu tun, ist die Verwendung von pydub module. Kürzlich hinzugefügte Silent Utilities erledigt alle schweren Aufgaben wie setting up silence threahold, setting up silence length. usw. und vereinfacht den Code erheblich im Gegensatz zu den anderen genannten Methoden.

Hier ist eine Demo-Implementierung, Inspiration von hier

Konfiguration:

Ich hatte eine Audiodatei mit gesprochenen englischen Buchstaben von A bis Z in der Datei "a-z.wav". Im aktuellen Arbeitsverzeichnis wurde ein Unterverzeichnis splitAudio angelegt. Bei der Ausführung des Demo-Codes wurden die Dateien in 26 separate Dateien aufgeteilt, wobei jede Audiodatei jede Silbe speichert. 

Beobachtungen: Einige der Silben wurden abgeschnitten, möglicherweise müssen die folgenden Parameter geändert werden.
min_silence_len=500
silence_thresh=-16 

Man möchte diese an die eigenen Anforderungen anpassen.

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

Ausgabe:

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
>>> 
15
Anil_M

Verwenden Sie IBM STT . Mit timestamps=true wird das Wort getrennt, sobald das System erkennt, dass es gesprochen wurde.

Es gibt viele andere coole Features wie Word_alternatives_threshold, um andere Möglichkeiten von Wörtern zu erhalten, und Word_confidence, um das Vertrauen zu gewinnen, mit dem das System das Wort vorhersagt. Setzen Sie Word_alternatives_threshold zwischen (0,1 und 0,01), um eine echte Vorstellung zu erhalten.

Hierfür müssen Sie sich anmelden. Danach können Sie den generierten Benutzernamen und das Kennwort verwenden.

IBM STT ist bereits Bestandteil des erwähnten Spracherkennungsmoduls. Um den Zeitstempel von Word zu erhalten, müssen Sie die Funktion jedoch ändern.

Ein extrahiertes und modifiziertes Formular sieht folgendermaßen aus:

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

Sie könnten sich Audiolab ansehen. Sie bietet eine anständige API, um die Sprachproben in numpy Arrays umzuwandeln .. _ Das Audiolab-Modul verwendet die libsndfile C++ - Bibliothek, um das schwere Anheben durchzuführen.

Sie können dann die Arrays analysieren, um die niedrigeren Werte zu finden, um die Pausen zu finden.

2
Piyush Sharma

pyAudioAnalysis kann eine Audiodatei segmentieren, wenn die Wörter klar voneinander getrennt sind (dies ist bei natürlicher Sprache selten der Fall). Das Paket ist relativ einfach zu benutzen:

python pyAudioAnalysis/pyAudioAnalysis/audioAnalysis.py silenceRemoval -i SPEECH_AUDIO_FILE_TO_SPLIT.mp3 --smoothing 1.0 --weight 0.3

Weitere Details in meinem blog .

0
epo3