web-dev-qa-db-fra.com

Fichier audio de discours divisé sur des mots en python

Je pense que c'est un problème assez commun, mais je n'ai pas encore trouvé de réponse appropriée. J'ai beaucoup de fichiers audio de paroles humaines que j'aimerais briser sur les mots, ce qui peut être fait de manière heuristique en examinant les pauses dans la forme d'onde, mais quelqu'un peut-il m'indiquer une fonction/bibliothèque en python qui le fait automatiquement? 

pythonaudiospeech-recognitionspeechheuristics
14
user3059201

Une méthode plus simple consiste à utiliser pydub module. ajout récent de utilités silencieuses fait tout le travail lourd comme setting up silence threahold, setting up silence length. etc et simplifie le code de manière significative par opposition aux autres méthodes mentionnées.

Voici une implémentation de démonstration inspirée de ici

Installer:

J'avais un fichier audio avec des lettres anglaises parlées de A à Z dans le fichier "a-z.wav". Un sous-répertoire splitAudio a été créé dans le répertoire de travail en cours. Lors de l’exécution du code de démonstration, les fichiers ont été divisés en 26 fichiers distincts, chaque fichier audio stockant chaque syllabe. 

Observations: Certaines syllabes ont été coupées, nécessitant éventuellement une modification des paramètres suivants,
min_silence_len=500
silence_thresh=-16 

On peut vouloir les adapter à ses propres besoins.

Code de démonstration:

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

Sortie:

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

Utilisez IBM STT . En utilisant timestamps=true, vous obtiendrez le mot de rupture avec lorsque le système détectera qu’il a été parlé.

Il y a beaucoup d'autres fonctionnalités intéressantes comme Word_alternatives_threshold pour obtenir d'autres possibilités de mots et Word_confidence pour obtenir la confiance avec laquelle le système prédit le mot. Définissez Word_alternatives_threshold entre 0,1 et 0,01 pour avoir une idée réelle.

Cela nécessite une connexion, à la suite de quoi vous pouvez utiliser le nom d'utilisateur et le mot de passe générés.

IBM STT fait déjà partie du module de reconnaissance vocale mentionné, mais pour obtenir l’horodatage de Word, vous devez modifier la fonction.

Un formulaire extrait et modifié ressemble à:

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

Vous pourriez regarder Audiolab Il fournit une API décente pour convertir les échantillons de voix en numpy arrays . Le module Audiolab utilise la bibliothèque C++ libsndfile pour faire le gros du travail.

Vous pouvez ensuite analyser les tableaux pour rechercher les valeurs les plus faibles afin de rechercher les pauses.

2
Piyush Sharma

pyAudioAnalysis peut segmenter un fichier audio si les mots sont clairement séparés (c'est rarement le cas dans le langage naturel). Le paquet est relativement facile à utiliser:

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

Plus de détails sur mon blog .

0
epo3