Code for How to Make a Speech Emotion Recognizer Using Python And Scikit-learn Tutorial

utils.py

import soundfile import numpy as np import librosa import glob import os from sklearn.model_selection import train_test_split # all emotions on RAVDESS dataset int2emotion = { "01": "neutral", "02": "calm", "03": "happy", "04": "sad", "05": "angry", "06": "fearful", "07": "disgust", "08": "surprised" } # we allow only these emotions AVAILABLE_EMOTIONS = { "angry", "sad", "neutral", "happy" } def extract_feature(file_name, **kwargs): """ Extract feature from audio file `file_name` Features supported: - MFCC (mfcc) - Chroma (chroma) - MEL Spectrogram Frequency (mel) - Contrast (contrast) - Tonnetz (tonnetz) e.g: `features = extract_feature(path, mel=True, mfcc=True)` """ mfcc = kwargs.get("mfcc") chroma = kwargs.get("chroma") mel = kwargs.get("mel") contrast = kwargs.get("contrast") tonnetz = kwargs.get("tonnetz") with soundfile.SoundFile(file_name) as sound_file: X = sound_file.read(dtype="float32") sample_rate = sound_file.samplerate if chroma or contrast: stft = np.abs(librosa.stft(X)) result = np.array([]) if mfcc: mfccs = np.mean(librosa.feature.mfcc(y=X, sr=sample_rate, n_mfcc=40).T, axis=0) result = np.hstack((result, mfccs)) if chroma: chroma = np.mean(librosa.feature.chroma_stft(S=stft, sr=sample_rate).T,axis=0) result = np.hstack((result, chroma)) if mel: mel = np.mean(librosa.feature.melspectrogram(X, sr=sample_rate).T,axis=0) result = np.hstack((result, mel)) if contrast: contrast = np.mean(librosa.feature.spectral_contrast(S=stft, sr=sample_rate).T,axis=0) result = np.hstack((result, contrast)) if tonnetz: tonnetz = np.mean(librosa.feature.tonnetz(y=librosa.effects.harmonic(X), sr=sample_rate).T,axis=0) result = np.hstack((result, tonnetz)) return result def load_data(test_size=0.2): X, y = [], [] for file in glob.glob("data/Actor_*/*.wav"): # get the base name of the audio file basename = os.path.basename(file) # get the emotion label emotion = int2emotion[basename.split("-")[2]] # we allow only AVAILABLE_EMOTIONS we set if emotion not in AVAILABLE_EMOTIONS: continue # extract speech features features = extract_feature(file, mfcc=True, chroma=True, mel=True) # add to data X.append(features) y.append(emotion) # split the data to training and testing and return it return train_test_split(np.array(X), y, test_size=test_size, random_state=7)

ser.py

from sklearn.neural_network import MLPClassifier from sklearn.metrics import accuracy_score from utils import load_data import os import pickle # load RAVDESS dataset X_train, X_test, y_train, y_test = load_data(test_size=0.25) # print some details # number of samples in training data print("[+] Number of training samples:", X_train.shape[0]) # number of samples in testing data print("[+] Number of testing samples:", X_test.shape[0]) # number of features used # this is a vector of features extracted # using utils.extract_features() method print("[+] Number of features:", X_train.shape[1]) # best model, determined by a grid search model_params = { 'alpha': 0.01, 'batch_size': 256, 'epsilon': 1e-08, 'hidden_layer_sizes': (300,), 'learning_rate': 'adaptive', 'max_iter': 500, } # initialize Multi Layer Perceptron classifier # with best parameters ( so far ) model = MLPClassifier(**model_params) # train the model print("[*] Training the model...") model.fit(X_train, y_train) # predict 25% of data to measure how good we are y_pred = model.predict(X_test) # calculate the accuracy accuracy = accuracy_score(y_true=y_test, y_pred=y_pred) print("Accuracy: {:.2f}%".format(accuracy*100)) # now we save the model # make result directory if doesn't exist yet if not os.path.isdir("result"): os.mkdir("result") pickle.dump(model, open("result/mlp_classifier.model", "wb"))

test.py

import pyaudio import os import wave import pickle from sys import byteorder from array import array from struct import pack from sklearn.neural_network import MLPClassifier from utils import extract_feature THRESHOLD = 500 CHUNK_SIZE = 1024 FORMAT = pyaudio.paInt16 RATE = 16000 SILENCE = 30 def is_silent(snd_data): "Returns 'True' if below the 'silent' threshold" return max(snd_data) < THRESHOLD def normalize(snd_data): "Average the volume out" MAXIMUM = 16384 times = float(MAXIMUM)/max(abs(i) for i in snd_data) r = array('h') for i in snd_data: r.append(int(i*times)) return r def trim(snd_data): "Trim the blank spots at the start and end" def _trim(snd_data): snd_started = False r = array('h') for i in snd_data: if not snd_started and abs(i)>THRESHOLD: snd_started = True r.append(i) elif snd_started: r.append(i) return r # Trim to the left snd_data = _trim(snd_data) # Trim to the right snd_data.reverse() snd_data = _trim(snd_data) snd_data.reverse() return snd_data def add_silence(snd_data, seconds): "Add silence to the start and end of 'snd_data' of length 'seconds' (float)" r = array('h', [0 for i in range(int(seconds*RATE))]) r.extend(snd_data) r.extend([0 for i in range(int(seconds*RATE))]) return r def record(): """ Record a word or words from the microphone and return the data as an array of signed shorts. Normalizes the audio, trims silence from the start and end, and pads with 0.5 seconds of blank sound to make sure VLC et al can play it without getting chopped off. """ p = pyaudio.PyAudio() stream = p.open(format=FORMAT, channels=1, rate=RATE, input=True, output=True, frames_per_buffer=CHUNK_SIZE) num_silent = 0 snd_started = False r = array('h') while 1: # little endian, signed short snd_data = array('h', stream.read(CHUNK_SIZE)) if byteorder == 'big': snd_data.byteswap() r.extend(snd_data) silent = is_silent(snd_data) if silent and snd_started: num_silent += 1 elif not silent and not snd_started: snd_started = True if snd_started and num_silent > SILENCE: break sample_width = p.get_sample_size(FORMAT) stream.stop_stream() stream.close() p.terminate() r = normalize(r) r = trim(r) r = add_silence(r, 0.5) return sample_width, r def record_to_file(path): "Records from the microphone and outputs the resulting data to 'path'" sample_width, data = record() data = pack('<' + ('h'*len(data)), *data) wf = wave.open(path, 'wb') wf.setnchannels(1) wf.setsampwidth(sample_width) wf.setframerate(RATE) wf.writeframes(data) wf.close() if __name__ == "__main__": # load the saved model (after training) model = pickle.load(open("result/mlp_classifier.model", "rb")) print("Please talk") filename = "test.wav" # record the file (start talking) record_to_file(filename) # extract features and reshape it features = extract_feature(filename, mfcc=True, chroma=True, mel=True).reshape(1, -1) # predict result = model.predict(features)[0] # show the result ! print("result:", result)

convert_wavs.py

""" A utility script used for converting audio samples to be suitable for feature extraction """ import os def convert_audio(audio_path, target_path, remove=False): """This function sets the audio `audio_path` to: - 16000Hz Sampling rate - one audio channel ( mono ) Params: audio_path (str): the path of audio wav file you want to convert target_path (str): target path to save your new converted wav file remove (bool): whether to remove the old file after converting Note that this function requires ffmpeg installed in your system.""" os.system(f"ffmpeg -i {audio_path} -ac 1 -ar 16000 {target_path}") # os.system(f"ffmpeg -i {audio_path} -ac 1 {target_path}") if remove: os.remove(audio_path) def convert_audios(path, target_path, remove=False): """Converts a path of wav files to: - 16000Hz Sampling rate - one audio channel ( mono ) and then put them into a new folder called `target_path` Params: audio_path (str): the path of audio wav file you want to convert target_path (str): target path to save your new converted wav file remove (bool): whether to remove the old file after converting Note that this function requires ffmpeg installed in your system.""" for dirpath, dirnames, filenames in os.walk(path): for dirname in dirnames: dirname = os.path.join(dirpath, dirname) target_dir = dirname.replace(path, target_path) if not os.path.isdir(target_dir): os.mkdir(target_dir) for dirpath, _, filenames in os.walk(path): for filename in filenames: file = os.path.join(dirpath, filename) if file.endswith(".wav"): # it is a wav file target_file = file.replace(path, target_path) convert_audio(file, target_file, remove=remove) if __name__ == "__main__": import argparse parser = argparse.ArgumentParser(description="""Convert ( compress ) wav files to 16MHz and mono audio channel ( 1 channel ) This utility helps for compressing wav files for training and testing""") parser.add_argument("audio_path", help="Folder that contains wav files you want to convert") parser.add_argument("target_path", help="Folder to save new wav files") parser.add_argument("-r", "--remove", type=bool, help="Whether to remove the old wav file after converting", default=False) args = parser.parse_args() audio_path = args.audio_path target_path = args.target_path if os.path.isdir(audio_path): if not os.path.isdir(target_path): os.makedirs(target_path) convert_audios(audio_path, target_path, remove=args.remove) elif os.path.isfile(audio_path) and audio_path.endswith(".wav"): if not target_path.endswith(".wav"): target_path += ".wav" convert_audio(audio_path, target_path, remove=args.remove) else: raise TypeError("The audio_path file you specified isn't appropriate for this operation")