Dans Article précédent, les voyelles ont été reconnues en utilisant l'analyse des formants. J'ai découvert MFCC grâce à un stage chez Sai Seed Co., Ltd. et j'ai vérifié l'exactitude de la classification. Je voudrais le résumer.
--Contexte
Dans l'analyse de forme de article précédent, l'enveloppement du spectre a été obtenu et les fréquences accentuées ont été utilisées comme F1 et F2 à partir du plus bas. Il a été utilisé pour l'analyse des voyelles. Pour les voyelles, il n'y a que 5 syllabes au Japon, et l'analyse des formants était efficace car les voyelles pouvaient être classées en fonction de la forme du chemin de la voix. Cependant, en raison des changements dynamiques et du nombre et des différences des organes utilisés pour la vocalisation, les phonèmes et consonnes dans le texte ne peuvent pas être exprimés par les seules caractéristiques de l'analyse des formants. Par conséquent, cette fois, nous classerons les phonèmes en utilisant MFCC et sa différence dynamique, qui peut exprimer plus en détail l'entraînement du spectre du trajet vocal.
Formant fait référence à plusieurs fréquences de résonance qui sont accentuées lorsqu'une voix passe par le chemin de la voix, et les voyelles sont utilisées pour l'analyse des voyelles car elles changent en fonction de la forme du chemin de la voix et de la langue. Dans MFCC, il est possible de capturer les caractéristiques des éléments sonores qui ne pourraient pas être capturés par l'analyse des formants en convertissant les phonèmes selon les caractéristiques auditives humaines et en exprimant l'entourage du spectre en utilisant plus de fonctionnalités que l'analyse des formants. De plus, MFCC (Mel Frequency Keptram Coefficient) fait référence au Kepstram du spectre de puissance logarithmique du Melfilter Bank, qui sera expliqué en détail plus loin.
La procédure pour dériver MFCC est la suivante.
Je vais vous expliquer chacun en détail.
Premièrement, en ce qui concerne le prétraitement, la puissance de la voix est atténuée à mesure qu'elle augmente, de sorte qu'un traitement d'accentuation à haute fréquence est effectué pour la compenser. De plus, une fonction de fenêtre est appliquée aux données discontinues de sorte que les deux extrémités de la forme d'onde soient atténuées. Le spectre de puissance est utilisé car la magnitude du son (fréquence accentuée) change en fonction de la différence de phonologie (le spectre d'amplitude est également l'une des méthodes d'expression de la pression acoustique, donc je pense que certaines personnes l'analysent là-bas).
L'audition humaine change en fonction de la fréquence. Plus la fréquence est élevée, plus il est difficile de distinguer la hauteur. Le calcul expérimental de la relation entre la fréquence réelle et la fréquence auditive s'appelle l'échelle de Mel. Lorsque vous considérez l'axe des fréquences sur l'échelle Mel, créez un filtre en fonction du nombre de banques de filtres Mel afin que la largeur soit uniforme. En l'utilisant, le spectre de puissance de la forme d'onde vocale obtenue par transformation de Fourier à grande vitesse est divisé en groupes du nombre de bancs de filtres mel.
Il y a deux raisons pour faire de la sortie (spectre de puissance) de la banque Melfilter un spectre de puissance logarithmique. Premièrement, le volume sonore que les humains perçoivent est proportionnel au logarithme de la pression acoustique, et à mesure que le son devient plus fort, il devient plus difficile de percevoir la différence de volume. Il doit s'agir d'un spectre logarithmique pour correspondre à cette caractéristique auditive humaine. Deuxièmement, puisque le son à un certain moment est une convolution du spectre des voies vocales (enveloppement de spectre) dans l'onde glandulaire (onde source), en prenant le spectre de puissance logarithmique, l'onde glandulaire et la voie vocale Il peut être séparé en une somme linéaire de spectres. Ce qui suit explique comment séparer en une somme linéaire.
Soit $ y (n) $ le signal vocal à un certain moment, $ v (n) $ l'onde gaudale à un certain moment, et $ h (n) $ la réponse impulsionnelle du trajet vocal.
Lorsque le signal vocal est transformé de Fourier
Il devient. A ce moment, le spectre de puissance du signal audio est $ S (k) $ comme suit.
Kepstram peut être obtenu en capturant le spectre de puissance logarithmique obtenu comme s'il s'agissait d'un signal temporel et en effectuant une transformée de Fourier discrète inverse. Maintenant, en utilisant la puissance logarithmique $ logS (k) $ utilisée précédemment, nous allons suivre le processus de dérivation de Kepstram avec une équation. La formule de la transformation de Fourier discrète inverse peut être trouvée à ici. Puisque Kepstram $ c (n) $ fait référence à la transformée de Fourier discrète inverse de puissance logarithmique
\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}
De plus, ce spectre de puissance est symétrique en ligne avec la fréquence de Nyquist comme limite. En d'autres termes
Il devient. Par conséquent, Kepstram $ c (n) $ peut être exprimé par la transformation cosinus discrète inverse comme suit.
\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}
Puisque $ v (n) $ est une onde glandulaire, elle contient de nombreux changements compliqués (composantes haute fréquence). D'un autre côté, $ h (n) $ est une réponse impulsionnelle du tube vocal, donc il contient de nombreux changements lisses (composantes basse fréquence). Par conséquent, la composante inférieure de ce Kepstram $ c (n) $ représente le spectre des voies vocales $ H_ {k} $.
librosa est un package Python pour analyser la musique et l'audio. Dans ce programme, il est utilisé pour MFCC et sortie de puissance logarithmique. Pour plus de détails, veuillez consulter la Documentation.
Les packages suivants sont utilisés.
#Package à utiliser
import cis
import librosa
import sklearn
import numpy as np
from collections import defaultdict
import scipy.signal
Installez librosa dans votre environnement avec pip install --upgrade sklearn librosa. De plus, `` cis utilisé dans ce programme est un package décrit dans l'introduction au traitement pratique d'image / voix appris en Python. Utilisez celui de here ou utilisez-le pour lire des fichiers audio. Veuillez utiliser un autre package à la place.
Le programme jusqu'à la dérivation MFCC est le suivant.
mfcc.py
#Utilisez toutes les fonctionnalités moyennes de la section audio comme vecteur
mfcc_data = []
boin_list = ["a","i","u","e","o"]
nobashi_boin = ["a:","i:","u:","e:","o:"]
remove_list = ["silB","silE","sp"]
#Accentuation des hautes fréquences
def preEmphasis(wave, p=0.97):
#coefficient(1.0, -p)Créer un filtre FIR pour
return scipy.signal.lfilter([1.0, -p], 1, wave)
#calcul de mfcc
def mfcc(wave):
mfccs = librosa.feature.mfcc(wave, sr = fs, n_fft = 512)
mfccs = np.average(mfccs, axis = 1)
#Faites-en un tableau unidimensionnel
mfccs = mfccs.flatten()
mfccs = mfccs.tolist()
#Je n'ai pas besoin des fonctionnalités de mfcc après les 1ère et 14ème dimensions, je vais donc les effacer.
mfccs.pop(0)
mfccs = mfccs[:12]
mfccs.insert(0,label)
return mfccs
#Lire les données,Calculer mfcc pour chaque élément phonétique(Les données utilisées concernent 500 fichiers)
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)#La fréquence d'échantillonnage est de 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]
#S'il est trop court, il ne peut pas être bien analysé, alors sautez-le.
if end - start <= 512:
continue
#Fenêtre bourdonnante
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))
Comme expliqué précédemment, les composants d'ordre supérieur sont caractéristiques de la représentation des ondes glandulaires, ils sont donc généralement utilisés dans environ 12 dimensions pour la reconnaissance des phonèmes. La première dimension est exclue car elle représente la composante orthogonale des données. De plus, le fichier de laboratoire ouvert par ce programme est un fichier qui contient la position de départ, la position de fin et le type d'élément phonétique par julius segmentation-kit. Article précédent a un exemple, veuillez donc le vérifier si vous êtes intéressé.
Je voudrais comparer la classification des phonèmes en utilisant SVM (Support Vector Machine).
svm.py
#Forfaits requis
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
#Charger le jeu de données
df = pd.DataFrame(mfcc_data)
x = df.iloc[:,1:]#Fonctionnalités obtenues avec mfcc
y = df.iloc[:,0]#Étiquette du navire
#L'étiquette a été changée en numéro une fois
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")
#Déterminer la limite entre les données des enseignants et les données des tests
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size = 0.4, random_state = 1)
#Standardisation des données
sc = StandardScaler()
sc.fit(x_train)
x_train_std = sc.transform(x_train)
x_test_std = sc.transform(x_test)
#Créer une instance de 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))
Lorsqu'il est appliqué à la fonction mfcc de librosa, l'élément phonétique d'entrée est divisé en plusieurs morceaux. Cette fois, en comparant le MFCC qui n'utilise que le centre des éléments phonétiques divisés et le MFCC qui utilise la moyenne de l'étiquette phonétique entière, il était préférable d'utiliser la moyenne, je publierai donc le résultat dans cet article. Les résultats de l'analyse des formants précédente sont également inclus pour comparaison. Environ 8200 données phonétiques de voyelle sont utilisées pour la classification des classes.
Résultat de la classification par analyse des formants
train_result
Linear : 0.8109896432681243
Poly : 0.7206559263521288
RBF : 0.8550057537399309
----------------------------------------
test_result
Linear : 0.7825503355704698
Poly : 0.6932885906040268
RBF : 0.8308724832214766
Résultat de la classification par MFCC
train_result
Linear : 0.885286271290786
Poly : 0.9113482454340243
RBF : 0.9201723784116561
----------------------------------------
test_result
Linear : 0.8833487226839027
Poly : 0.8913511849799939
RBF : 0.9039704524469068
Par rapport à l'analyse des formants, ** environ 7% ** la précision de la reconnaissance s'est améliorée. De plus, en raison de l'augmentation du nombre de fonctionnalités, il était possible de reconnaître avec une bonne précision même en linéaire. Les consonnes sont également classées de la même manière.
Résultats de l'analyse des formants
train_result
Linear : 0.2290266367936271
Poly : 0.20114513318396812
RBF : 0.31292008961911877
----------------------------------------
test_result
Linear : 0.22357723577235772
Poly : 0.1991869918699187
RBF : 0.30720092915214864
résultat de 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
La quantité de données concerne l'analyse des formants (environ 5000 données de consonnes) et les résultats mfcc (environ 8500 données de consonnes). Par rapport à l'analyse des formants, la précision de la reconnaissance est grandement améliorée, mais le résultat n'est pas bon pour un dispositif de reconnaissance.
Dans la reconnaissance vocale continue réelle, un traitement d'analyse tel que MFCC est effectué pour chaque trame vocale, et un traitement de reconnaissance pour la voix de cette trame est effectué. Par conséquent, il n'est pas réellement possible d'utiliser les caractéristiques du MFCC moyennées pour chaque section phonétique pour la classification.
En général, en reconnaissance vocale, en plus des caractéristiques du MFCC, la valeur logarithmique de la somme des sorties du banc Melfilter (ci-après dénommée spectre de puissance logarithmique), la différence du premier ordre (différence dynamique) entre le spectre de puissance logarithmique et le MFCC, et la différence du second ordre sont utilisées. Il semble que les 39 dimensions ajoutées soient souvent utilisées (reconnaissance vocale de la série MLP). En utilisant des différences dynamiques pour la reconnaissance, il devient possible de capturer les caractéristiques d'une mélodie à changement dynamique telles que les consonnes et les demi voyelles. De plus, en ce qui concerne le spectre de puissance, les consonnes changent plus rapidement que les voyelles, donc prendre une différence dynamique améliorera la précision de la reconnaissance.
※ Mise en garde Dans la mise en œuvre jusqu'à présent, la précision a été vérifiée en utilisant les caractéristiques moyennes de l'intervalle phonétique, mais avec des différences dynamiques, il est nécessaire de suivre les changements continus des caractéristiques. Afin de le traiter comme des données continues, le résultat de MFCC pour chaque largeur de fenêtre est utilisé tel quel en tant que caractéristique. De plus, le programme sera modifié en conséquence. En ce qui concerne le résultat, veuillez voir les résultats suivants comme différents du résultat ci-dessus.
Maintenant, je voudrais mettre en œuvre le programme immédiatement. Tout d'abord, le MFCC, le spectre de puissance logarithmique et les fonctions pour dériver leurs différences dynamiques qui doivent être obtenues cette fois sont résumés ci-dessous.
function.py
#Accentuation des hautes fréquences
def preEmphasis(wave, p=0.97):
#coefficient(1.0, -p)Créer un filtre FIR pour
return scipy.signal.lfilter([1.0, -p], 1, wave)
#calcul de mfcc
def mfcc(wave):
mfccs = librosa.feature.mfcc(wave, sr = fs, n_fft = 512)
mfccs = np.average(mfccs, axis = 1)
#Faites-en un tableau unidimensionnel
mfccs = mfccs.flatten()
mfccs = mfccs.tolist()
#Je n'ai pas besoin des fonctionnalités de mfcc après les 1ère et 14ème dimensions, je vais donc les effacer.
mfccs.pop(0)
mfccs = mfccs[:12]
return mfccs
#Calcul du spectre de puissance logarithmique
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
#Combien d'images à voir avant et après(Habituellement 2~5)
#Partie poids pour le cadre
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)
#Extraction de caractéristiques différentielles
def make_delta(K, scale, feature):
#Référence de données de sa propre position à K avant
before = [feature[0]]*K
#K données de référence après sa propre position
after = []
#Liste de stockage des fonctionnalités différentielles
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 par derrière+Il y a une partie à voir comme une différence jusqu'à 1
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)
#quantité de données-Étant donné que les données ne peuvent pas être ajoutées après K
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
Ensuite, le programme d'extraction des caractéristiques de mfcc, du spectre de puissance logarithmique et de leur différence quadratique est décrit ci-dessous.
get_all_feature.py
#Utilisez toutes les fonctionnalités de la section audio comme vecteur
phoneme = []
feature_data = []
delta_list = []
delta_2_list = []
nobashi_boin = ["a:","i:","u:","e:","o:"]
remove_list = ["silB","silE","sp"]
#Lire les données,Calculer mfcc pour chaque élément phonétique(Les données utilisées concernent 500 fichiers)
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)#La fréquence d'échantillonnage est de 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]))
#Concernant les voyelles étirées
if label in nobashi_boin:
label = label[0]
voice_data = v[start:end]
#Fenêtre bourdonnante
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)
Maintenant que nous avons créé une différence quadratique, nous pouvons créer une trame de données en utilisant phoneme, `` `` feature_data, `delta_list```,` `delta_2_list```. Veuillez créer. Aussi, je pense que la classification peut être utilisée en faisant correspondre le formulaire avec le programme SVM mentionné précédemment.
Le résultat de la classification à l'aide de SVM en ajoutant le montant de la différence est le suivant. Pour les deux résultats, la précision de la reconnaissance est basée sur les caractéristiques du MFCC pour chaque largeur de fenêtre. À propos des voyelles, les données phonétiques (environ 32500) sont utilisées pour la classification.
MFCC(12 dimensions)Seuls les résultats
train_result
Linear : 0.8297360883797054
Poly : 0.8647708674304418
RBF : 0.8777618657937807
----------------------------------------
test_result
Linear : 0.8230149597238204
Poly : 0.8420406597621788
RBF : 0.8566168009205984
MFCC+Résultat de l'addition à la différence quadratique de puissance logarithmique
train_result
Linear : 0.8631853518821604
Poly : 0.9549918166939444
RBF : 0.9495703764320785
----------------------------------------
test_result
Linear : 0.8588415803605677
Poly : 0.9132336018411967
RBF : 0.9177598772535481
En utilisant la différence dynamique, la précision de reconnaissance peut être améliorée de ** environ 6% **. Puisque des données continues sont utilisées pour l'analyse, il a été confirmé que le changement du son avant et après est caractéristique et efficace.
Ensuite, classons également les consonnes. Environ 27 000 données de consonnes sont utilisées pour la classification.
MFCC(12 dimensions)Seuls les résultats
train_result
Linear : 0.418983174835406
Poly : 0.5338332114118508
RBF : 0.5544989027066569
----------------------------------------
test_result
Linear : 0.4189448660510195
Poly : 0.4599067385937643
RBF : 0.49419402029807075
MFCC+Le résultat de l'addition de la différence quadratique de puissance logarithmique
train_result
Linear : 0.5945501097293343
Poly : 0.8152889539136796
RBF : 0.8201658132162887
----------------------------------------
test_result
Linear : 0.5684374142817957
Poly : 0.6783395812379994
RBF : 0.7101581786595959
Les consonnes ont également montré une amélioration significative de la précision (** environ 22% **) par rapport à celles utilisant les caractéristiques du MFCC (12 dimensions). Puisque le changement de la forme d'onde de la consonne est plus grand que celui de la voyelle, il a été confirmé que la différence dynamique est plus efficace en tant que caractéristique. D'autre part, à mesure que la quantité de caractéristiques augmente, la différence de précision entre le test et le train s'élargit, de sorte que le manque de données est considéré comme un problème.
En ce qui concerne les voyelles, il a été confirmé que la précision était améliorée en utilisant la quantité de caractéristiques de l'enroulement du spectre en utilisant MFCC par rapport à l'analyse des formants. Au début de la phrase, j'ai déclaré que l'analyse des formants est suffisante pour les voyelles uniquement, mais que pour les données de prononciation d'une seule voyelle. Cependant, cette fois, comme pour les données de voyelle, nous avons utilisé les données d'énonciation de la phrase segmentée à l'aide de julius. Dans le cas de telles données de voyelle, elles sont affectées par les sons précédents et suivants, et il est possible que la forme d'onde diffère de celle qui a produit une voyelle unique. Par conséquent, il y a des changements dans la forme d'onde qui ne peuvent pas être capturés par l'analyse des formants, et on pense que la précision a été améliorée en utilisant MFCC. En outre, étant donné qu'il est affecté par les changements des sons avant et après, on suppose que la précision a été encore améliorée en ajoutant une différence dynamique.
Concernant les consonnes, trois choses peuvent être dites à partir de ce résultat.
Cet article décrit de la théorie à la vérification de classification réelle du MFCC, qui est le plus souvent utilisé dans les modèles acoustiques. Une bibliothèque (librosa) est préparée pour MFCC, et elle peut être facilement implémentée, j'ai donc expliqué en détail un exemple de sa théorie et ses résultats d'utilisation. J'espère que cet article mènera à une compréhension du mécanisme de reconnaissance vocale et des indices pour sa mise en œuvre.
À l'avenir, je voudrais aborder le modèle acoustique et le modèle de langage pour les phonèmes continus.
Recommended Posts