AI avec Python - Reconnaissance vocale

Dans ce chapitre, nous découvrirons la reconnaissance vocale à l'aide de l'IA avec Python.

La parole est le moyen le plus élémentaire de communication humaine adulte. Le but fondamental du traitement de la parole est de fournir une interaction entre un humain et une machine.

Le système de traitement de la parole a principalement trois tâches -

  • First, la reconnaissance vocale qui permet à la machine de saisir les mots, les phrases et les phrases que nous prononçons

  • Second, traitement du langage naturel pour permettre à la machine de comprendre ce que nous parlons, et

  • Third, synthèse vocale pour permettre à la machine de parler.

Ce chapitre se concentre sur speech recognition, le processus de compréhension des mots prononcés par les êtres humains. N'oubliez pas que les signaux vocaux sont capturés à l'aide d'un microphone et qu'ils doivent ensuite être compris par le système.

Construire un logiciel de reconnaissance vocale

La reconnaissance vocale ou la reconnaissance vocale automatique (ASR) est le centre d'attention des projets d'IA comme la robotique. Sans ASR, il n'est pas possible d'imaginer un robot cognitif interagissant avec un humain. Cependant, il n'est pas assez facile de créer un logiciel de reconnaissance vocale.

Difficultés à développer un système de reconnaissance vocale

Développer un système de reconnaissance vocale de haute qualité est vraiment un problème difficile. La difficulté de la technologie de reconnaissance vocale peut être largement caractérisée selon un certain nombre de dimensions, comme indiqué ci-dessous -

  • Size of the vocabulary- La taille du vocabulaire a un impact sur la facilité de développement d'un ASR. Considérez les tailles de vocabulaire suivantes pour une meilleure compréhension.

    • Un vocabulaire de petite taille se compose de 2 à 100 mots, par exemple, comme dans un système de menu vocal

    • Un vocabulaire de taille moyenne se compose de plusieurs centaines à 1000 mots, par exemple, comme dans une tâche de recherche de base de données

    • Un vocabulaire de grande taille se compose de plusieurs 10 000 mots, comme dans une tâche de dictée générale.

    Notez que plus la taille du vocabulaire est grande, plus il est difficile d'effectuer la reconnaissance.

  • Channel characteristics- La qualité des canaux est également une dimension importante. Par exemple, la parole humaine contient une bande passante élevée avec une plage de fréquences complète, tandis qu'une parole téléphonique se compose d'une bande passante faible avec une plage de fréquences limitée. Notez que c'est plus dur dans ce dernier.

  • Speaking mode- La facilité de développement d'un ASR dépend également du mode de parole, c'est-à-dire si la parole est en mode mot isolé, ou en mode mot connecté, ou en mode parole continue. Notez qu'un discours continu est plus difficile à reconnaître.

  • Speaking style- Un discours lu peut être dans un style formel, ou spontané et conversationnel avec un style décontracté. Ce dernier est plus difficile à reconnaître.

  • Speaker dependency- La parole peut être dépendante du locuteur, adaptative ou indépendante du locuteur. Un haut-parleur indépendant est le plus difficile à construire.

  • Type of noise- Le bruit est un autre facteur à prendre en compte lors du développement d'un ASR. Le rapport signal sur bruit peut se situer dans diverses plages, en fonction de l'environnement acoustique qui observe moins de bruit de fond par rapport à plus -

    • Si le rapport signal sur bruit est supérieur à 30 dB, il est considéré comme une plage haute

    • Si le rapport signal sur bruit se situe entre 30 dB et 10 dB, il est considéré comme un SNR moyen

    • Si le rapport signal sur bruit est inférieur à 10 dB, il est considéré comme une plage basse

    Par exemple, le type de bruit de fond tel que le bruit stationnaire, non humain, la parole de fond et la diaphonie par d'autres locuteurs contribue également à la difficulté du problème.

  • Microphone characteristics- La qualité du microphone peut être bonne, moyenne ou inférieure à la moyenne. De plus, la distance entre la bouche et le micro-téléphone peut varier. Ces facteurs doivent également être pris en compte pour les systèmes de reconnaissance.

Malgré ces difficultés, les chercheurs ont beaucoup travaillé sur divers aspects de la parole tels que la compréhension du signal vocal, le locuteur et l'identification des accents.

Vous devrez suivre les étapes ci-dessous pour créer un logiciel de reconnaissance vocale -

Visualiser les signaux audio - Lire à partir d'un fichier et travailler dessus

Il s'agit de la première étape de la construction d'un système de reconnaissance vocale, car il permet de comprendre comment un signal audio est structuré. Voici quelques étapes courantes qui peuvent être suivies pour travailler avec des signaux audio:

Enregistrement

Lorsque vous devez lire le signal audio d'un fichier, enregistrez-le d'abord à l'aide d'un microphone.

Échantillonnage

Lors de l'enregistrement avec microphone, les signaux sont stockés sous une forme numérisée. Mais pour y travailler, la machine en a besoin sous forme numérique discrète. Par conséquent, nous devons effectuer un échantillonnage à une certaine fréquence et convertir le signal sous la forme numérique discrète. Le choix de la haute fréquence d'échantillonnage implique que lorsque les humains écoutent le signal, ils le ressentent comme un signal audio continu.

Exemple

L'exemple suivant montre une approche par étapes pour analyser un signal audio, à l'aide de Python, qui est stocké dans un fichier. La fréquence de ce signal audio est de 44 100 HZ.

Importez les packages nécessaires comme indiqué ici -

import numpy as np
import matplotlib.pyplot as plt
from scipy.io import wavfile

Maintenant, lisez le fichier audio stocké. Il renverra deux valeurs: la fréquence d'échantillonnage et le signal audio. Fournissez le chemin du fichier audio où il est stocké, comme indiqué ici -

frequency_sampling, audio_signal = wavfile.read("/Users/admin/audio_file.wav")

Affichez les paramètres tels que la fréquence d'échantillonnage du signal audio, le type de données du signal et sa durée, à l'aide des commandes indiquées -

print('\nSignal shape:', audio_signal.shape)
print('Signal Datatype:', audio_signal.dtype)
print('Signal duration:', round(audio_signal.shape[0] / 
float(frequency_sampling), 2), 'seconds')

Cette étape consiste à normaliser le signal comme indiqué ci-dessous -

audio_signal = audio_signal / np.power(2, 15)

Dans cette étape, nous extrayons les 100 premières valeurs de ce signal à visualiser. Utilisez les commandes suivantes à cet effet -

audio_signal = audio_signal [:100]
time_axis = 1000 * np.arange(0, len(signal), 1) / float(frequency_sampling)

Maintenant, visualisez le signal en utilisant les commandes données ci-dessous -

plt.plot(time_axis, signal, color='blue')
plt.xlabel('Time (milliseconds)')
plt.ylabel('Amplitude')
plt.title('Input audio signal')
plt.show()

Vous pourrez voir un graphique de sortie et des données extraites pour le signal audio ci-dessus, comme indiqué dans l'image ici 

Signal shape: (132300,)
Signal Datatype: int16
Signal duration: 3.0 seconds

Caractérisation du signal audio: transformation en domaine fréquentiel

La caractérisation d'un signal audio implique la conversion du signal du domaine temporel en domaine fréquentiel et la compréhension de ses composantes fréquentielles par. C'est une étape importante car elle donne beaucoup d'informations sur le signal. Vous pouvez utiliser un outil mathématique tel que la transformation de Fourier pour effectuer cette transformation.

Exemple

L'exemple suivant montre, étape par étape, comment caractériser le signal, à l'aide de Python, qui est stocké dans un fichier. Notez qu'ici, nous utilisons l'outil mathématique de transformée de Fourier pour le convertir en domaine fréquentiel.

Importez les packages nécessaires, comme indiqué ici -

import numpy as np
import matplotlib.pyplot as plt
from scipy.io import wavfile

Maintenant, lisez le fichier audio stocké. Il renverra deux valeurs: la fréquence d'échantillonnage et le signal audio. Fournissez le chemin du fichier audio où il est stocké comme indiqué dans la commande ici -

frequency_sampling, audio_signal = wavfile.read("/Users/admin/sample.wav")

Dans cette étape, nous afficherons les paramètres tels que la fréquence d'échantillonnage du signal audio, le type de données du signal et sa durée, en utilisant les commandes données ci-dessous -

print('\nSignal shape:', audio_signal.shape)
print('Signal Datatype:', audio_signal.dtype)
print('Signal duration:', round(audio_signal.shape[0] / 
float(frequency_sampling), 2), 'seconds')

Dans cette étape, nous devons normaliser le signal, comme indiqué dans la commande suivante -

audio_signal = audio_signal / np.power(2, 15)

Cette étape consiste à extraire la longueur et la demi-longueur du signal. Utilisez les commandes suivantes à cet effet -

length_signal = len(audio_signal)
half_length = np.ceil((length_signal + 1) / 2.0).astype(np.int)

Maintenant, nous devons appliquer des outils mathématiques pour la transformation en domaine fréquentiel. Ici, nous utilisons la transformée de Fourier.

signal_frequency = np.fft.fft(audio_signal)

Maintenant, faites la normalisation du signal du domaine fréquentiel et mettez-le au carré -

signal_frequency = abs(signal_frequency[0:half_length]) / length_signal
signal_frequency **= 2

Ensuite, extrayez la longueur et la demi-longueur du signal transformé en fréquence -

len_fts = len(signal_frequency)

Notez que le signal transformé de Fourier doit être ajusté pour les cas pairs et impairs.

if length_signal % 2:
   signal_frequency[1:len_fts] *= 2
else:
   signal_frequency[1:len_fts-1] *= 2

Maintenant, extrayez la puissance en décibales (dB) -

signal_power = 10 * np.log10(signal_frequency)

Ajustez la fréquence en kHz pour l'axe X -

x_axis = np.arange(0, len_half, 1) * (frequency_sampling / length_signal) / 1000.0

Maintenant, visualisez la caractérisation du signal comme suit -

plt.figure()
plt.plot(x_axis, signal_power, color='black')
plt.xlabel('Frequency (kHz)')
plt.ylabel('Signal power (dB)')
plt.show()

Vous pouvez observer le graphique de sortie du code ci-dessus comme indiqué dans l'image ci-dessous -

Génération d'un signal audio monotone

Les deux étapes que vous avez vues jusqu'à présent sont importantes pour connaître les signaux. Maintenant, cette étape sera utile si vous souhaitez générer le signal audio avec certains paramètres prédéfinis. Notez que cette étape enregistrera le signal audio dans un fichier de sortie.

Exemple

Dans l'exemple suivant, nous allons générer un signal monotone, en utilisant Python, qui sera stocké dans un fichier. Pour cela, vous devrez suivre les étapes suivantes -

Importez les packages nécessaires comme indiqué -

import numpy as np
import matplotlib.pyplot as plt
from scipy.io.wavfile import write

Fournissez le fichier dans lequel le fichier de sortie doit être enregistré

output_file = 'audio_signal_generated.wav'

Maintenant, spécifiez les paramètres de votre choix, comme indiqué -

duration = 4 # in seconds
frequency_sampling = 44100 # in Hz
frequency_tone = 784
min_val = -4 * np.pi
max_val = 4 * np.pi

Dans cette étape, nous pouvons générer le signal audio, comme indiqué -

t = np.linspace(min_val, max_val, duration * frequency_sampling)
audio_signal = np.sin(2 * np.pi * tone_freq * t)

Maintenant, enregistrez le fichier audio dans le fichier de sortie -

write(output_file, frequency_sampling, signal_scaled)

Extrayez les 100 premières valeurs de notre graphique, comme indiqué -

audio_signal = audio_signal[:100]
time_axis = 1000 * np.arange(0, len(signal), 1) / float(sampling_freq)

Maintenant, visualisez le signal audio généré comme suit -

plt.plot(time_axis, signal, color='blue')
plt.xlabel('Time in milliseconds')
plt.ylabel('Amplitude')
plt.title('Generated audio signal')
plt.show()

Vous pouvez observer le graphique comme indiqué dans la figure donnée ici -

Extraction de fonctionnalités à partir de la parole

Il s'agit de l'étape la plus importante dans la construction d'un module de reconnaissance vocale car après avoir converti le signal vocal dans le domaine fréquentiel, nous devons le convertir en la forme utilisable de vecteur de caractéristiques. Nous pouvons utiliser différentes techniques d'extraction de caractéristiques comme MFCC, PLP, PLP-RASTA etc. à cette fin.

Exemple

Dans l'exemple suivant, nous allons extraire les fonctionnalités du signal, étape par étape, en utilisant Python, en utilisant la technique MFCC.

Importez les packages nécessaires, comme indiqué ici -

import numpy as np
import matplotlib.pyplot as plt
from scipy.io import wavfile
from python_speech_features import mfcc, logfbank

Maintenant, lisez le fichier audio stocké. Il renverra deux valeurs - la fréquence d'échantillonnage et le signal audio. Indiquez le chemin du fichier audio dans lequel il est stocké.

frequency_sampling, audio_signal = wavfile.read("/Users/admin/audio_file.wav")

Notez que nous prenons ici les 15 000 premiers échantillons pour analyse.

audio_signal = audio_signal[:15000]

Utilisez les techniques MFCC et exécutez la commande suivante pour extraire les fonctionnalités MFCC -

features_mfcc = mfcc(audio_signal, frequency_sampling)

Maintenant, imprimez les paramètres MFCC, comme indiqué -

print('\nMFCC:\nNumber of windows =', features_mfcc.shape[0])
print('Length of each feature =', features_mfcc.shape[1])

Maintenant, tracez et visualisez les fonctionnalités MFCC à l'aide des commandes données ci-dessous -

features_mfcc = features_mfcc.T
plt.matshow(features_mfcc)
plt.title('MFCC')

Dans cette étape, nous travaillons avec les fonctionnalités de banque de filtres comme indiqué -

Extraire les fonctionnalités de la banque de filtres -

filterbank_features = logfbank(audio_signal, frequency_sampling)

Maintenant, imprimez les paramètres du banc de filtres.

print('\nFilter bank:\nNumber of windows =', filterbank_features.shape[0])
print('Length of each feature =', filterbank_features.shape[1])

Maintenant, tracez et visualisez les fonctionnalités du banc de filtres.

filterbank_features = filterbank_features.T
plt.matshow(filterbank_features)
plt.title('Filter bank')
plt.show()

À la suite des étapes ci-dessus, vous pouvez observer les sorties suivantes: Figure1 pour MFCC et Figure2 pour Filter Bank

Reconnaissance des mots prononcés

La reconnaissance vocale signifie que lorsque les humains parlent, une machine le comprend. Ici, nous utilisons l'API Google Speech en Python pour y arriver. Nous devons installer les packages suivants pour cela -

  • Pyaudio - Il peut être installé en utilisant pip install Pyaudio commander.

  • SpeechRecognition - Ce package peut être installé en utilisant pip install SpeechRecognition.

  • Google-Speech-API - Il peut être installé en utilisant la commande pip install google-api-python-client.

Exemple

Observez l'exemple suivant pour comprendre la reconnaissance des mots prononcés -

Importez les packages nécessaires comme indiqué -

import speech_recognition as sr

Créez un objet comme indiqué ci-dessous -

recording = sr.Recognizer()

Maintenant le Microphone() le module prendra la voix comme entrée -

with sr.Microphone() as source: recording.adjust_for_ambient_noise(source)
   print("Please Say something:")
   audio = recording.listen(source)

Maintenant, l'API Google reconnaîtrait la voix et donnerait le résultat.

try:
   print("You said: \n" + recording.recognize_google(audio))
except Exception as e:
   print(e)

Vous pouvez voir la sortie suivante -

Please Say Something:
You said:

Par exemple, si vous avez dit tutorialspoint.com, le système le reconnaît correctement comme suit -

tutorialspoint.com