Spracherkennung durch Python MFCC

In Vorheriger Artikel wurden Vokale mithilfe der Formantenanalyse erkannt. Ich habe durch ein Praktikum bei Sai Seed Co., Ltd. von MFCC erfahren und die Klassifizierungsgenauigkeit überprüft. Ich möchte es zusammenfassen.

Inhaltsverzeichnis

--Hintergrund

Hintergrund

In der Formanalyse von vorheriger Artikel wurde die Umhüllung des Spektrums erhalten, und die hervorgehobenen Frequenzen wurden als F1 und F2 von der niedrigsten verwendet. Es wurde für die Vokalanalyse verwendet. In Bezug auf Vokale gibt es in Japan nur 5 Silben, und die Formantenanalyse war effektiv, da die Vokale grundsätzlich nach der Form des Sprachpfads klassifiziert werden konnten. Aufgrund der dynamischen Änderungen sowie der Anzahl und Unterschiede der zur Vokalisierung verwendeten Organe können die Phoneme und Konsonanten im Text jedoch nicht allein durch die Merkmale der Formantenanalyse ausgedrückt werden. Daher werden wir dieses Mal die Phoneme unter Verwendung von MFCC und seiner dynamischen Differenz klassifizieren, wodurch die Mitnahme des Sprachpfadspektrums detaillierter ausgedrückt werden kann.

Was ist MFCC?

Formant bezieht sich auf mehrere Resonanzfrequenzen, die hervorgehoben werden, wenn eine Stimme den Sprachpfad durchläuft, und Vokale werden für die Vokalanalyse verwendet, da sie sich abhängig von der Form des Sprachpfads und der Zunge ändern. In MFCC ist es möglich, die Eigenschaften von Tonelementen zu erfassen, die durch Formantenanalyse nicht erfasst werden konnten, indem die phonetischen Elemente gemäß den menschlichen Hörmerkmalen konvertiert und die Hüllkurve des Spektrums mit mehr Merkmalen als der Formantenanalyse ausgedrückt werden. Darüber hinaus bezieht sich MFCC (Mel Frequency Keptram Coefficient) auf das Kepstram des logarithmischen Leistungsspektrums der Melfilter Bank, das später ausführlich erläutert wird.

MFCC-Ableitungsprozess

Das Verfahren zum Ableiten von MFCC ist wie folgt.

  1. Vorbehandlung
  2. Hochfrequenzbetonung (Vorverbesserung)
  3. Fensterfunktion
  4. Komprimieren Sie das Leistungsspektrum mit der Melfilter-Bank.
  5. Wandeln Sie das komprimierte Leistungsspektrum in ein logarithmisches Leistungsspektrum um.
  6. Ableitung von Kepstram durch Anwendung der inversen diskreten Cosinustransformation auf das logarithmische Leistungsspektrum. Verwenden Sie die niederwertige Komponente von Kepstram (den Koeffizienten, der die Umhüllung des Spektrums darstellt) als Spektrum des Sprachpfads für die Spracherkennung

Ich werde jedes im Detail erklären.

1. Vorbehandlung

Erstens wird in Bezug auf die Vorverarbeitung die Leistung der Stimme gedämpft, wenn sie höher wird, so dass eine Hochfrequenz-Hervorhebungsverarbeitung durchgeführt wird, um dies zu kompensieren. Zusätzlich wird eine Fensterfunktion auf die diskontinuierlichen Daten angewendet, so dass beide Enden der Wellenform gedämpft werden. Das Leistungsspektrum wird verwendet, weil sich die Stärke des Schalls (hervorgehobene Frequenz) in Abhängigkeit vom Unterschied in der Phonologie ändert (das Amplitudenspektrum ist auch eine der Methoden zum Ausdrücken des Schalldrucks, daher denke ich, dass einige Leute ihn dort analysieren).

2. Komprimieren Sie das Leistungsspektrum mit der Melfilter-Bank.

Das menschliche Gehör ändert sich je nach Frequenz. Je höher die Frequenz, desto schwieriger ist es, die Tonhöhe zu unterscheiden. Die experimentelle Berechnung der Beziehung zwischen der tatsächlichen Frequenz und der Hörfrequenz wird als Mel-Skala bezeichnet. Wenn Sie die Frequenzachse auf der Mel-Skala betrachten, erstellen Sie einen Filter entsprechend der Anzahl der Mel-Filterbänke, damit die Breite gleichmäßig ist. Unter Verwendung davon wird das Leistungsspektrum der durch Hochgeschwindigkeits-Fourier-Transformation erhaltenen Sprachwellenform in Gruppen der Anzahl von Mel-Filterbänken unterteilt.

3. In logarithmisches Leistungsspektrum konvertieren

Es gibt zwei Gründe, die Ausgabe (Leistungsspektrum) der Melfilter-Bank zu einem logarithmischen Leistungsspektrum zu machen. Erstens ist die Lautstärke des Geräusches, die Menschen wahrnehmen, proportional zum Logarithmus des Schalldrucks, und wenn das Geräusch lauter wird, wird es schwieriger, den Unterschied in der Lautstärke wahrzunehmen. Es muss ein logarithmisches Spektrum sein, um diesem menschlichen Hörmerkmal zu entsprechen. Zweitens, da der Schall zu einem bestimmten Zeitpunkt eine Faltung des Voiceway-Spektrums (Spektrumumhüllung) in die Drüsenwelle (Quellwelle) ist, indem das logarithmische Leistungsspektrum, die Drüsenwelle und die Voiceway genommen werden Es kann in eine lineare Summe von Spektren unterteilt werden. Im Folgenden wird erläutert, wie Sie in eine lineare Summe trennen.

Sei $ y (n) $ das Sprachsignal zu einer bestimmten Zeit, $ v (n) $ die Gaudalwelle zu einer bestimmten Zeit und $ h (n) $ die Impulsantwort des Sprachpfades. $y(n) = \sum_{m=-\infty}^{\infty}v(m) \cdot h(n-m) = v(n)*h(n)$

Wenn das Sprachsignal Fourier-transformiert ist $Y(k) = V(k) \cdot H(k)$

Es wird. Zu diesem Zeitpunkt beträgt das Leistungsspektrum des Audiosignals wie folgt $ S (k) . $S(k) = |Y(k)|^2 = |V(k) \cdot H(k)|^2 $ Wenn dies in logarithmisch konvertiert wird $\log S(k) = 2\log |V(k)| + 2\log |H(k)| $$ Und kann in eine lineare Summe getrennt werden.

4. Ableitung von Kepstram

Kepstram kann erhalten werden, indem das erhaltene logarithmische Leistungsspektrum erfasst wird, als wäre es ein Zeitsignal, und eine inverse diskrete Fourier-Transformation durchgeführt wird. Unter Verwendung der zuvor verwendeten logarithmischen Potenz $ logS (k) $ werden wir nun den Ableitungsprozess von Kepstram mit einer Gleichung verfolgen. Die Formel für die inverse diskrete Fourier-Transformation finden Sie unter hier. Da sich Kepstram $ c (n) $ auf die inverse diskrete Fourier-Transformation der logarithmischen Leistung bezieht

\begin{align}
c(n) &= \frac{1}{N}\sum_{k=0}^{N-1}\log S_{k}e^{(i\frac{2\pi kn}{N})}\\
     &= \frac{1}{N}\sum_{k=0}^{N-1}\log S_{k} \cos (\frac{2\pi kn}{N}) + i \log S_{k} \sin (\frac{2\pi kn}{N})\\
\end{align}

Zusätzlich ist dieses Leistungsspektrum liniensymmetrisch mit der Nyquist-Frequenz als Grenze. Mit anderen Worten

\frac{1}{N}\sum_{k=0}^{N-1}i \log S_{k}\sin (\frac{2\pi kn}{N}) = 0

Es wird. Daher kann Kepstram $ c (n) $ durch die inverse diskrete Cosinustransformation wie folgt ausgedrückt werden.

\begin{align}
c(n) &= \frac{1}{N}\sum_{k=0}^{N-1}\log S_{k} \cos (\frac{2\pi kn}{N})\\
     &= \frac{2}{N}\sum_{k=0}^{N-1}\log V_{k} \cos (\frac{2\pi kn}{N}) 
        + \frac{2}{N}\sum_{k=0}^{N-1}\log H_{k} \cos (\frac{2\pi kn}{N}) \\
\end{align}

Da $ v (n) $ eine Drüsenwelle ist, enthält sie viele komplizierte Änderungen (Hochfrequenzkomponenten). Andererseits ist $ h (n) $ eine Impulsantwort des Sprachtrakts, daher enthält es viele sanfte Änderungen (Niederfrequenzkomponenten). Daher repräsentiert die untere Komponente dieses Kepstrams $ c (n) $ das Voiceway-Spektrum $ H_ {k} $.

Implementierung des MFCC-Ableitungsprogramms

Über Librosa

librosa ist ein Python-Paket zur Analyse von Musik und Audio. In diesem Programm wird es für die MFCC- und logarithmische Ausgangsleistung verwendet. Einzelheiten finden Sie in der Dokumentation.

Ableitung von MFCC

Die folgenden Pakete werden verwendet.

#Paket zu verwenden
import cis
import librosa
import sklearn
import numpy as np
from collections import defaultdict
import scipy.signal

Installieren Sie librosa in Ihrer Umgebung mit `pip install --upgrade sklearn librosa```. Darüber hinaus ist `cis``` in diesem Programm ein Paket, das in der Einführung in die in Python erlernte praktische Bild- / Sprachverarbeitung beschrieben wird. Verwenden Sie die in hier oder zum Lesen von Audiodateien. Bitte verwenden Sie stattdessen ein anderes Paket.

Das Programm bis zur MFCC-Ableitung ist wie folgt.

mfcc.py


#Verwenden Sie alle durchschnittlichen Funktionen des Audiobereichs als Vektor
mfcc_data = []
boin_list = ["a","i","u","e","o"]
nobashi_boin = ["a:","i:","u:","e:","o:"]
remove_list = ["silB","silE","sp"]

#Hochfrequenzbetonung
def preEmphasis(wave, p=0.97):
    #Koeffizient(1.0, -p)Erstellen Sie einen FIR-Filter für
    return scipy.signal.lfilter([1.0, -p], 1, wave)
#Berechnung von mfcc
def mfcc(wave):
    mfccs = librosa.feature.mfcc(wave, sr = fs, n_fft = 512)
    mfccs = np.average(mfccs, axis = 1)
    #Machen Sie es zu einem eindimensionalen Array
    mfccs = mfccs.flatten()
    mfccs = mfccs.tolist()
    #Ich brauche die Funktionen von mfcc nach der 1. und 14. Dimension nicht mehr, also werde ich sie löschen.
    mfccs.pop(0)
    mfccs = mfccs[:12]
    mfccs.insert(0,label)
    return mfccs
  
#Daten lesen,Berechnen Sie mfcc für jedes phonetische Element(Die verwendeten Daten beziehen sich auf 500 Dateien)
for i in range(1,500,1):
    data_list = []
    open_file = "wav/sound-"+str(i).zfill(3)+".lab"
    filename = "wav/sound-"+str(i).zfill(3)#Die Abtastfrequenz beträgt 16 kHz
    v, fs = cis.wavread(filename+".wav")
    with open(open_file,"r") as f:
        data = f.readline().split()
        while data:
            data_list.append(data)
            data = f.readline().split()
        for j in range(len(data_list)):
            label =  data_list[j][2]
            if label in boin_list:
                start = int(fs * float(data_list[j][0]))
                end = int(fs * float(data_list[j][1]))
                voice_data = v[start:end]
                #Wenn es zu kurz ist, kann es nicht gut analysiert werden. Überspringen Sie es daher.
                if end - start <= 512:
                    continue
                #Summen Fenster
                hammingWindow = np.hamming(len(voice_data))
                voice_data = voice_data * hammingWindow
                p = 0.97
                voice_data = preEmphasis(voice_data, p)
                mfcc_data.append(mfcc(voice_data))

Wie zuvor erläutert, sind die Komponenten höherer Ordnung charakteristisch für die Darstellung von Drüsenwellen, so dass sie üblicherweise in etwa 12 Dimensionen zur Erkennung von Phonemen verwendet werden. Die erste Dimension wird ausgeschlossen, da sie die orthogonale Komponente der Daten darstellt. Darüber hinaus ist die von diesem Programm geöffnete Labordatei eine Datei, die die Startposition, Endposition und den Typ des phonetischen Elements von Julius Segmentation-Kit enthält. Vorheriger Artikel enthält ein Beispiel. Überprüfen Sie es daher, wenn Sie interessiert sind.

Klassifizierung von Phonemen mit MFCC

Ich möchte die Klassifizierung von Phonemen mit SVM (Support Vector Machine) vergleichen.

svm.py


#Erforderliche Pakete
import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.svm import SVC
from sklearn.metrics import accuracy_score

#Datensatz laden
df = pd.DataFrame(mfcc_data)

x = df.iloc[:,1:]#Eigenschaften erhalten mit mfcc
y = df.iloc[:,0]#Schiffsetikett
#Die Bezeichnung wurde einmal in Nummer geändert
label = set(y)
label_list = list(label)
label_list.sort()
for i in range(len(label_list)):
    y[y == label_list[i]] =i
y = np.array(y, dtype = "int")

#Bestimmen Sie die Grenze zwischen Lehrerdaten und Testdaten
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size = 0.4, random_state = 1)

#Datenstandardisierung
sc = StandardScaler()
sc.fit(x_train)
x_train_std = sc.transform(x_train)
x_test_std = sc.transform(x_test)

#Erstellen Sie eine Instanz von SVM
model_linear = SVC(kernel='linear', random_state = 1)
model_poly = SVC(kernel = "poly", random_state = 1)
model_rbf = SVC(kernel = "rbf", random_state =1)
model_linear.fit(x_train_std, y_train)
model_poly.fit(x_train_std, y_train)
model_rbf.fit(x_train_std, y_train)

pred_linear_train = model_linear.predict(x_train_std)
pred_poly_train = model_poly.predict(x_train_std)
pred_rbf_train = model_rbf.predict(x_train_std)
accuracy_linear_train =accuracy_score(y_train, pred_linear_train)
accuracy_poly_train =accuracy_score(y_train, pred_poly_train)
accuracy_rbf_train =accuracy_score(y_train, pred_rbf_train)
print("train_result")
print("Linear : "+str(accuracy_linear_train))
print("Poly : "+str(accuracy_poly_train))
print("RBF : "+ str(accuracy_rbf_train))

pred_linear_test = model_linear.predict(x_test_std)
pred_poly_test = model_poly.predict(x_test_std)
pred_rbf_test = model_rbf.predict(x_test_std)
accuracy_linear_test = accuracy_score(y_test, pred_linear_test)
accuracy_poly_test = accuracy_score(y_test, pred_poly_test)
accuracy_rbf_test = accuracy_score(y_test, pred_rbf_test)
print("-"*40)
print("test_result")
print("Linear : "+str(accuracy_linear_test))
print("Poly : "+str(accuracy_poly_test))
print("RBF : "+ str(accuracy_rbf_test))

Bei Anwendung auf die mfcc-Funktion von librosa wird das eingegebene phonetische Element in mehrere Teile aufgeteilt. Wenn Sie diesmal das MFCC vergleichen, das nur die Mitte der geteilten phonetischen Elemente verwendet, und das MFCC, das den Durchschnitt der gesamten phonetischen Bezeichnung verwendet, war es besser, den Durchschnitt zu verwenden, daher werde ich das Ergebnis in diesem Artikel veröffentlichen. Zum Vergleich sind auch die Ergebnisse der vorherigen Formantenanalyse enthalten. Ungefähr 8200 phonetische Vokaldaten werden für die Klassenklassifizierung verwendet.

Klassifizierungsergebnis durch Formantenanalyse


train_result
Linear : 0.8109896432681243
Poly : 0.7206559263521288
RBF : 0.8550057537399309
----------------------------------------
test_result
Linear : 0.7825503355704698
Poly : 0.6932885906040268
RBF : 0.8308724832214766

Klassifizierungsergebnis von MFCC


train_result
Linear : 0.885286271290786
Poly : 0.9113482454340243
RBF : 0.9201723784116561
----------------------------------------
test_result
Linear : 0.8833487226839027
Poly : 0.8913511849799939
RBF : 0.9039704524469068

Im Vergleich zur Formantenanalyse hat sich die Erkennungsgenauigkeit von ** etwa 7% ** verbessert. Aufgrund der Zunahme der Anzahl von Merkmalen war es auch möglich, selbst in linearer Form mit guter Genauigkeit zu erkennen. Konsonanten werden ebenfalls auf die gleiche Weise klassifiziert.

Ergebnisse der Formantenanalyse


train_result
Linear : 0.2290266367936271
Poly : 0.20114513318396812
RBF : 0.31292008961911877
----------------------------------------
test_result
Linear : 0.22357723577235772
Poly : 0.1991869918699187
RBF : 0.30720092915214864

Ergebnis von mfcc


train_result
train_result
Linear : 0.5635076681085333
Poly : 0.647463625639009
RBF : 0.679315768777035
----------------------------------------
test_result
Linear : 0.5396638159834857
Poly : 0.5364199351223827
RBF : 0.6004128575641404

Bei der Datenmenge handelt es sich um Formantenanalyse (ca. 5000 Konsonantendaten) und mfcc-Ergebnisse (ca. 8500 Konsonantendaten). Im Vergleich zur Formantenanalyse ist die Erkennungsgenauigkeit stark verbessert, aber das Ergebnis ist für einen Erkenner nicht gut.

Implementierung von Programmen zur kontinuierlichen Spracherkennung

Bei der tatsächlichen kontinuierlichen Spracherkennung wird eine Analyseverarbeitung wie MFCC für jeden Sprachrahmen durchgeführt, und eine Erkennungsverarbeitung für die Stimme dieses Rahmens wird durchgeführt. Daher ist es tatsächlich nicht möglich, die für jeden phonetischen Abschnitt gemittelten Eigenschaften des MFCC zur Klassifizierung zu verwenden.

In Bezug auf dynamische Unterschiede

Im Allgemeinen werden bei der Spracherkennung zusätzlich zu den Eigenschaften von MFCC der logarithmische Wert der Summe der Ausgänge der Melfilter-Bank (im Folgenden als logarithmisches Leistungsspektrum bezeichnet), die Differenz erster Ordnung (dynamische Differenz) zwischen dem logarithmischen Leistungsspektrum und dem MFCC und die Differenz zweiter Ordnung verwendet. Es scheint, dass die hinzugefügten 39 Dimensionen häufig verwendet werden (Spracherkennung der MLP-Serie). Durch die Verwendung dynamischer Unterschiede zur Erkennung wird es möglich, die Eigenschaften sich dynamisch ändernder Melodien wie Konsonanten und Halbvokale zu erfassen. In Bezug auf das Leistungsspektrum ändern sich Konsonanten schneller als Vokale, sodass ein dynamischer Unterschied die Erkennungsgenauigkeit verbessert.

※ Hinweis In der bisherigen Implementierung wurde die Genauigkeit anhand der gemittelten Merkmale des phonetischen Intervalls überprüft. Bei dynamischen Unterschieden ist es jedoch erforderlich, kontinuierliche Änderungen der Merkmale zu verfolgen. Um es als kontinuierliche Daten zu behandeln, wird das Ergebnis von MFCC für jede Fensterbreite so wie es ist als Merkmal verwendet. Zusätzlich wird das Programm entsprechend geändert. Bezüglich des Ergebnisses sehen Sie bitte die folgenden Ergebnisse, die sich vom obigen Ergebnis unterscheiden.

Ableitung der Primärdifferenz und der Sekundärdifferenz

Jetzt möchte ich das Programm sofort implementieren. Zunächst werden das MFCC, das logarithmische Leistungsspektrum und die Funktionen zum Ableiten ihrer dynamischen Unterschiede, die dieses Mal erhalten werden müssen, nachstehend zusammengefasst.

function.py


#Hochfrequenzbetonung
def preEmphasis(wave, p=0.97):
    #Koeffizient(1.0, -p)Erstellen Sie einen FIR-Filter für
    return scipy.signal.lfilter([1.0, -p], 1, wave)

#Berechnung von mfcc
def mfcc(wave):
    mfccs = librosa.feature.mfcc(wave, sr = fs, n_fft = 512)
    mfccs = np.average(mfccs, axis = 1)
    #Machen Sie es zu einem eindimensionalen Array
    mfccs = mfccs.flatten()
    mfccs = mfccs.tolist()
    #Ich brauche die Funktionen von mfcc nach der 1. und 14. Dimension nicht mehr, also werde ich sie löschen.
    mfccs.pop(0)
    mfccs = mfccs[:12]
    return mfccs

#Berechnung des logarithmischen Leistungsspektrums
def cal_logpower(wave):
    S = librosa.feature.melspectrogram(wave, sr = fs,n_fft = 512)
    S = sum(S)
    PS=librosa.power_to_db(S)
    PS = np.average(PS)
    return PS

#Wie viele Frames vorher und nachher zu sehen sind(Normalerweise 2~5)
#Gewichtsteil für den Rahmen
def make_scale(K):
    scale = []
    div = sum(2*(i**2) for i in range(1,K+1))
    for i in range(-K,K+1):
        scale.append(i/div)
    return np.array(scale)

#Extraktion von Differentialmerkmalen
def make_delta(K, scale, feature):
    #Datenreferenz von der eigenen Position zu K vor
    before = [feature[0]]*K
    #K Referenzdaten nach eigener Position
    after = []
    #Speicherliste der unterschiedlichen Funktionen
    delta = []
    for i in range(K+1):
        after.append(feature[i])      
    for j in range(len(feature)):
        if j == 0:
            match =  np.array(before + after)
            dif_cal =  np.dot(scale, match)
            delta.append(dif_cal)
            after.append(feature[j+K+1])
            after.pop(0)
        #K von hinten+Es gibt einen Teil, der als Unterschied bis zu 1 zu sehen ist
        elif j < (len(feature) - K - 1):
            match = np.array(before + after)
            dif_cal = np.dot(scale, match)
            delta.append(dif_cal)
            before.append(feature[j])
            before.pop(0)                
            after.append(feature[j+K+1])
            after.pop(0)
        #Datenmenge-Da Daten nach K nicht mehr hinzugefügt werden können
        else:
            match = np.array(before + after)
            dif_cal = np.dot(scale, match)
            delta.append(dif_cal)
            before.append(feature[j])
            before.pop(0)
            after.append(feature[len(feature)-1])
            after.pop(0)
    return delta

Als nächstes wird das Programm zum Extrahieren der Merkmale von mfcc, des logarithmischen Leistungsspektrums und seiner quadratischen Differenz nachstehend beschrieben.

get_all_feature.py


#Verwenden Sie alle Funktionen des Audiobereichs als Vektor
phoneme = []
feature_data = []
delta_list = []
delta_2_list = []
nobashi_boin = ["a:","i:","u:","e:","o:"]
remove_list = ["silB","silE","sp"]


#Daten lesen,Berechnen Sie mfcc für jedes phonetische Element(Die verwendeten Daten beziehen sich auf 500 Dateien)
for i in range(1,500,1):
    data_list = []
    open_file = "wav/sound-"+str(i).zfill(3)+".lab"
    filename = "wav/sound-"+str(i).zfill(3)#Die Abtastfrequenz beträgt 16 kHz
    v, fs = cis.wavread(filename+".wav")
    with open(open_file,"r") as f:
        data = f.readline().split()
        while data:
            data_list.append(data)
            data = f.readline().split()
        for j in range(len(data_list)):
            label =  data_list[j][2]
            if label not in remove_list:
                start = int(fs * float(data_list[j][0]))
                end = int(fs * float(data_list[j][1]))
                #In Bezug auf gestreckte Vokale
                if label in nobashi_boin:
                    label = label[0]
                voice_data = v[start:end]
                #Summen Fenster
                hammingWindow = np.hamming(len(voice_data))
                voice_data = voice_data * hammingWindow
                p = 0.97
                voice_data = preEmphasis(voice_data, p)
                mfccs = librosa.feature.mfcc(voice_data, sr = fs, n_fft = 512)
                mfccs_T = mfccs.T
                S = librosa.feature.melspectrogram(voice_data, sr = fs,n_fft = 512)
                S = sum(S)
                PS=librosa.power_to_db(S)
                for i in range(len(PS)):
                    feature = mfccs_T[i][1:13].tolist()
                    feature.append(PS[i])
                    feature_data.append(feature)
                    phoneme.append(label)
        K = 3
        scale = make_scale(K)
        delta = make_delta(K,scale,feature_data[len(delta_list):len(feature_data)])
        delta_list.extend(delta)
        second_delta = make_delta(K,scale,delta)
        delta_2_list.extend(second_delta)

Nachdem wir einen quadratischen Unterschied erstellt haben, können wir einen Datenrahmen mit `Phonem```,` feature_data, `` delta_list, `` delta_2_list``` erstellen. Bitte erstellen. Ich denke auch, dass die Klassifizierung verwendet werden kann, indem das Formular mit dem zuvor erwähnten SVM-Programm abgeglichen wird.

Klassifizierung von Phonemen einschließlich der Merkmale sekundärer Unterschiede

Das Ergebnis der Klassifizierung mithilfe von SVM durch Hinzufügen des Differenzmerkmalsbetrags ist wie folgt. Für beide Ergebnisse basiert die Erkennungsgenauigkeit auf den Eigenschaften von MFCC für jede Fensterbreite. Über Vokale werden phonetische Daten (ca. 32500) zur Klassifizierung verwendet.

MFCC(12 Dimensionen)Nur Ergebnisse


train_result
Linear : 0.8297360883797054
Poly : 0.8647708674304418
RBF : 0.8777618657937807
----------------------------------------
test_result
Linear : 0.8230149597238204
Poly : 0.8420406597621788
RBF : 0.8566168009205984

MFCC+Ergebnis der Addition zur quadratischen Differenz der logarithmischen Leistung


train_result
Linear : 0.8631853518821604
Poly : 0.9549918166939444
RBF : 0.9495703764320785
----------------------------------------
test_result
Linear : 0.8588415803605677
Poly : 0.9132336018411967
RBF : 0.9177598772535481

Durch Verwendung der dynamischen Differenz kann die Erkennungsgenauigkeit um ** ca. 6% ** verbessert werden. Da kontinuierliche Daten für die Analyse verwendet werden, wurde bestätigt, dass die Änderung des Tons vorher und nachher charakteristisch und effektiv ist.

Als nächstes klassifizieren wir auch Konsonanten. Für die Klassifizierung werden ca. 27.000 Konsonantendaten verwendet.

MFCC(12 Dimensionen)Nur Ergebnisse


train_result
Linear : 0.418983174835406
Poly : 0.5338332114118508
RBF : 0.5544989027066569
----------------------------------------
test_result
Linear : 0.4189448660510195
Poly : 0.4599067385937643
RBF : 0.49419402029807075

MFCC+Das Ergebnis der Addition der quadratischen Differenz der logarithmischen Leistung


train_result
Linear : 0.5945501097293343
Poly : 0.8152889539136796
RBF : 0.8201658132162887
----------------------------------------
test_result
Linear : 0.5684374142817957
Poly : 0.6783395812379994
RBF : 0.7101581786595959

Konsonanten zeigten auch eine signifikante Verbesserung der Genauigkeit (** etwa 22% **) im Vergleich zu denen, die die Eigenschaften von MFCC (12 Dimensionen) verwendeten. Da die Änderung der Wellenform von Konsonanten größer ist als die von Vokalen, wurde bestätigt, dass der dynamische Unterschied als Merkmal wirksamer ist. Andererseits vergrößert sich mit zunehmender Merkmalsmenge der Genauigkeitsunterschied zwischen Test und Zug, sodass Datenmangel als Problem angesehen wird.

Erwägung

In Bezug auf Vokale

In Bezug auf Vokale wurde bestätigt, dass die Genauigkeit durch Verwendung der Merkmalsmenge der Spektrumsumhüllung unter Verwendung von MFCC im Vergleich zur Formantenanalyse verbessert wurde. Am Anfang des Satzes habe ich festgestellt, dass die Formantenanalyse nur für Vokale ausreicht, aber nur für die Aussprachedaten eines einzelnen Vokals. Für die Vokaldaten haben wir diesmal jedoch die Äußerungsdaten des mit Julius segmentierten Satzes verwendet. Im Fall solcher Vokaldaten wird dies durch die vorhergehenden und folgenden Töne beeinflusst, und es besteht die Möglichkeit, dass sich die Wellenform von der unterscheidet, die einen einzelnen Vokal erzeugt hat. Daher gibt es Änderungen in der Wellenform, die von der Formantenanalyse nicht erfasst werden können, und es wird angenommen, dass die Genauigkeit durch Verwendung von MFCC verbessert wurde. Da es von Änderungen der Sounds vorher und nachher beeinflusst wird, wird außerdem angenommen, dass die Genauigkeit durch Hinzufügen eines dynamischen Unterschieds weiter verbessert wurde.

In Bezug auf Konsonanten

In Bezug auf Konsonanten können aus diesem Ergebnis drei Dinge gesagt werden.

  1. Da Konsonanten mit mehr Organen als Vokalen ausgesprochen werden, ist ersichtlich, dass die Erkennungsgenauigkeit schlecht war, da bei der Formantenanalyse nur die durch die Hüllkurve des Spektrums hervorgehobenen Frequenzen betrachtet wurden. Es wird angenommen, dass sich die Genauigkeit verbessert hat, da MFCC die Umhüllung des Spektrums detaillierter ausdrücken kann.
  2. Einige der phonetischen Wellenformen von Konsonanten ändern sich schnell, z. B. platzende Geräusche. Es wird angenommen, dass die Genauigkeit im Vergleich zu MFCC durch Verwendung der dynamischen Differenz und des Leistungsspektrums für solche Elemente weiter verbessert wurde.
  3. In Bezug auf Datenmangel. Da die Gesamtzahl der Daten (zum Zeitpunkt der dynamischen Differenz) 27.000 beträgt und die Anzahl der Konsonanten dieses Mal 26 Typen (von Julius klassifiziert) beträgt, wird sie einfach berechnet und liegt für ein phonetisches Element über 1000. Es gibt nur Daten. Auf der anderen Seite gibt es 39 Funktionen, sodass die Anzahl der Daten nicht ausreicht. Außerdem werden die mit dieser Zeit behandelten Textäußerungsdaten nicht so angepasst, dass die Phoneme das gleiche Gleichgewicht haben. Wenn die Menge klein ist, beträgt die Datenmenge ungefähr 150, und wenn die Menge groß ist, beträgt die Datenmenge ungefähr 4000. Durch Anpassen der Variation der Datenmenge und Erhöhen der Gesamtdatenmenge kann die Genauigkeit sogar noch besser sein als dieses Ergebnis.

Zusammenfassung

Dieser Artikel beschreibt die Theorie und die tatsächliche Überprüfung der Klassifizierung von MFCC, die am häufigsten in akustischen Modellen verwendet wird. Eine Bibliothek (librosa) ist für MFCC vorbereitet und kann leicht implementiert werden. Daher habe ich ein Beispiel für ihre Theorie und ihre Verwendungsergebnisse ausführlich erläutert. Ich hoffe, dieser Artikel wird zu einem Verständnis des Mechanismus der Spracherkennung und zu Hinweisen für dessen Umsetzung führen.

In Zukunft möchte ich auf das akustische Modell und das Sprachmodell für kontinuierliche Phoneme eingehen.

Referenz

Recommended Posts

Spracherkennung durch Python MFCC
Spracherkennung mit Python
Sprachdateierkennung durch Google Speech API v2 mit Python
Englische Spracherkennung mit Python [Rede zu Text]
Einfache Einführung der Spracherkennung mit Python
Szenenerkennung nach GIST-Feature-Quantität in Python
Sprachsynthese und Spracherkennung durch Microsoft Project Oxford
Primzahlbeurteilung durch Python
Visualisierungsnotiz von Python
Kommunikationsverarbeitung durch Python
Beamformer-Antwort von Python
EXE Web API von Python
Newcomer Trainingsprogramm von Python
Parametereinstellung durch Python Configparser
Pin Python von Conda verwaltet
Keyword-Extraktion mit MeCab (Python)
Zahlen durch 3 Ziffern trennen (Python)
Markov-Schaltmodell von Python
Sprechen mit Python [Text zu Sprache]
Bildverarbeitung mit Python (Pillow)
Python wurde von C-Programmierern gestartet
Versuchen Sie die Gesichtserkennung mit Python
Plattform (OS) Beurteilung durch Python
Sortieren nach Datum in Python
Streamen Sie die Spracherkennung mithilfe der gRPC-API von Google Cloud Speech mit Python3 auf dem Mac!
[Python] Sortierbar nach mehreren Bedingungen sortieren
Erweiterung des Python-Wörterbuchs um Argumente
Zusammenfassung des maschinellen Lernens von Python-Anfängern
Lerne Python durch Zeichnen (Turtle Graphics)
Python-Entwicklung unterstützt durch Jenkins-Unit-Test
Primzahlgenerator von Python
Python SQL-Anweisung Nach Zeit extrahieren
Attributzugriff auf Python dict zulassen
Betriebssystembestimmung durch Makefile mit Python
Typisierungsautomatisierungsnotiz von Python-Anfängern
Versuchen Sie die Gesichtserkennung mit Python + OpenCV
Python x Tensoflow x Gesichtserkennung
Gesichtserkennung mit Kamera mit opencv3 + python2.7
Verwenden Sie die Windows 10-Sprachsynthese mit Python
Abschnittsplanung Lernnotiz ~ von Python ~
Verhalten von Python3 durch Sakuras Server
Spracherkennung: Genreklassifizierung Part2-Musikgenreklassifizierung CNN
Handschriftliche Zeichenerkennung mit KNN in Python
100 Sprachverarbeitung Knock Kapitel 1 von Python
Geschichte der Potenznäherung von Python
Objekterkennung mit openCV durch traincascade
Sortieren von Dateien nach Namenskonvention mit Python