[PYTHON] Lineare Vorhersageanalyse (LPC) (= Formantenanalyse)

Hallo. "Linear Predictive Analysis (LPC) (20. Sprachsignalverarbeitung in Python (14.05.2011): Auffinden der Mitnahme des LPC-Spektrums) Ich habe einen Artikel mit dem Namen "(= Formantenanalyse)" gefunden und versucht, den Code dort fast so auszuführen, wie er ist. Dies ist ein Beispiel für den Vokal "A".

Der Code, den ich ausgeführt habe, ist der gleiche wie dort, aber ich werde ihn schreiben (`` `levinson_durbin.py``` wird auch von dort übernommen):

• Der Artikel "Formularanalyse mit Python (NumPy, SciPy) durchführen" Aber es scheint dies zu nutzen.
• Ich habe auch die Vokal-Audiodatei a.wav von irgendwoher bekommen.

# coding:utf-8
from __future__ import division
import wave
import numpy as np
import scipy.io.wavfile
import scipy.signal
import pylab as P
from levinson_durbin import autocorr, LevinsonDurbin

"""Finden Sie den Einschluss des LPC-Spektrums"""

def wavread(filename):
    wf = wave.open(filename, "r")
    fs = wf.getframerate()
    x = wf.readframes(wf.getnframes())
    x = np.frombuffer(x, dtype="int16") / 32768.0  # (-1, 1)Normalisiert auf
    wf.close()
    return x, float(fs)

def preEmphasis(signal, p):
    """Vorverstärkter Filter"""
    #Koeffizient(1.0, -p)Erstellen Sie einen FIR-Filter für
    return scipy.signal.lfilter([1.0, -p], 1, signal)

def plot_signal(s, a, e, fs, lpcOrder, file):
    t = np.arange(0.0, len(s) / fs, 1/fs)
    #Finden Sie das positiv vorhergesagte Signal mit LPC
    predicted = np.copy(s)
    #Da dies aus dem letzten lpcOrder vorhergesagt wird, stammt der Startindex von lpcOrder
    #Zuvor wurde das ursprüngliche Signal unvorhersehbar kopiert
    for i in range(lpcOrder, len(predicted)):
        predicted[i] = 0.0
        for j in range(1, lpcOrder):
            predicted[i] -= a[j] * s[i - j]
    #Zeichnen Sie das ursprüngliche Signal
    P.plot(t, s)
    #Zeichnen Sie das vorwärts vorhergesagte Signal mit LPC
    P.plot(t, predicted,"r",alpha=0.4)
    P.xlabel("Time (s)")
    P.xlim((-0.001, t[-1]+0.001))
    P.title(file)
    P.grid()
    P.show()
    return 0

def plot_spectrum(s, a, e, fs, file):
    #Finden Sie das Amplitudenspektrum des LPC-Koeffizienten
    nfft = 2048   #Anzahl der FFT-Proben
    fscale = np.fft.fftfreq(nfft, d = 1.0 / fs)[:nfft/2]
    #Logarithmisches Spektrum des ursprünglichen Signals
    spec = np.abs(np.fft.fft(s, nfft))
    logspec = 20 * np.log10(spec)
    P.plot(fscale, logspec[:nfft/2])
    #LPC logarithmisches Spektrum
    w, h = scipy.signal.freqz(np.sqrt(e), a, nfft, "whole")
    lpcspec = np.abs(h)
    loglpcspec = 20 * np.log10(lpcspec)
    P.plot(fscale, loglpcspec[:nfft/2], "r", linewidth=2)
    P.xlabel("Frequency (Hz)")
    P.xlim((-100, 8100))
    P.title(file)
    P.grid()
    P.show()
    return 0

def lpc_spectral_envelope(file):
    #Audio laden
    wav, fs = wavread(file)
    t = np.arange(0.0, len(wav) / fs, 1/fs)
    #Schneiden Sie den zentralen Teil der Sprachwellenform aus
    center = len(wav) / 2  #Probennummer zentrieren
    cuttime = 0.04         #Länge ausschneiden[s]
    s = wav[center - cuttime/2*fs : center + cuttime/2*fs]
    #Vorverstärkungsfilter anwenden
    p = 0.97         #Vorverbesserungskoeffizient
    s = preEmphasis(s, p)
    #Summen Fenster
    hammingWindow = np.hamming(len(s))
    s = s * hammingWindow
    #Finden Sie den LPC-Koeffizienten
#    lpcOrder = 12
    lpcOrder = 32
    r = autocorr(s, lpcOrder + 1)
    a, e  = LevinsonDurbin(r, lpcOrder)
    plot_signal(s, a, e, fs, lpcOrder, file)
    plot_spectrum(s, a, e, fs, file)
    return 0

if __name__ == "__main__":
    file = "a.wav"
    lpc_spectral_envelope(file)
    exit(0)