File audio parlato diviso per parole in python

Question

Mi sembra che questo sia un problema abbastanza comune ma non ho ancora trovato una risposta adeguata. Ho molti file audio del linguaggio umano che vorrei rompere sulle parole, che possono essere fatti euristicamente guardando le pause nella forma d'onda, ma qualcuno può indicarmi una funzione/libreria in python che lo faccia automaticamente?

Answer 1

Si potrebbe guardare Audiolab Fornisce un'API decente per convertire i campioni vocali in matrici numpy. Il modulo Audiolab utilizza la libreria libsndfile C++ per eseguire il sollevamento pesante.

È quindi possibile analizzare gli array per trovare i valori più bassi per trovare le pause.

Answer 2

Un modo più semplice per eseguire questa operazione è utilizzare il modulo pydub. l'aggiunta recente di silent utilities fa tutto il sollevamento pesante come setting up silence threahold, setting up silence length. ecc. e semplifica il codice in modo significativo rispetto ad altri metodi citati.

Ecco un'implementazione demo, ispirazione da here

Setup:

ho avuto un file audio con le lettere si parla inglese da A al Z nel file "a-z.wav". Una sottodirectory splitAudio è stata creata nella directory di lavoro corrente. Dopo aver eseguito il codice demo, i file sono stati suddivisi su 26 file separati con ciascun file audio che memorizza ciascuna sillaba.

Osservazioni: Alcune delle sillabe sono stati tagliati fuori, forse che necessitano di modifica dei seguenti parametri,
min_silence_len=500
silence_thresh=-16

Si consiglia di sintonizzarsi questi per il proprio fabbisogno.

Codice Demo:

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

uscita:

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

Usa IBM STT. Usando timestamps=true si otterrà la parola si rompe con quando il sistema li rileva che sono stati pronunciati.

Ci sono molte altre funzioni interessanti come word_alternatives_threshold per ottenere altre possibilità di parole e word_confidence per ottenere la sicurezza con cui il sistema prevede la parola. Impostare word_alternatives_threshold tra (0,1 e 0,01) per ottenere una vera idea.

Questo segno di necessità, seguito dal quale è possibile utilizzare il nome utente e la password generati.

IBM STT è già una parte del modulo di riconoscimento vocale menzionato, ma per ottenere la parola timestamp, è necessario modificare la funzione.

Un estratto e forma modificata assomiglia:

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)