Intelligence artificielle

Analyse de reconnaissance vocale – Vers la science des données

Analyse de reconnaissance vocale - Vers la science des données


Construisez un modèle de reconnaissance vocale à l'aide de Keras.

De Siri aux appareils intelligents pour la maison, la reconnaissance vocale est largement utilisée dans nos vies. Ce projet de reconnaissance vocale consiste à utiliser le jeu de données de défi de reconnaissance vocale Kaggle pour créer un modèle Keras sur Tensorflow et effectuer des prédictions sur les fichiers vocaux.

https://cosmosmagazine.com/technology/hey-siri-how-does-voice-recognition-work

Le lien du jeu de données de défi de reconnaissance vocale Kaggle est répertorié ci-dessous:

Semblable à la reconnaissance d'image, la partie la plus importante de la reconnaissance vocale consiste à convertir des fichiers audio en matrices 2X2.

Taux d'échantillonnage et vague brute de fichiers audio:

La fréquence d'échantillonnage d'un fichier audio représente le nombre d'échantillons d'audio transmis par seconde et est mesurée en Hz. L'image suivante montre la relation entre l'onde brute audio et la fréquence d'échantillonnage du fichier audio «lit»:

train_audio_path = 'C:\Utilisateurs\...\train\l'audio'
filename = '\lit\00f0204f_nohash_0.wav '
taux_échantillonnage, échantillons = wavfile.read (str (train_audio_path) + nom du fichier)
ipd.Audio (samples, rate = sample_rate)
print (sample_rate)
imprimer (échantillons)
La fréquence d'échantillonnage est le nombre d'échantillons d'audio transmis par seconde, mesurés en Hz.
# visualise cette onde audio:
fig = plt.figure (figsize = (14, 8))
plt.plot (samples)
plt.title ('Raw wave of' + nom de fichier)
plt.ylabel ('Wave')
plt.show ()

Ensuite, je présenterai deux attributs importants des fichiers audio:

Spectrogramme:

Le spectrogramme est une représentation spectro-temporelle du son. La direction horizontale du spectrogramme représente le temps, la direction verticale représente la fréquence. (1) Les spectrogrammes peuvent être utilisés pour visualiser le changement du contenu fréquentiel d’un signal non stationnaire dans le temps.

La formule du spectrogramme (2) est listée ci-dessous:

J'ai utilisé le code des sites ci-dessous pour calculer et visualiser le logrogramme:

https://www.tensorflow.org/api_guides/python/contrib.signal https://github.com/Tony607/tf_audio_signal/blob/master/tf_audio_signal.ipynb

def log_spectrogramme (fichier, étiquette):
taux_échantillonnage, échantillons = wavfile.read (str (train_audio_path) + '\'+ label +'\'+ fichier)
signaux = tf.cast (tf.reshape (échantillons, [1,-1 ]), tf.float32)
spectrogramme = signal.stft (signaux, frame_length = 1024, frame_step = 512)
magnitude_spectrogrammes = tf.abs (spectrogramme)
log_offset = 1e-6
#Lorsque vous compressez avec un logarithme, c'est une bonne idée d'utiliser un offset stabilisant
#pour éviter les plages dynamiques élevées causées par la singularité à zéro.
log_magnitude_spectrograms = tf.log (magnitude_spectrograms + log_offset)
revenir log_magnitude_spectrogrammes

Tracez ensuite le log_spectrogramme de l'échantillon de données: lit.

log_spe_bed = log_spectrogram (train.file[0]train.label[0]) .numpy ()
array_bed = log_spe_bed.astype (np.float)[0]
fig = plt.figure (figsize = (14,8))
# plt.ylabel ("Freqs in Hz")
plt.xlabel ("Log_Spectrogram")
plt.imshow (np.swapaxes (array_bed, 0,1) .T)

Coefficient Cepstral de Fréquence Mel (MFCC):

Le coefficient de fréquence de Mel (fréquence) est la caractéristique la plus utilisée dans la reconnaissance automatique de la parole et du locuteur. L'échelle Mel relie la fréquence perçue, ou hauteur d'un ton pur, à la fréquence réelle mesurée. Les humains sont beaucoup mieux à même de discerner les petits changements de hauteur dans les basses fréquences que dans les hautes fréquences. En incorporant cette échelle, nos fonctionnalités correspondent plus étroitement à ce que les humains entendent. (3)

def mfcc (fichier = train['file'].tolist (), label = train['label'].lister()):
taux_échantillonnage, échantillons = wavfile.read (str (train_audio_path) + '\'+ label +'\'+ fichier)
si len (échantillons) <16000:
samples = np.pad (samples, (0,16000-len (samples)), 'linear_ramp')
autre:
échantillons = échantillons[:16000]
signaux = tf.cast (tf.reshape (échantillons, [1,-1 ]), tf.float32)
spectrogramme = signal.stft (signaux, frame_length = 1024, frame_step = 512)
magnitude_spectrogrammes = tf.abs (spectrogramme)
num_spectrogram_bins = magnitude_spectrograms.shape[-1].valeur
lower_edge_hertz, upper_edge_hertz, num_mel_bins = 80.0, 7600.0, 64
linear_to_mel_weight_matrix = tf.contrib.signal.linear_to_mel_weight_matrix (num_mel_bins, num_spectrogram_bins, sample_rate, lower_edge_hertz, upper_edge_hertz)
mel_spectrograms = tf.tensordot (magnitude_spectrograms, linear_to_mel_weight_matrix, 1)
# Remarque: inférence de forme pour tf.tensordot ne gère pas actuellement ce cas.
mel_spectrograms.set_shape (magnitude_spectrograms.shape[:-1].concatenate (linear_to_mel_weight_matrix.shape[-1:]))
log_offset = 1e-6
log_mel_spectrograms = tf.log (mel_spectrograms + log_offset)
num_mfccs = 13
# Conservez les premiers MFCC `num_mfccs`.
mfccs = tf.contrib.signal.mfccs_from_log_mel_spectrograms (log_mel_spectrograms)[..., :num_mfccs]
revenir mfccs.numpy ()[0]

En utilisant la fonction «mfcc» définie ci-dessus, il est facile de calculer le mfcc du fichier audio de «bed» et de visualiser son MFCC.

mfcc_bed = mfcc (train.file[0]train.label[0])
fig = plt.figure (figsize = (14,8))
plt.ylabel ("coefficient MFCC (log)")
plt.imshow (np.swapaxes (mfcc_bed, 0,1))

J'ai construit un modèle de réseau neuronal séquentiel, qui est la méthode la plus simple pour créer un modèle dans Keras. Il indique à keras d'empiler toutes les couches de manière séquentielle. Ensuite, j'ai ajouté quatre couches denses, qui sont entièrement liées dans le modèle.

Référence: https://towardsdatascience.com/applied-deep-learning-part-1-artificial-neural-networks-d7834f67a4f6

Après avoir construit le modèle, j'ai utilisé Adaptive Moment Estimation comme optimiseur, crossoptopie catégorique comme perte et la précision comme métriques pour compiler le modèle.

# Dense (64) est une couche entièrement connectée avec 64 unités cachées.
# dans la première couche, vous devez spécifier la forme de données d'entrée attendue:
# ici, vecteurs à 20 dimensions.
avec tf.Session () comme sess0:
affirmer ne pas tf.executing_eagerly ()
modèle = séquentiel ()

model.add (layers.Dense (32, input_shape = X_train_array.shape)[1:], activation = 'tanh'))
model.add (Dense (64, activation = 'tanh'))
model.add (Dense (128, activation = 'tanh'))

model.add (Flatten ())
# model.add (Dense (256, activation = 'relu'))

model.add (Dense (30))
model.add (activation ('sigmoid'))

model.compile (loss = 'categorical_crossentropy', optimiseur = 'adam', metrics =['accuracy'])
#Adam, un algorithme d'optimisation basée sur le gradient du premier ordre de fonctions objectives stochastiques, basé sur des estimations adaptatives de moments d'ordre inférieur.
model.summary ()

# history = model.fit (x = X_train_array, y = y_train_array, epochs = 5, verbose = 1, validation_split = 0.33, shuffle = True, class_weight = get_class_weights (pd.Series ((liste (étiquettes)),), dtype = 'catégorie'). cat.codes.values), batch_size = batch_size)
history = model.fit (x = X_train_array, y = y_train_array, epochs = 25, verbose = 1, validation_split = 0.1, shuffle =Vrai, class_weight = get_class_weights (pd.Series (Y_train, dtype = 'category'). cat.codes.values), batch_size = 128)

model_evaluation = model.evaluate (x = X_test_array, y = y_test_array, batch_size =Aucun, verbeux = 1)

prediction = model.predict (X_test_array, batch_size = 128, verbose = 1)

april_tst = model.predict (mfcc_april_test, batch_size = 128, verbose = 1)

sess0.close ()

Modèle de réseau neuronal séquentiel chez Keras

J'ai choisi 25 comme nombre d'époques, qui correspond au nombre de fois où le modèle parcourt les données. Après avoir fonctionné environ 20 époques, la précision de validation du modèle est améliorée de 61% à 62%.

Précision du modèle concernant le nombre d'époques
Perte de modèle concernant le nombre d'époques

Comme nous pouvons le constater à partir des deux images ci-dessus, la précision des tests et des trains n'est pas suffisamment proche les uns des autres, ce qui signifie que ce modèle peut être amélioré en surmontant les problèmes de sur-adaptation.

  1. Le fichier audio est généralement converti en tableau pour être l'entrée du modèle Keras.
  2. Spectrogram et MFCC sont les deux fonctionnalités des fichiers audio à convertir en tableaux.
  3. Nous pouvons modifier les couches du modèle Keras pour augmenter la précision du modèle.
  4. Soyez conscient des problèmes de sur-adaptation en comparant la formation et la précision des tests.
  5. Le modèle séquentiel est plus facile à modifier que le modèle API de Keras.
  1. Pour prédire avec précision les voix avec des bruits dans le fichier audio «test» du jeu de données Kaggle, je dois traiter les données d'entraînement actuelles en ajoutant un bruit de fond.
  2. Puisqu'il y a des voix inconnues dans le fichier audio «test» de Kaggle, je dois également ajouter «inconnu» comme l'une de mes étiquettes.
  3. Je peux également normaliser les mfcc des données d'entraînement pour voir si je peux améliorer la précision du modèle.
  4. Je peux également utiliser la combinaison de CNN et RNN pour voir si je peux améliorer la précision du modèle ou non.
  1. Paul Boersma et David Weenink Introduction 3.1. Regarder un spectrogramme, Institut des sciences de la phonétique de l'Université d'Amsterdam
  2. Wikipedia: https://en.wikipedia.org/wiki/Short-time_Fourier_transform
  3. Cryptographie: http://practicalcryptography.com/miscipes/machine-learning/guide-mel-frequency-cepstral-coefficients-mfccs/
  4. Chris Dinant, Défi de reconnaissance vocale Kaggle Tensorflow
  1. https://www.kaggle.com/davids1992/speech-representation-and-data-exploration
  2. https://www.kaggle.com/ollmer/labels-spectrograms-exploration
  3. https://github.com/Tony607/tf_audio_signal/blob/master/tf_audio_signal.ipynb
  4. https://towardsdatascience.com/kaggle-tensorflow-speech-recognition-challenge-b46a3bca2501
  5. https://www.kaggle.com/kcs93023/keras-sequential-conv1d-model-classification
Afficher plus

SupportIvy

SupportIvy.com : Un lieu pour partager le savoir et mieux comprendre le monde. Meilleure plate-forme de support gratuit pour vous, Documentation &Tutoriels par les experts.

Articles similaires

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *

Bouton retour en haut de la page
Fermer