{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "# Hey, Jetson!\n", "\n", "### By Brice Walker\n", "\n", "[View the full project on GitHub](https://github.com/bricewalker/Hey-Jetson)\n", "\n", "[Render the notebook with nbviewer](https://nbviewer.jupyter.org/github/bricewalker/Hey-Jetson/blob/master/Speech.ipynb)\n", "\n", "\n", "## Outline\n", "\n", "- [Introduction](#intro)\n", "- [Importing Libraries](#libraries)\n", "- [Importing The Dataset](#data)\n", "- [Acoustic Feature Extraction/Engineering for Speech Recognition](#features)\n", "- [Visualizing The Data](#plotting)\n", " - [Raw Audio](#raw)\n", " - [Spectrograms](#spectograms)\n", " - [Mel-Frequency Cepstral Coefficients](#mfcc)\n", "- [Deep Neural Networks for Acoustic Modeling](#deeplearning)\n", " - [RNN](#rnn)\n", " - [RNN + TimeDistributed Dense](#rnntd)\n", " - [CNN + RNN + TimeDistributed Dense](#cnnrnn)\n", " - [Deeper RNN + TimeDistributed Dense](#deeprnn)\n", " - [Bidirectional RNN + TimeDistributed Dense](#bidirectional)\n", " - [CNN + Deeper Bidirectional RNN + TimeDistributed Dense](#cnndeepbi)\n", " - [Advanced Modeling Techniques](#modeling)\n", " - [Dropout](#dropout)\n", " - [Dilated Convolutions](#dilated)\n", " - [Aggregate Models](#aggregate)\n", " - [Deep Aggregate Model](#deepagg)\n", " - [Attention](#attention)\n", " - [Final Model](#final)\n", "- [Visualizing The Final Model Architecture](#architecture)\n", "- [Comparing Models](#selection)\n", " - [Final Model Performance](#test)\n", " - [Cosine Similarity](#similarity)\n", " - [Word Error Rate](#error_rate)\n", " - [Benchmarking Performance](#benchmark)\n", "- [Conclusion](#conclusion)\n", "\n", "\n", "## Introduction\n", "\n", "This project builds a scalable attention based speech recognition platform in Keras/Tensorflow for inference on the Nvidia Jetson. This real world application of automatic speech recognition was inspired by my career in mental health. This project begins a journey towards building a platform for real time therapeutic intervention inference and feedback. The ultimate intent was to build a tool that can give therapists real time feedback on the efficacy of their interventions, but this has many applications in mobile, robotics, or other areas where cloud based deep learning is not desirable.\n", "\n", "This notebook explores three common ways of visualizing/mathematically representing audio for use in machine learning models. This project then walks you through the construction of a series of increasingly complex character-level phonetics sequencing models. For this project, I have chosen Recurrent Neural Networks, as they allow us to harness the power of deep neural networks for time sequencing issues and allow fast training on GPU's compared to other models. I chose character level phonetics modeling as it provides a more accurate depiction of language and would allow building a system that can pick up on the nuances of human-to-human communication in deeply personal conversations. Additionally, this notebook explores measures of model performance and makes predictions based on the trained models.\n", "\n", "The final production model has a word error rate of roughly 16% and a cosine similarity score of about 79%.\n", "\n", "### Automatic Speech Recognition\n", "Speech recognition models are based on a statistical optimization problem called the fundamental equation of speech recognition. Given a sequence of observations, we look for the most likely character or word sequence. So, using Bayes Theory, we are looking for the sequence which maximizes the posterior probability of the character given the observation. The speech recognition problem is a search over this model for the best character sequence.\n", "\n", "Character level speech recognition can be broken into two parts; the acoustic model, that describes the distribution over acoustic observations, O, given the character sequence, C; and the language model based solely on the character sequence which assigns a probability to every possible character sequence. This sequence to sequence model combines both the acoustic and language models into one neural network, though pretrained acoustic models are available from [kaldi](http://www.kaldi-asr.org/downloads/build/6/trunk/egs/) if you would like to speed up training.\n", "\n", "### Problem Statement\n", "My goal was to build a character-level ASR system using an encoder/decoder based recurrent neural network with an attention mechanism in TensorFlow that can run inference on an Nvidia Jetson with a word error rate of <20%." ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "Using TensorFlow backend.\n" ] }, { "data": { "text/html": [ "" ], "text/vnd.plotly.v1+html": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "" ], "text/vnd.plotly.v1+html": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Common, File Based, and Math Imports\n", "import pandas as pd\n", "import numpy as np\n", "import collections\n", "import os\n", "from os.path import isdir, join\n", "from pathlib import Path\n", "from subprocess import check_output\n", "import sys\n", "import math\n", "import pickle\n", "from glob import glob\n", "import random\n", "from random import sample\n", "import json\n", "from mpl_toolkits.axes_grid1 import make_axes_locatable\n", "from numpy.lib.stride_tricks import as_strided\n", "from tqdm import tqdm\n", "\n", "# Audio processing\n", "from scipy import signal\n", "from scipy.fftpack import dct\n", "import soundfile\n", "import json\n", "from python_speech_features import mfcc\n", "import scipy.io.wavfile as wav\n", "from scipy.fftpack import fft\n", "\n", "# Neural Network\n", "import keras\n", "from keras.utils.generic_utils import get_custom_objects\n", "from keras import backend as K\n", "from keras import regularizers, callbacks\n", "from keras.constraints import max_norm\n", "from keras.models import Model, Sequential, load_model\n", "from keras.layers import Input, Lambda, Dense, Dropout, Flatten, Embedding, merge, Activation, GRUCell, LSTMCell,SimpleRNNCell\n", "from keras.layers import Convolution2D, MaxPooling2D, Convolution1D, Conv1D, SimpleRNN, GRU, LSTM, CuDNNLSTM, CuDNNGRU, Conv2D\n", "from keras.layers.advanced_activations import LeakyReLU, PReLU, ThresholdedReLU, ELU\n", "from keras.layers import LeakyReLU, PReLU, ThresholdedReLU, ELU\n", "from keras.layers import BatchNormalization, TimeDistributed, Bidirectional\n", "from keras.layers import activations, Wrapper\n", "from keras.regularizers import l2\n", "from keras.optimizers import Adam, SGD, RMSprop, Adagrad, Adadelta, Adamax, Nadam\n", "from keras.callbacks import ModelCheckpoint \n", "from keras.utils import np_utils\n", "from keras import constraints, initializers, regularizers\n", "from keras.engine.topology import Layer\n", "import keras.losses\n", "from keras.backend.tensorflow_backend import set_session\n", "from keras.engine import InputSpec\n", "import tensorflow as tf\n", "\n", "# Model metrics\n", "from sklearn.feature_extraction.text import CountVectorizer, TfidfVectorizer\n", "from sklearn.metrics.pairwise import cosine_similarity\n", "\n", "# Visualization\n", "import IPython.display as ipd\n", "from IPython.display import Markdown, display, Audio\n", "import matplotlib.pyplot as plt\n", "import seaborn as sns\n", "import plotly.offline as py\n", "import plotly.graph_objs as go\n", "import plotly.tools as tls\n", "\n", "py.init_notebook_mode(connected=True)\n", "color = sns.color_palette()\n", "sns.set_style('darkgrid')\n", "py.init_notebook_mode(connected=True)\n", "%matplotlib inline\n", "\n", "# Setting Random Seeds\n", "np.random.seed(95)\n", "RNG_SEED = 95\n", "\n", "# Suppressing some of Tensorflow's warnings\n", "tf.logging.set_verbosity(tf.logging.ERROR)" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[[22. 28.]\n", " [49. 64.]]\n" ] } ], "source": [ "# Simple matrix multiplication test to check if tf is using GPU device. \n", "with tf.device('/gpu:0'):\n", " a = tf.constant([1.0, 2.0, 3.0, 4.0, 5.0, 6.0], shape=[2, 3], name='a')\n", " b = tf.constant([1.0, 2.0, 3.0, 4.0, 5.0, 6.0], shape=[3, 2], name='b')\n", " c = tf.matmul(a, b)\n", "# If there is an output then it is able to access the device.\n", "with tf.Session() as sess:\n", " print (sess.run(c))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "## Importing The Dataset\n", "\n", "The primary dataset used is the [LibriSpeech ASR corpus](http://www.openslr.org/12/) which includes 1000 hours of recorded speech. A 960 hour subset of the dataset of audio files was used for model development and training. The dataset consists of 16kHz audio files of spoken English derived from read audiobooks from the LibriVox project. Some issues identified with this data set are the age of some of the works (the Declaration of Independence probably doesn't relate well to modern spoken English), the fact that there is much overlap in words spoken between the books, a lack of 'white noise' and other non-voice noises to help the model differentiate spoken words from background noise, and the fact that this does not include conversational English. An overview of the difficulties of working with data such as this can be found [here](https://awni.github.io/speech-recognition/).\n", "\n", "The dataset is prepared using a set of scripts borrowed from [Baidu Research's Deep Speech GitHub Repo](https://github.com/baidu-research/ba-dls-deepspeech). \n", "\n", "The dataset consists of 16kHz audio files between 2-15 seconds long. Using the prepared scripts, the audio files were converted to single channel (mono) WAV/WAVE files (.wav extension) with a 64k bit rate, and a 16kHz sample rate. They were encoded in PCM format, and then cut/padded to an equal length of 10 seconds. The pre-processing techniques used for the text transcriptions include the removal of any punctuation other than apostrophes, and transforming all characters to lowercase. Full instructions on how to download the dataset, convert the .flac files to .wav, and build the corpus are found in the README on the GitHub repository or in the wiki." ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Train Set Duration Mean: 12.301810444600907\n", "Valid Set Duration Mean: 6.795830092509413\n", "Test Set Duration Mean: 6.958454892966327\n" ] } ], "source": [ "train_corpus = pd.read_json('train_corpus.json', lines=True)\n", "valid_corpus = pd.read_json('valid_corpus.json', lines=True)\n", "test_corpus = pd.read_json('test_corpus.json', lines=True)\n", "train_duration_mean = train_corpus.duration.mean()\n", "valid_duration_mean = valid_corpus.duration.mean()\n", "test_duration_mean = test_corpus.duration.mean()\n", "print('Train Set Duration Mean:', train_duration_mean)\n", "print('Valid Set Duration Mean:', valid_duration_mean)\n", "print('Test Set Duration Mean:', test_duration_mean)" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Train Set Duration Median: 13.79\n", "Valid Set Duration Median: 5.53\n", "Test Set Duration Median: 5.455\n" ] } ], "source": [ "train_duration_median = train_corpus.duration.median()\n", "valid_duration_median = valid_corpus.duration.median()\n", "test_duration_median = test_corpus.duration.median()\n", "print('Train Set Duration Median:', train_duration_median)\n", "print('Valid Set Duration Median:', valid_duration_median)\n", "print('Test Set Duration Median:', test_duration_median)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Defining some initial functions for preparing the dataset" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "# Function for shuffling data which is important as neural networks make multiple passes through the data\n", "def shuffle_dataset(audio_paths, durations, texts):\n", " p = np.random.permutation(len(audio_paths))\n", " audio_paths = [audio_paths[i] for i in p] \n", " durations = [durations[i] for i in p] \n", " texts = [texts[i] for i in p]\n", " return audio_paths, durations, texts\n", "\n", "# Function for sorting data by duration\n", "def sort_dataset(audio_paths, durations, texts):\n", " p = np.argsort(durations).tolist()\n", " audio_paths = [audio_paths[i] for i in p]\n", " durations = [durations[i] for i in p] \n", " texts = [texts[i] for i in p]\n", " return audio_paths, durations, texts\n", "\n", "# Mapping each character that could be spoken at each time step\n", "char_map_str = \"\"\"\n", "' 0\n", " 1\n", "a 2\n", "b 3\n", "c 4\n", "d 5\n", "e 6\n", "f 7\n", "g 8\n", "h 9\n", "i 10\n", "j 11\n", "k 12\n", "l 13\n", "m 14\n", "n 15\n", "o 16\n", "p 17\n", "q 18\n", "r 19\n", "s 20\n", "t 21\n", "u 22\n", "v 23\n", "w 24\n", "x 25\n", "y 26\n", "z 27\n", "\"\"\"\n", "# This leaves \"blank\" character mapped to number 28\n", "\n", "char_map = {}\n", "index_map = {}\n", "for line in char_map_str.strip().split('\\n'):\n", " ch, index = line.split()\n", " char_map[ch] = int(index)\n", " index_map[int(index)+1] = ch\n", "index_map[2] = ' '\n", "\n", "# Function for converting text to an integer sequence\n", "def text_to_int_seq(text):\n", " int_sequence = []\n", " for c in text:\n", " if c == ' ':\n", " ch = char_map['']\n", " else:\n", " ch = char_map[c]\n", " int_sequence.append(ch)\n", " return int_sequence\n", "\n", "# Function for converting an integer sequence to text\n", "def int_seq_to_text(int_sequence):\n", " text = []\n", " for c in int_sequence:\n", " ch = index_map[c]\n", " text.append(ch)\n", " return text\n", "# Function for calculating feature dimensions.\n", "def calc_feat_dim(window, max_freq):\n", " return int(0.001 * window * max_freq) + 1" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Defining the primary class for preparing the dataset for visualization and modeling.\n", "\n", "This class provides options for training models on both MFCC's and Spectrograms of the data but is set to use spectrograms by default." ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "class AudioGenerator():\n", " def __init__(self, step=10, window=20, max_freq=8000, mfcc_dim=13,\n", " minibatch_size=20, desc_file=None, spectrogram=True, max_duration=10.0, \n", " sort_by_duration=False):\n", " # Initializing variables\n", " self.feat_dim = calc_feat_dim(window, max_freq)\n", " self.mfcc_dim = mfcc_dim\n", " self.feats_mean = np.zeros((self.feat_dim,))\n", " self.feats_std = np.ones((self.feat_dim,))\n", " self.rng = random.Random(RNG_SEED)\n", " if desc_file is not None:\n", " self.load_metadata_from_desc_file(desc_file)\n", " self.step = step\n", " self.window = window\n", " self.max_freq = max_freq\n", " self.cur_train_index = 0\n", " self.cur_valid_index = 0\n", " self.cur_test_index = 0\n", " self.max_duration=max_duration\n", " self.minibatch_size = minibatch_size\n", " self.spectrogram = spectrogram\n", " self.sort_by_duration = sort_by_duration\n", "\n", " def get_batch(self, partition):\n", " # Obtain a batch of audio files\n", " if partition == 'train':\n", " audio_paths = self.train_audio_paths\n", " cur_index = self.cur_train_index\n", " texts = self.train_texts\n", " elif partition == 'valid':\n", " audio_paths = self.valid_audio_paths\n", " cur_index = self.cur_valid_index\n", " texts = self.valid_texts\n", " elif partition == 'test':\n", " audio_paths = self.test_audio_paths\n", " cur_index = self.test_valid_index\n", " texts = self.test_texts\n", " else:\n", " raise Exception(\"Invalid partition. Must be train/validation/test\")\n", "\n", " features = [self.normalize(self.featurize(a)) for a in \n", " audio_paths[cur_index:cur_index+self.minibatch_size]]\n", "\n", " # Calculate size\n", " max_length = max([features[i].shape[0] \n", " for i in range(0, self.minibatch_size)])\n", " max_string_length = max([len(texts[cur_index+i]) \n", " for i in range(0, self.minibatch_size)])\n", " \n", " # Initialize arrays\n", " X_data = np.zeros([self.minibatch_size, max_length, \n", " self.feat_dim*self.spectrogram + self.mfcc_dim*(not self.spectrogram)])\n", " labels = np.ones([self.minibatch_size, max_string_length]) * 28\n", " input_length = np.zeros([self.minibatch_size, 1])\n", " label_length = np.zeros([self.minibatch_size, 1])\n", " \n", " for i in range(0, self.minibatch_size):\n", " # Calculate input_length\n", " feat = features[i]\n", " input_length[i] = feat.shape[0]\n", " X_data[i, :feat.shape[0], :] = feat\n", "\n", " # Calculate label_length\n", " label = np.array(text_to_int_seq(texts[cur_index+i])) \n", " labels[i, :len(label)] = label\n", " label_length[i] = len(label)\n", "\n", " # Output arrays\n", " outputs = {'ctc': np.zeros([self.minibatch_size])}\n", " inputs = {'the_input': X_data, \n", " 'the_labels': labels, \n", " 'input_length': input_length, \n", " 'label_length': label_length \n", " }\n", " return (inputs, outputs)\n", "\n", " def shuffle_dataset_by_partition(self, partition):\n", " # More shuffling\n", " if partition == 'train':\n", " self.train_audio_paths, self.train_durations, self.train_texts = shuffle_dataset(\n", " self.train_audio_paths, self.train_durations, self.train_texts)\n", " elif partition == 'valid':\n", " self.valid_audio_paths, self.valid_durations, self.valid_texts = shuffle_dataset(\n", " self.valid_audio_paths, self.valid_durations, self.valid_texts)\n", " else:\n", " raise Exception(\"Invalid partition. \"\n", " \"Must be train/val\")\n", "\n", " def sort_dataset_by_duration(self, partition):\n", " # Extra shuffling\n", " if partition == 'train':\n", " self.train_audio_paths, self.train_durations, self.train_texts = sort_dataset(\n", " self.train_audio_paths, self.train_durations, self.train_texts)\n", " elif partition == 'valid':\n", " self.valid_audio_paths, self.valid_durations, self.valid_texts = sort_dataset(\n", " self.valid_audio_paths, self.valid_durations, self.valid_texts)\n", " else:\n", " raise Exception(\"Invalid partition. \"\n", " \"Must be train/val\")\n", "\n", " def next_train(self):\n", " # Get a batch of training data\n", " while True:\n", " ret = self.get_batch('train')\n", " self.cur_train_index += self.minibatch_size\n", " if self.cur_train_index >= len(self.train_texts) - self.minibatch_size:\n", " self.cur_train_index = 0\n", " self.shuffle_dataset_by_partition('train')\n", " yield ret \n", "\n", " def next_valid(self):\n", " # Get a batch of validation data\n", " while True:\n", " ret = self.get_batch('valid')\n", " self.cur_valid_index += self.minibatch_size\n", " if self.cur_valid_index >= len(self.valid_texts) - self.minibatch_size:\n", " self.cur_valid_index = 0\n", " self.shuffle_dataset_by_partition('valid')\n", " yield ret\n", "\n", " def next_test(self):\n", " # Get a batch of testing data\n", " while True:\n", " ret = self.get_batch('test')\n", " self.cur_test_index += self.minibatch_size\n", " if self.cur_test_index >= len(self.test_texts) - self.minibatch_size:\n", " self.cur_test_index = 0\n", " yield ret\n", " \n", " # Load datasets\n", " def load_train_data(self, desc_file='train_corpus.json'):\n", " self.load_metadata_from_desc_file(desc_file, 'train')\n", " self.fit_train()\n", " if self.sort_by_duration:\n", " self.sort_dataset_by_duration('train')\n", " \n", "\n", " def load_validation_data(self, desc_file='valid_corpus.json'):\n", " self.load_metadata_from_desc_file(desc_file, 'validation')\n", " if self.sort_by_duration:\n", " self.sort_dataset_by_duration('valid')\n", "\n", " def load_test_data(self, desc_file='test_corpus.json'):\n", " self.load_metadata_from_desc_file(desc_file, 'test')\n", " if self.sort_by_duration:\n", " self.sort_dataset_by_duration('test')\n", " \n", " def load_metadata_from_desc_file(self, desc_file, partition):\n", " # Get metadata from json corpus\n", " audio_paths, durations, texts = [], [], []\n", " with open(desc_file) as json_line_file:\n", " for line_num, json_line in enumerate(json_line_file):\n", " try:\n", " spec = json.loads(json_line)\n", " if float(spec['duration']) > self.max_duration:\n", " continue\n", " audio_paths.append(spec['key'])\n", " durations.append(float(spec['duration']))\n", " texts.append(spec['text'])\n", " except Exception as e:\n", " print('Error reading line #{}: {}'\n", " .format(line_num, json_line))\n", " if partition == 'train':\n", " self.train_audio_paths = audio_paths\n", " self.train_durations = durations\n", " self.train_texts = texts\n", " elif partition == 'validation':\n", " self.valid_audio_paths = audio_paths\n", " self.valid_durations = durations\n", " self.valid_texts = texts\n", " elif partition == 'test':\n", " self.test_audio_paths = audio_paths\n", " self.test_durations = durations\n", " self.test_texts = texts\n", " else:\n", " raise Exception(\"Invalid partition. \"\n", " \"Must be train/validation/test\")\n", " \n", " def fit_train(self, k_samples=100):\n", " # Estimate descriptive stats for training set based on sample of 100 instances\n", " k_samples = min(k_samples, len(self.train_audio_paths))\n", " samples = self.rng.sample(self.train_audio_paths, k_samples)\n", " feats = [self.featurize(s) for s in samples]\n", " feats = np.vstack(feats)\n", " self.feats_mean = np.mean(feats, axis=0)\n", " self.feats_std = np.std(feats, axis=0)\n", " \n", " def featurize(self, audio_clip):\n", " # Create features from data, either spectrogram or mfcc\n", " if self.spectrogram:\n", " return spectrogram_from_file(\n", " audio_clip, step=self.step, window=self.window,\n", " max_freq=self.max_freq)\n", " else:\n", " (rate, sig) = wav.read(audio_clip)\n", " return mfcc(sig, rate, numcep=self.mfcc_dim)\n", "\n", " def normalize(self, feature, eps=1e-14):\n", " # Scale the data to improve neural network performance and reduce the size of the gradients\n", " return (feature - self.feats_mean) / (self.feats_std + eps)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "## Acoustic Feature Extraction/Engineering for Speech Recognition\n", "\n", "There are 3 primary methods for extracting features for speech recognition. This includes using raw audio forms, spectrograms, and mfcc's. For this project, I will be creating a character level sequencing model. This allows me to train a model on a data set with a limited vocabulary that can generalize to more unique/rare words better. The downsides are that these models are more computationally expensive, more difficult to interpret/understand, and they are more susceptible to the problems of vanishing or exploding gradients as the sequences can be quite long.\n", "\n", "##### The primary dataset used will not need much cleaning as it is taken from audiobooks that have been preprocessed for background noises. This will, of course, lead to reduced performance in distracting environments." ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [], "source": [ "# Defining 3 different ways of converting audio files to spectrograms\n", "\n", "def spectrogram(samples, fft_length=256, sample_rate=2, hop_length=128):\n", "# Create a spectrogram from audio signals\n", " assert not np.iscomplexobj(samples), \"You shall not pass in complex numbers\"\n", " window = np.hanning(fft_length)[:, None]\n", " window_norm = np.sum(window**2) \n", " scale = window_norm * sample_rate\n", " trunc = (len(samples) - fft_length) % hop_length\n", " x = samples[:len(samples) - trunc]\n", " # Reshape to include the overlap\n", " nshape = (fft_length, (len(x) - fft_length) // hop_length + 1)\n", " nstrides = (x.strides[0], x.strides[0] * hop_length)\n", " x = as_strided(x, shape=nshape, strides=nstrides)\n", " # Window stride sanity check\n", " assert np.all(x[:, 1] == samples[hop_length:(hop_length + fft_length)])\n", " # Broadcast window, and then compute fft over columns and square mod\n", " x = np.fft.rfft(x * window, axis=0)\n", " x = np.absolute(x)**2\n", " # Scale 2.0 for everything except dc and fft_length/2\n", " x[1:-1, :] *= (2.0 / scale)\n", " x[(0, -1), :] /= scale\n", " freqs = float(sample_rate) / fft_length * np.arange(x.shape[0])\n", " return x, freqs\n", "\n", "def spectrogram_from_file(filename, step=10, window=20, max_freq=None, eps=1e-14):\n", "# Calculate log(linear spectrogram) from FFT energy\n", " with soundfile.SoundFile(filename) as sound_file:\n", " audio = sound_file.read(dtype='float32')\n", " sample_rate = sound_file.samplerate\n", " if audio.ndim >= 2:\n", " audio = np.mean(audio, 1)\n", " if max_freq is None:\n", " max_freq = sample_rate / 2\n", " if max_freq > sample_rate / 2:\n", " raise ValueError(\"max_freq can not be > than 0.5 of \"\n", " \" sample rate\")\n", " if step > window:\n", " raise ValueError(\"step size can not be > than window size\")\n", " hop_length = int(0.001 * step * sample_rate)\n", " fft_length = int(0.001 * window * sample_rate)\n", " pxx, freqs = spectrogram(\n", " audio, fft_length=fft_length, sample_rate=sample_rate,\n", " hop_length=hop_length)\n", " ind = np.where(freqs <= max_freq)[0][-1] + 1\n", " return np.transpose(np.log(pxx[:ind, :] + eps))\n", "\n", "def log_spectrogram_feature(samples, sample_rate, window_size=20, step_size=10, eps=1e-14):\n", " nperseg = int(round(window_size * sample_rate / 1e3))\n", " noverlap = int(round(step_size * sample_rate / 1e3))\n", " freqs, times, spec = signal.spectrogram(samples,\n", " fs=sample_rate,\n", " window='hann',\n", " nperseg=nperseg,\n", " noverlap=noverlap,\n", " detrend=False)\n", " freqs = (freqs*2)\n", " return freqs, times, np.log(spec.T.astype(np.float64) + eps)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "## Visualizing The Data\n", "\n", "\n", "- [Raw Audio](#raw)\n", "- [Spectrograms](#spectograms)\n", "- [Mel-Frequency Cepstral Coefficients](#mfcc)" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [], "source": [ "def vis_train_features(index):\n", "# Function for visualizing a single audio file based on index chosen\n", " # Get spectrogram\n", " audio_gen = AudioGenerator(spectrogram=True)\n", " audio_gen.load_train_data()\n", " vis_audio_path = audio_gen.train_audio_paths[index]\n", " vis_spectrogram_feature = audio_gen.normalize(audio_gen.featurize(vis_audio_path))\n", " # Get mfcc\n", " audio_gen = AudioGenerator(spectrogram=False)\n", " audio_gen.load_train_data()\n", " vis_mfcc_feature = audio_gen.normalize(audio_gen.featurize(vis_audio_path))\n", " # Obtain text label\n", " vis_text = audio_gen.train_texts[index]\n", " # Obtain raw audio\n", " sample_rate, samples = wav.read(vis_audio_path)\n", " # Print total number of training examples\n", " print('There are %d total training examples.' % len(audio_gen.train_audio_paths))\n", " # Return labels for plotting\n", " return vis_text, vis_mfcc_feature, vis_spectrogram_feature, vis_audio_path, sample_rate, samples" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "There are 64220 total training examples.\n" ] } ], "source": [ "# Creating visualisations for audio file at index number 2012\n", "vis_text, vis_mfcc_feature, vis_spectrogram_feature, vis_audio_path, sample_rate, samples, = vis_train_features(index=2012)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "## Raw Audio\n", "\n", "This method uses the raw wave forms of the audio files and is a 1D vector of the amplitude where X = [x1, x2, x3...]\n", "\n", "This is used by the [Pannous Sequence to Sequence](https://github.com/pannous/tensorflow-speech-recognition) models built in Caffe and TensorFlow." ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [], "source": [ "def plot_raw_audio(sample_rate, samples):\n", " # Plot the raw audio signal\n", " time = np.arange(0, float(samples.shape[0]), 1) / sample_rate\n", " fig = plt.figure(figsize=(12,5))\n", " ax = fig.add_subplot(111)\n", " ax.plot(time, samples, linewidth=1, alpha=0.7, color='#76b900')\n", " plt.title('Raw Audio Signal')\n", " plt.xlabel('Time')\n", " plt.ylabel('Amplitude')\n", " plt.show()" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "data": { "text/markdown": [ "**Audio File Transcription** : in front of the table benches arranged in zigzag form like the circumvallations of a retrenchment formed a succession of bastions and curtains" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "\n", " \n", " " ], "text/plain": [ "" ] }, "execution_count": 11, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Plot the raw audio file\n", "plot_raw_audio(sample_rate, samples)\n", "# Print the transcript corresponding to the audio file\n", "display(Markdown('**Audio File Transcription** : ' + str(vis_text)))\n", "# Play the raw audio file\n", "Audio(vis_audio_path)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "## Spectrograms\n", "\n", "This is what we will use by default for this project. A spectrogram transforms the raw audio wave forms into a 2D tensor (using the Fourier transform) where the first dimension corresponds to time (the horizontal axis), and the second dimension corresponds to frequency (the vertical axis). We lose a little bit of information in this conversion process as we take the log of the power of FFT. This can be written as log |FFT(X)|^2. This gives us 161 features, so each feature corresponds to something between 99-100 Hz. The full transformation process is documented [here](resources/spectrograms.pdf).\n", "\n", "Spectrograms are used in [Baidu's Deep Speech](https://github.com/baidu-research/ba-dls-deepspeech) system." ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [], "source": [ "def plot_spectrogram_feature(vis_spectrogram_feature):\n", " # Plot a normalized spectrogram\n", " fig = plt.figure(figsize=(12,5))\n", " ax1 = fig.add_subplot(111)\n", " im = ax1.imshow(vis_spectrogram_feature.T, cmap=plt.cm.viridis, aspect='auto', origin='lower')\n", " plt.title('Normalized Log Spectrogram')\n", " plt.ylabel('Frequency')\n", " plt.xlabel('Time (s)')\n", " divider = make_axes_locatable(ax1)\n", " cax = divider.append_axes(\"right\", size=\"5%\", pad=0.05)\n", " plt.colorbar(im, cax=cax)\n", " plt.show()" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "data": { "text/markdown": [ "**Shape of the Spectrogram** : (904, 161)" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Plot the spectrogram for the selected file\n", "plot_spectrogram_feature(vis_spectrogram_feature)\n", "# Print shape of the spectrogram for the selected file\n", "display(Markdown('**Shape of the Spectrogram** : ' + str(vis_spectrogram_feature.shape)))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "If we have 161 features for each frame, and frequencies are between 0 and 16000, then each feature corresponds to around 100 Hz. Humans have a resolution of around 3.6 Hz, so our hearing is much more precise than what this transformation allows. This graph looks a little noisy so let's look at it with a finer grain of detail:" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [], "source": [ "freqs, times, log_spectrogram = log_spectrogram_feature(samples, sample_rate)\n", "\n", "mean = np.mean(log_spectrogram, axis=0)\n", "std = np.std(log_spectrogram, axis=0)\n", "log_spectrogram = (log_spectrogram - mean) / std\n", "\n", "def plot_log_spectrogram_feature(freqs, times, log_spectrogram):\n", " fig = plt.figure(figsize=(12,5))\n", " ax2 = fig.add_subplot(111)\n", " ax2.imshow(log_spectrogram.T, aspect='auto', origin='lower', cmap=plt.cm.viridis, \n", " extent=[times.min(), times.max(), freqs.min(), freqs.max()])\n", " ax2.set_yticks(freqs[::20])\n", " ax2.set_xticks(times[::20])\n", " ax2.set_title('Normalized Log Spectrogram')\n", " ax2.set_ylabel('Frequency')\n", " ax2.set_xlabel('Time (s)')" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "plot_log_spectrogram_feature(freqs, times, log_spectrogram)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Now, let's take a look at it in 3D, where we add the (log) amplitude as a 3rd dimension:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "data = [go.Surface(z=log_spectrogram.T, colorscale='Viridis')]\n", "layout = go.Layout(\n", "title='3D Spectrogram',\n", "autosize=True,\n", "margin=dict(l=50, r=50, b=50, t=50))\n", "fig = go.Figure(data=data, layout=layout)\n", "py.iplot(fig)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### And as a contour map." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "data = [go.Contour(z=log_spectrogram.T, colorscale='Viridis')]\n", "layout = go.Layout(\n", "title='Contour Graph',\n", "autosize=True)\n", "fig = go.Figure(data=data, layout=layout)\n", "py.iplot(fig)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "## Mel-Frequency Cepstral Coefficients\n", "\n", "Like the spectrogram, this turns the audio wave form into a 2D array. This works by mapping the powers of the Fourier transform of the signal, and then taking the discrete cosine transform of the logged mel powers. This produces a 2D array with reduced dimensions when compared to spectrograms, effectively allowing for compression of the spectrogram and speeding up training as we are left with 13 features. The full process for deriving MFCC's from audio is outlined [here](resources/mfccs.pdf).\n", "\n", "This is used in Mozilla's implementation of [Deep Speech](https://github.com/mozilla/DeepSpeech) in TensorFlow." ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [], "source": [ "def plot_mfcc_feature(vis_mfcc_feature):\n", " # Plot a normalized MFCC feature\n", " fig = plt.figure(figsize=(12,5))\n", " ax = fig.add_subplot(111)\n", " im = ax.imshow(vis_mfcc_feature, cmap=plt.cm.viridis, aspect='auto')\n", " plt.title('Normalized MFCC')\n", " plt.ylabel('Time')\n", " plt.xlabel('MFCC Coefficient')\n", " divider = make_axes_locatable(ax)\n", " cax = divider.append_axes(\"right\", size=\"5%\", pad=0.05)\n", " plt.colorbar(im, cax=cax)\n", " ax.set_xticks(np.arange(0, 13, 2), minor=False);\n", " plt.show()" ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "data": { "text/markdown": [ "**Shape of the MFCC** : (904, 13)" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Plot the MFCC of the selected file\n", "plot_mfcc_feature(vis_mfcc_feature)\n", "# Print the shape of the MFCC of the selected file\n", "display(Markdown('**Shape of the MFCC** : ' + str(vis_mfcc_feature.shape)))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "## Deep Neural Networks for Acoustic Modeling\n", "\n", "- [RNN](#rnn)\n", "- [RNN + TimeDistributed Dense](#rnntd)\n", "- [CNN + RNN + TimeDistributed Dense](#cnnrnn)\n", "- [Deeper RNN + TimeDistributed Dense](#deeprnn)\n", "- [Bidirectional RNN + TimeDistributed Dense](#bidirectional)\n", "- [CNN + Deeper Bidirectional RNN + TimeDistributed Dense](#cnndeepbi)\n", "- [Advanced Modeling Techniques](#modeling)\n", " - [Dropout](#dropout)\n", " - [Dilated Convolutions](#dilated)\n", "- [Aggregate Models](#aggregate)\n", " - [Deep Aggregate Model](#deepagg)\n", "- [Attention](#attention)\n", " - [Final Model](#final)\n", "\n", "The two most common tools for automatic speech recognition are Hidden Markov Models (HMM's), and Deep Neural Networks. For this project, the architecture chosen is a (Recurrent) Deep Neural Network (RNN) as it is easy to implement, and scales well. Though the most effective and sophisticated models implement \"hybrid\" systems or DNN-HMM, this is beyond the scope of this project. While HMM's using weighted finite state transducers are still considered the most powerful speech recognition tools, they were ignored for this program due to their complexity and increased computing requirements. HMM's also require the development of an extensive vocabulary of phonemes and graphemes that could not be produced under the time constraints of this project.\n", "\n", "Recurrent neurons are similar to feedforward neurons, except they also have connections pointing backward. At each step in time, each neuron recieves an input as well as its own output form the previous time step. Each neuron has two sets of weights, one for the input and one for the output at the last time step. Each layer takes vectors as inputs and outputs some vector. This model works by calculating forword propogation through each time step, t, and then back propagation through each time step. At each time step, the speaker is assumed to have spoken 1 of 29 possible characters (26 letters, 1 space character, 1 apostrophe, and 1 blank/empty character used to pad short files since inputs will have varying length). The output of this model at each time step will be a list of probabilitites for each possible character.\n", "\n", "The RNN is comprised of a combined acoustic model and language model. The acoustic model scores sequences of acoustic model labels over a time frame and the language model scores sequences of characters. A decoding graph then maps valid acoustic label sequences to the corresponding character sequences. Speech recognition is a path search algorithm through the decoding graph, where the score of the path is the sum of the score given to it by the decoding graph, and the score given to it by the acoustic model. So, to put it simply, speech recognition is the process of finding the character sequence that maximizes both the language and acoustic model scores.\n", "\n", "In this notebook, I have created several end-to-end RNN's for ASR. I have addressed the common issues with RNN's; exploding gradients, and vanishing gradients through gradient clipping, and the use of GRU, and LSTM cells respectively. I have also employed batch normalization and recurrent dropout.\n", "\n", "For more information on the use of deep learning in speech recognition, read [George Dahl's paper](resources/deeplearning.pdf)." ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [], "source": [ "# Custom CTC loss function (discussed below)\n", "def ctc_lambda_func(args):\n", " y_pred, labels, input_length, label_length = args\n", " return K.ctc_batch_cost(labels, y_pred, input_length, label_length)\n", "\n", "def add_ctc_loss(input_to_softmax):\n", " the_labels = Input(name='the_labels', shape=(None,), dtype='float32')\n", " input_lengths = Input(name='input_length', shape=(1,), dtype='int64')\n", " label_lengths = Input(name='label_length', shape=(1,), dtype='int64')\n", " output_lengths = Lambda(input_to_softmax.output_length)(input_lengths)\n", " # CTC loss is implemented in a lambda layer\n", " loss_out = Lambda(ctc_lambda_func, output_shape=(1,), name='ctc')(\n", " [input_to_softmax.output, the_labels, output_lengths, label_lengths])\n", " model = Model(\n", " inputs=[input_to_softmax.input, the_labels, input_lengths, label_lengths], \n", " outputs=loss_out)\n", " return model\n", "\n", "# Function for modifying CNN layers for sequence problems \n", "def cnn_output_length(input_length, filter_size, border_mode, stride,\n", " dilation=1):\n", "# Compute the length of cnn output seq after 1D convolution across time\n", " if input_length is None:\n", " return None\n", " assert border_mode in {'same', 'valid', 'causal'}\n", " dilated_filter_size = filter_size + (filter_size - 1) * (dilation - 1)\n", " if border_mode == 'same':\n", " output_length = input_length\n", " elif border_mode == 'valid':\n", " output_length = input_length - dilated_filter_size + 1\n", " elif border_mode == 'causal':\n", " output_length = input_length\n", " return (output_length + stride - 1) // stride" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Connectionist Temporal Classification\n", "\n", "The loss function I am using is a custom implementation of Connectionist Temporal Classification (CTC), which is a special case of sequential objective functions that addresses some of the modeling burden in cross-entropy that forces the model to link every frame of input data to a label. CTC's label set includes a \"blank\" symbol in its alphabet so if a frame of data doesn’t contain any utterance, the CTC system can output \"blank\" indicating that there isn't enough information to classify an output. This also has the added benefits of allowing us to have inputs/outputs of varying length as short files can be padded with the \"blank\" character and allowing us to model words using a character level classification system. This function only observes the sequence of labels along a path, ignoring the alignment of the labels to the acoustic data.\n", "\n", "More information on CTC can be found in Alex Grave's [paper](resources/ctc.pdf)." ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [], "source": [ "def train_model(input_to_softmax, \n", " pickle_path,\n", " save_model_path,\n", " train_json='train_corpus.json',\n", " valid_json='valid_corpus.json',\n", " minibatch_size=16, # You will want to change this depending on the GPU you are training on\n", " spectrogram=True,\n", " mfcc_dim=13,\n", " optimizer=Adam(lr=0.0001, beta_1=0.9, beta_2=0.999, epsilon=None, decay=0.0, amsgrad=False, clipnorm=1, clipvalue=.5),\n", " epochs=30, # You will want to change this depending on the model you are training and data you are using\n", " verbose=1,\n", " sort_by_duration=False,\n", " max_duration=10.0):\n", " \n", " # Obtain batches of data\n", " audio_gen = AudioGenerator(minibatch_size=minibatch_size, \n", " spectrogram=spectrogram, mfcc_dim=mfcc_dim, max_duration=max_duration,\n", " sort_by_duration=sort_by_duration)\n", " # Load the datasets\n", " audio_gen.load_train_data(train_json)\n", " audio_gen.load_validation_data(valid_json) \n", " # Calculate steps per epoch\n", " num_train_examples=len(audio_gen.train_audio_paths)\n", " steps_per_epoch = num_train_examples//minibatch_size\n", " # Calculate validation steps\n", " num_valid_samples = len(audio_gen.valid_audio_paths) \n", " validation_steps = num_valid_samples//minibatch_size \n", " # Add custom CTC loss function to the nn\n", " model = add_ctc_loss(input_to_softmax)\n", " # Dummy lambda function for loss since CTC loss is implemented above\n", " model.compile(loss={'ctc': lambda y_true, y_pred: y_pred}, optimizer=optimizer)\n", " # Make initial results/ directory for saving model pickles\n", " if not os.path.exists('results'):\n", " os.makedirs('results')\n", " # Add callbacks\n", " checkpointer = ModelCheckpoint(filepath='results/'+save_model_path, verbose=0)\n", " terminator = callbacks.TerminateOnNaN()\n", " time_machiner = callbacks.History()\n", " logger = callbacks.CSVLogger('training.log')\n", " stopper = callbacks.EarlyStopping(monitor='val_loss', patience=2, verbose=1, mode='auto')\n", " reducer = callbacks.ReduceLROnPlateau(monitor='val_loss', factor=0.1, patience=10, verbose=0, mode='auto', min_delta=0.0001, cooldown=0, min_lr=0)\n", " tensor_boarder = callbacks.TensorBoard(log_dir='./logs', batch_size=16,\n", " write_graph=True, write_grads=True, write_images=True,)\n", " # Fit/train model\n", " hist = model.fit_generator(generator=audio_gen.next_train(), steps_per_epoch=steps_per_epoch,\n", " epochs=epochs, validation_data=audio_gen.next_valid(), validation_steps=validation_steps,\n", " callbacks=[checkpointer, terminator, logger, time_machiner, tensor_boarder, stopper, reducer], verbose=verbose)\n", " # Save model loss\n", " with open('results/'+pickle_path, 'wb') as f:\n", " pickle.dump(hist.history, f)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Adam Optimizer\n", "The Adam optimizer was chosen as it has momentum and has been shown to work well in speech recognition. \n", "\n", "#### Exporting the model for inference\n", "\n", "The preferred method of exporting Keras models for inference is to use the built-in saver/checkpointer (and this is what is used for the inference engine). This uses H5PY, which converts the data to the HDF5 binary data format, letting you store huge amounts of numerical data, and easily manipulate that data from NumPy. The models were set to save checkpoints in a .h5 file after each epoch and at the end of training. These are stored in the /results/ directory and will be used by the inference engine in the flask web app." ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [], "source": [ "# Creating a TensorFlow session\n", "from keras.backend.tensorflow_backend import set_session\n", "config = tf.ConfigProto()\n", "config.gpu_options.per_process_gpu_memory_fraction = 1.0\n", "set_session(tf.Session(config=config))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Training\n", "This notebook walks through the development of a series of models that successively get more complex. We will train all of the developmental models (model 0-7) for 20 epochs on a 100 hour subset of the data, and then test an aggregate model (model 8 and 9) by training for 30 epochs using both spectrograms and MFCC's on a 460 hour subset before training the final model architecture (model 10) for 30 epochs on the full 960 hour training set.\n", "\n", "\n", "## RNN\n", "\n", "This model explores a simple RNN with 1 layer of Gated Recurrent Units, a simplified type of Long-Short Term Memory Recurrent Neuron with fewer parameters than typical LSTM's. These work via a memory update gate and provide most of the performance of traditional LSTM's at a fraction of the computing costs.\n", "\n", "For more information on the use of reccurent neural networks in speech recognition, read [Alex Graves' paper](resources/rnn.pdf).\n", "\n", "To learn more about GRU's, you can check out [this paper](resources/gru.pdf)." ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [], "source": [ "def regular_rnn_model(input_dim, output_dim=29):\n", " # Input\n", " input_data = Input(name='the_input', shape=(None, input_dim))\n", " # Recurrent layer\n", " simp_rnn = GRU(output_dim, return_sequences=True, \n", " implementation=2, name='rnn')(input_data)\n", " # Softmax Activation Layer\n", " y_pred = Activation('softmax', name='softmax')(simp_rnn)\n", " # Specifying the model\n", " model = Model(inputs=input_data, outputs=y_pred)\n", " model.output_length = lambda x: x\n", " print(model.summary())\n", " return model" ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "_________________________________________________________________\n", "Layer (type) Output Shape Param # \n", "=================================================================\n", "the_input (InputLayer) (None, None, 161) 0 \n", "_________________________________________________________________\n", "rnn (GRU) (None, None, 29) 16617 \n", "_________________________________________________________________\n", "softmax (Activation) (None, None, 29) 0 \n", "=================================================================\n", "Total params: 16,617\n", "Trainable params: 16,617\n", "Non-trainable params: 0\n", "_________________________________________________________________\n", "None\n" ] } ], "source": [ "model_0 = regular_rnn_model(input_dim=161) # 161 for Spectrogram/13 for MFCC" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "train_model(input_to_softmax=model_0, \n", " pickle_path='model_0.pickle', \n", " save_model_path='model_0.h5',\n", " spectrogram=True,\n", " ) # True for Spectrogram/False for MFCC" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "This model came a long way. Its performance is alright, but let's see if we can improve it with a more complex model.\n", "\n", "\n", "## RNN + TimeDistributed Dense\n", "\n", "This model explores the addition of layers of normal Dense neurons to every temporal slice of an input. This model also uses batch normalization, which normalizes the activations of the layers with a mean close to 0 and standard deviation close to 1.\n", "\n", "This model uses LSTM's. These cells include forget and output gates, which allow more control over the cell's memory by allowing separate control of what is forgotten and what is passed through to the next hidden layer of cells. This will also make it easier to implement 'peepholes' later, which allow the cell to look at both the previous output state and hidden state when making this determination.\n", "\n", "More information on the use of LSTM's in speech recognition can be found in [this paper](resources/lstm.pdf) from Google and for more info on TimeDistributed Layers, check out the [Keras Documentation](https://keras.io/layers/wrappers/)." ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [], "source": [ "def rnn_tdd_model(input_dim, units, activation, output_dim=29):\n", " # Input\n", " input_data = Input(name='the_input', shape=(None, input_dim))\n", " # Recurrent layer\n", " simp_rnn = LSTM(units, activation=activation,\n", " return_sequences=True, implementation=2, name='rnn')(input_data)\n", " bn_rnn = BatchNormalization()(simp_rnn)\n", " # TimeDistributed Dense layer\n", " time_dense = TimeDistributed(Dense(output_dim))(bn_rnn)\n", " # Softmax activation layer\n", " y_pred = Activation('softmax', name='softmax')(time_dense)\n", " # Specifying the model\n", " model = Model(inputs=input_data, outputs=y_pred)\n", " model.output_length = lambda x: x\n", " print(model.summary())\n", " return model" ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "_________________________________________________________________\n", "Layer (type) Output Shape Param # \n", "=================================================================\n", "the_input (InputLayer) (None, None, 161) 0 \n", "_________________________________________________________________\n", "rnn (LSTM) (None, None, 200) 289600 \n", "_________________________________________________________________\n", "batch_normalization_1 (Batch (None, None, 200) 800 \n", "_________________________________________________________________\n", "time_distributed_1 (TimeDist (None, None, 29) 5829 \n", "_________________________________________________________________\n", "softmax (Activation) (None, None, 29) 0 \n", "=================================================================\n", "Total params: 296,229\n", "Trainable params: 295,829\n", "Non-trainable params: 400\n", "_________________________________________________________________\n", "None\n" ] } ], "source": [ "model_1 = rnn_tdd_model(input_dim=161, # 161 for Spectrogram/13 for MFCC\n", " units=200,\n", " activation='relu')" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "train_model(input_to_softmax=model_1, \n", " pickle_path='model_1.pickle', \n", " save_model_path='model_1.h5',\n", " spectrogram=True) # True for Spectrogram/False for MFCC" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "This model did significantly better, so let's see if deepening the framework can improve our scores.\n", "\n", "\n", "## CNN + RNN + TimeDistributed Dense\n", "\n", "This model explores the addition of a Convolutional Neural Network to the RNN." ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [], "source": [ "def cnn_rnn_td_model(input_dim, filters, activation, kernel_size, conv_stride,\n", " conv_border_mode, units, output_dim=29):\n", " # Input\n", " input_data = Input(name='the_input', shape=(None, input_dim))\n", " # Convolutional layer\n", " conv_1d = Conv1D(filters, kernel_size, \n", " strides=conv_stride, \n", " padding=conv_border_mode,\n", " activation=activation,\n", " name='conv1d')(input_data)\n", " # Batch normalization\n", " bn_cnn = BatchNormalization(name='bn_conv1d')(conv_1d)\n", " # Recurrent layer\n", " simp_rnn = GRU(units, activation=activation,\n", " return_sequences=True, implementation=2, name='rnn')(bn_cnn)\n", " # Batch Normalization\n", " bn_rnn = BatchNormalization()(simp_rnn)\n", " # TimeDistributed Dense layer\n", " time_dense = TimeDistributed(Dense(output_dim))(bn_rnn)\n", " # Softmax activation layer\n", " y_pred = Activation('softmax', name='softmax')(time_dense)\n", " # Specifying the model\n", " model = Model(inputs=input_data, outputs=y_pred)\n", " model.output_length = lambda x: cnn_output_length(\n", " x, kernel_size, conv_border_mode, conv_stride)\n", " print(model.summary())\n", " return model" ] }, { "cell_type": "code", "execution_count": 26, "metadata": { "scrolled": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "_________________________________________________________________\n", "Layer (type) Output Shape Param # \n", "=================================================================\n", "the_input (InputLayer) (None, None, 161) 0 \n", "_________________________________________________________________\n", "conv1d (Conv1D) (None, None, 200) 354400 \n", "_________________________________________________________________\n", "bn_conv1d (BatchNormalizatio (None, None, 200) 800 \n", "_________________________________________________________________\n", "rnn (GRU) (None, None, 200) 240600 \n", "_________________________________________________________________\n", "batch_normalization_2 (Batch (None, None, 200) 800 \n", "_________________________________________________________________\n", "time_distributed_2 (TimeDist (None, None, 29) 5829 \n", "_________________________________________________________________\n", "softmax (Activation) (None, None, 29) 0 \n", "=================================================================\n", "Total params: 602,429\n", "Trainable params: 601,629\n", "Non-trainable params: 800\n", "_________________________________________________________________\n", "None\n" ] } ], "source": [ "model_2 = cnn_rnn_td_model(input_dim=161, # 161 for Spectrogram/13 for MFCC\n", " filters=200,\n", " kernel_size=11, \n", " conv_stride=2,\n", " conv_border_mode='valid',\n", " activation='relu',\n", " units=200)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "train_model(input_to_softmax=model_2, \n", " pickle_path='model_2.pickle', \n", " save_model_path='model_2.h5', \n", " spectrogram=True) # True for Spectrogram/False for MFCC" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Adding a convolution layer greatly improved our score, but what about adding another RNN layer?\n", "\n", "\n", "## Deeper RNN + TimeDistributed Dense\n", "\n", "This model explores deepening of the network with additional recurrent layers." ] }, { "cell_type": "code", "execution_count": 27, "metadata": {}, "outputs": [], "source": [ "def deep_rnn_tdd_model(input_dim, units, recur_layers, activation, output_dim=29):\n", " # Input\n", " input_data = Input(name='the_input', shape=(None, input_dim))\n", " # 1st Recurrent layer\n", " simp_rnn = GRU(units, activation=activation, \n", " return_sequences=True, implementation=2, name='rnn_0')(input_data)\n", " # Batch normalization \n", " bn_rnn = BatchNormalization()(simp_rnn)\n", " # Loop for additional layers\n", " for i in range(recur_layers - 1):\n", " name = 'rnn_' + str(i + 1)\n", " simp_rnn = GRU(units, activation=activation, \n", " return_sequences=True, implementation=2, name=name)(bn_rnn)\n", " bn_rnn = BatchNormalization()(simp_rnn)\n", " # TimeDistributed Dense layer\n", " time_dense = TimeDistributed(Dense(output_dim))(bn_rnn)\n", " # Softmax activation layer\n", " y_pred = Activation('softmax', name='softmax')(time_dense)\n", " # Specifying the model\n", " model = Model(inputs=input_data, outputs=y_pred)\n", " model.output_length = lambda x: x\n", " print(model.summary())\n", " return model" ] }, { "cell_type": "code", "execution_count": 28, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "_________________________________________________________________\n", "Layer (type) Output Shape Param # \n", "=================================================================\n", "the_input (InputLayer) (None, None, 161) 0 \n", "_________________________________________________________________\n", "rnn_0 (GRU) (None, None, 200) 217200 \n", "_________________________________________________________________\n", "batch_normalization_3 (Batch (None, None, 200) 800 \n", "_________________________________________________________________\n", "rnn_1 (GRU) (None, None, 200) 240600 \n", "_________________________________________________________________\n", "batch_normalization_4 (Batch (None, None, 200) 800 \n", "_________________________________________________________________\n", "time_distributed_3 (TimeDist (None, None, 29) 5829 \n", "_________________________________________________________________\n", "softmax (Activation) (None, None, 29) 0 \n", "=================================================================\n", "Total params: 465,229\n", "Trainable params: 464,429\n", "Non-trainable params: 800\n", "_________________________________________________________________\n", "None\n" ] } ], "source": [ "model_3 = deep_rnn_tdd_model(input_dim=161, units=200, recur_layers=2, activation='relu') # 161 for Spectrogram/13 for MFCC" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "train_model(input_to_softmax=model_3, \n", " pickle_path='model_3.pickle', \n", " save_model_path='model_3.h5', \n", " spectrogram=True) # True for Spectrogram/False for MFCC" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "This one did pretty well, but didn't perform quite as well as the convolution layer.\n", "\n", "\n", "## Bidirectional RNN + TimeDistributed Dense\n", "\n", "This model explores connecting two hidden layers of opposite directions to the same output, making their future input information reachable from the current state. To put it simply, this creates two layers of neurons; 1 that goes through the sequence forward in time and 1 that goes through it backward through time. This allows the output layer to get information from past and future states meaning that it will have knowledge of the letters located before and after the current utterance. This can lead to great improvements in performance but comes at a cost of increased latency.\n", "\n", "Inspiration for bidirectional layers came from [this paper](resources/bidirectional.pdf).\n", "\n", "> Note: The original implementation of this model ran into the problem of exploding gradients (which can be recognized by your loss being nan) and clipnorm=1 was added to the Adam optimizer above to clip the gradients and address this issue. This [blog post](https://machinelearningmastery.com/exploding-gradients-in-neural-networks/) gives a great overview of the various approaches for dealing with exploding gradients." ] }, { "cell_type": "code", "execution_count": 29, "metadata": {}, "outputs": [], "source": [ "def brnn_tdd_model(input_dim, units, activation, output_dim=29):\n", " # Input\n", " input_data = Input(name='the_input', shape=(None, input_dim))\n", " # Bidirectional recurrent layer\n", " brnn = Bidirectional(LSTM(units, activation=activation, \n", " return_sequences=True, implementation=2, name='brnn'))(input_data)\n", " # TimeDistributed Dense layer\n", " time_dense = TimeDistributed(Dense(output_dim))(brnn)\n", " # Softmax activation layer\n", " y_pred = Activation('softmax', name='softmax')(time_dense)\n", " # Specifying the model\n", " model = Model(inputs=input_data, outputs=y_pred)\n", " model.output_length = lambda x: x\n", " print(model.summary())\n", " return model" ] }, { "cell_type": "code", "execution_count": 30, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "_________________________________________________________________\n", "Layer (type) Output Shape Param # \n", "=================================================================\n", "the_input (InputLayer) (None, None, 161) 0 \n", "_________________________________________________________________\n", "bidirectional_1 (Bidirection (None, None, 400) 579200 \n", "_________________________________________________________________\n", "time_distributed_4 (TimeDist (None, None, 29) 11629 \n", "_________________________________________________________________\n", "softmax (Activation) (None, None, 29) 0 \n", "=================================================================\n", "Total params: 590,829\n", "Trainable params: 590,829\n", "Non-trainable params: 0\n", "_________________________________________________________________\n", "None\n" ] } ], "source": [ "model_4 = brnn_tdd_model(input_dim=161, units=200, activation='relu') # 161 for Spectrogram/13 for MFCC" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "train_model(input_to_softmax=model_4, \n", " pickle_path='model_4.pickle', \n", " save_model_path='model_4.h5', \n", " spectrogram=True) # True for Spectrogram/False for MFCC" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "This also lead to some improvements in the model so let's see if we can combine these techniques for increased performance.\n", "\n", "\n", "## CNN + Deeper Bidirectional RNN + TimeDistributed Dense\n", "\n", "This model combines all of the ideas in the precedding models." ] }, { "cell_type": "code", "execution_count": 31, "metadata": {}, "outputs": [], "source": [ "def cnn_deep_brnn_tdd_model(input_dim, filters, activation, kernel_size, conv_stride,\n", " conv_border_mode, recur_layers, units, output_dim=29):\n", " # Input\n", " input_data = Input(name='the_input', shape=(None, input_dim))\n", " # Convolutional layer\n", " conv_1d = Conv1D(filters, kernel_size, \n", " strides=conv_stride, \n", " padding=conv_border_mode,\n", " activation=activation,\n", " name='conv1d')(input_data)\n", " # Batch normalization\n", " bn_cnn = BatchNormalization()(conv_1d)\n", " # Bidirectional recurrent layer\n", " brnn = Bidirectional(GRU(units, activation=activation, \n", " return_sequences=True, name='brnn'))(bn_cnn)\n", " # Batch normalization \n", " bn_rnn = BatchNormalization()(brnn)\n", " # Loop for additional layers\n", " for i in range(recur_layers - 1):\n", " name = 'brnn_' + str(i + 1)\n", " brnn = Bidirectional(GRU(units, activation=activation, \n", " return_sequences=True, implementation=2, name=name))(bn_rnn)\n", " bn_rnn = BatchNormalization()(brnn)\n", " # TimeDistributed Dense layer\n", " time_dense = TimeDistributed(Dense(output_dim))(bn_rnn)\n", " # Softmax activation layer\n", " y_pred = Activation('softmax', name='softmax')(time_dense)\n", " # Specifying the model\n", " model = Model(inputs=input_data, outputs=y_pred)\n", " model.output_length = lambda x: cnn_output_length(\n", " x, kernel_size, conv_border_mode, conv_stride)\n", " print(model.summary())\n", " return model" ] }, { "cell_type": "code", "execution_count": 32, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "_________________________________________________________________\n", "Layer (type) Output Shape Param # \n", "=================================================================\n", "the_input (InputLayer) (None, None, 161) 0 \n", "_________________________________________________________________\n", "conv1d (Conv1D) (None, None, 200) 354400 \n", "_________________________________________________________________\n", "batch_normalization_5 (Batch (None, None, 200) 800 \n", "_________________________________________________________________\n", "bidirectional_2 (Bidirection (None, None, 400) 481200 \n", "_________________________________________________________________\n", "batch_normalization_6 (Batch (None, None, 400) 1600 \n", "_________________________________________________________________\n", "bidirectional_3 (Bidirection (None, None, 400) 721200 \n", "_________________________________________________________________\n", "batch_normalization_7 (Batch (None, None, 400) 1600 \n", "_________________________________________________________________\n", "time_distributed_5 (TimeDist (None, None, 29) 11629 \n", "_________________________________________________________________\n", "softmax (Activation) (None, None, 29) 0 \n", "=================================================================\n", "Total params: 1,572,429\n", "Trainable params: 1,570,429\n", "Non-trainable params: 2,000\n", "_________________________________________________________________\n", "None\n" ] } ], "source": [ "model_5 = cnn_deep_brnn_tdd_model(input_dim=161, # 161 for Spectrogram/13 for MFCC\n", " filters=200,\n", " activation='relu',\n", " kernel_size=11, \n", " conv_stride=2,\n", " conv_border_mode='valid',\n", " recur_layers=2,\n", " units=200)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "train_model(input_to_softmax=model_5, \n", " pickle_path='model_5.pickle', \n", " save_model_path='model_5.h5', \n", " spectrogram=True) # True for Spectrogram/False for MFCC" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "This ASR program scored very well, so let's see if we can squeeze a little more out of our model using a few tricks.\n", "\n", "## Advanced Modeling Techniques\n", "\n", "\n", "### Dropout\n", "\n", "This model adds randomized dropout of inputs to the aggregate model to prevent the model from over fitting.\n", "\n", "> Note: The dropout rate is 1%. Any larger than this will lead to exploding gradients. Due to this, this idea won't be pursued any further but one proposed solution can be found in this [paper](resources/gradientsexplode.pdf) and an example of this in action can be found in this [paper](resources/microsoft2016.pdf)." ] }, { "cell_type": "code", "execution_count": 33, "metadata": {}, "outputs": [], "source": [ "def cnn_deep_brnn_dropout_model(input_dim, filters, activation, kernel_size, conv_stride,\n", " conv_border_mode, recur_layers, units, output_dim=29):\n", " # Input\n", " input_data = Input(name='the_input', shape=(None, input_dim))\n", " # Convolutional layer\n", " conv_1d = Conv1D(filters, kernel_size, \n", " strides=conv_stride, \n", " padding=conv_border_mode,\n", " activation=activation,\n", " name='conv1d')(input_data)\n", " # Batch normalization\n", " bn_cnn = BatchNormalization()(conv_1d)\n", " # Bidirectional recurrent layer\n", " brnn = Bidirectional(GRU(units, activation=activation, \n", " return_sequences=True, implementation=2, recurrent_dropout=0.01, name='brnn'))(bn_cnn)\n", " # Batch normalization \n", " bn_rnn = BatchNormalization()(brnn)\n", " # Loop for additional layers\n", " for i in range(recur_layers - 1):\n", " name = 'brnn_' + str(i + 1)\n", " brnn = Bidirectional(GRU(units, activation=activation, \n", " return_sequences=True, implementation=2, name=name))(bn_rnn)\n", " bn_rnn = BatchNormalization()(brnn)\n", " # TimeDistributed Dense layer\n", " time_dense = TimeDistributed(Dense(output_dim))(bn_rnn)\n", " # Softmax activation layer\n", " y_pred = Activation('softmax', name='softmax')(time_dense)\n", " # Specifying the model\n", " model = Model(inputs=input_data, outputs=y_pred)\n", " model.output_length = lambda x: cnn_output_length(\n", " x, kernel_size, conv_border_mode, conv_stride)\n", " print(model.summary())\n", " return model" ] }, { "cell_type": "code", "execution_count": 34, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "_________________________________________________________________\n", "Layer (type) Output Shape Param # \n", "=================================================================\n", "the_input (InputLayer) (None, None, 161) 0 \n", "_________________________________________________________________\n", "conv1d (Conv1D) (None, None, 200) 354400 \n", "_________________________________________________________________\n", "batch_normalization_8 (Batch (None, None, 200) 800 \n", "_________________________________________________________________\n", "bidirectional_4 (Bidirection (None, None, 400) 481200 \n", "_________________________________________________________________\n", "batch_normalization_9 (Batch (None, None, 400) 1600 \n", "_________________________________________________________________\n", "bidirectional_5 (Bidirection (None, None, 400) 721200 \n", "_________________________________________________________________\n", "batch_normalization_10 (Batc (None, None, 400) 1600 \n", "_________________________________________________________________\n", "time_distributed_6 (TimeDist (None, None, 29) 11629 \n", "_________________________________________________________________\n", "softmax (Activation) (None, None, 29) 0 \n", "=================================================================\n", "Total params: 1,572,429\n", "Trainable params: 1,570,429\n", "Non-trainable params: 2,000\n", "_________________________________________________________________\n", "None\n" ] } ], "source": [ "model_6 = cnn_deep_brnn_dropout_model(input_dim=161, # 161 for Spectrogram/13 for MFCC\n", " filters=200,\n", " activation='relu',\n", " kernel_size=11, \n", " conv_stride=2,\n", " conv_border_mode='valid',\n", " recur_layers=2,\n", " units=200)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "train_model(input_to_softmax=model_6, \n", " pickle_path='model_6.pickle', \n", " save_model_path='model_6.h5', \n", " spectrogram=True) # True for Spectrogram/False for MFCC" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Despite the small amount of instances dropped, this still lead to improved performance.\n", "\n", "\n", "### Dilated Convolutions\n", "\n", "This model adds dilated CNN's to the aggregate model. Dilation introduces gaps into the CNN's kernels, so that the receptive field must encircle areas rather than simply slide over the window in a systematic way. This means that the convolutional layer can pick up on the global context of what it is looking at while still only having as many weights/inputs as the standard form.\n", "\n", "Inspiration for this technique came from [IBM's Watson Team](resources/dilation.pdf)." ] }, { "cell_type": "code", "execution_count": 35, "metadata": {}, "outputs": [], "source": [ "def cnn_deep_brnn_dilated_model(input_dim, filters, activation, kernel_size, conv_stride,\n", " conv_border_mode, recur_layers, dilation_rate, units, conv_layers, output_dim=29):\n", " input_data = Input(name='the_input', shape=(None, input_dim))\n", " conv_1d = Conv1D(filters, kernel_size, \n", " strides=conv_stride, \n", " padding=conv_border_mode,\n", " activation=activation,\n", " name='conv1d')(input_data)\n", " # Batch normalization\n", " bn_cnn = BatchNormalization()(conv_1d)\n", " for i in range(conv_layers - 1):\n", " conv_1d = Conv1D(filters, kernel_size,\n", " padding='causal',\n", " activation='relu',\n", " dilation_rate=2**i,\n", " name=\"conv_1d_\"+str(i))(bn_cnn)\n", " bn_cnn = BatchNormalization()(conv_1d)\n", " # Bidirectional recurrent layer\n", " brnn = Bidirectional(GRU(units, activation=activation, \n", " return_sequences=True, implementation=2, name='brnn'))(bn_cnn)\n", " # Batch normalization \n", " bn_rnn = BatchNormalization()(brnn)\n", " # Loop for additional layers\n", " for i in range(recur_layers - 1):\n", " name = 'brnn_' + str(i + 1)\n", " brnn = Bidirectional(GRU(units, activation=activation, \n", " return_sequences=True, implementation=2, name=name))(bn_rnn)\n", " bn_rnn = BatchNormalization()(brnn)\n", " time_dense = TimeDistributed(Dense(output_dim))(bn_rnn)\n", " y_pred = Activation('softmax', name='softmax')(time_dense)\n", " model = Model(inputs=input_data, outputs=y_pred)\n", " model.output_length = lambda x: cnn_output_length(\n", " x, kernel_size, 'causal', 1)\n", " print(model.summary())\n", " return model" ] }, { "cell_type": "code", "execution_count": 36, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "_________________________________________________________________\n", "Layer (type) Output Shape Param # \n", "=================================================================\n", "the_input (InputLayer) (None, None, 161) 0 \n", "_________________________________________________________________\n", "conv1d (Conv1D) (None, None, 200) 354400 \n", "_________________________________________________________________\n", "batch_normalization_11 (Batc (None, None, 200) 800 \n", "_________________________________________________________________\n", "conv_1d_0 (Conv1D) (None, None, 200) 440200 \n", "_________________________________________________________________\n", "batch_normalization_12 (Batc (None, None, 200) 800 \n", "_________________________________________________________________\n", "bidirectional_6 (Bidirection (None, None, 400) 481200 \n", "_________________________________________________________________\n", "batch_normalization_13 (Batc (None, None, 400) 1600 \n", "_________________________________________________________________\n", "bidirectional_7 (Bidirection (None, None, 400) 721200 \n", "_________________________________________________________________\n", "batch_normalization_14 (Batc (None, None, 400) 1600 \n", "_________________________________________________________________\n", "time_distributed_7 (TimeDist (None, None, 29) 11629 \n", "_________________________________________________________________\n", "softmax (Activation) (None, None, 29) 0 \n", "=================================================================\n", "Total params: 2,013,429\n", "Trainable params: 2,011,029\n", "Non-trainable params: 2,400\n", "_________________________________________________________________\n", "None\n" ] } ], "source": [ "model_7 = cnn_deep_brnn_dilated_model(input_dim=161, # 161 for Spectrogram/13 for MFCC\n", " filters=200,\n", " activation='relu',\n", " kernel_size=11, \n", " conv_stride=1,\n", " conv_border_mode='causal',\n", " recur_layers=2,\n", " conv_layers=2,\n", " dilation_rate=2,\n", " units=200)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "train_model(input_to_softmax=model_7, \n", " pickle_path='model_7.pickle', \n", " save_model_path='model_7.h5', \n", " spectrogram=True) # True for Spectrogram/False for MFCC" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "This model also does pretty well (at the cost of increased training time) so let's see if we can combine all of these ideas into one very deep and very powerful speech recognition platform.\n", "\n", "\n", "## Aggregate Models\n", "\n", "The aggregate Keras model is a fine tuned implementation of model_5 (CNN + Deep BRNN + TDD). The model will consist of 1 convolutional layer, 2 GRU layers, and 1 Time Distributed Dense layer. The convolutional layer conducts feature/pattern extraction, while the RNN layers develop predictions on those features. This model won't make use of dropout or dilated convolutions as they both led to gradient explosions in tests. We have also increased the number of neurons in each layer. This model is trained for 30 epochs on a 460 hour subset of the data. This is the model deployed in the [heyjetson.com](https://heyjetson.com) project. \n", "\n", "Inspiration for the aggregate architecture came from Baidu's [Deep Speech 2](resources/deepspeech2.pdf) engine.\n", "\n", "#### Training with spectrograms" ] }, { "cell_type": "code", "execution_count": 37, "metadata": {}, "outputs": [], "source": [ "def agg_model(input_dim, filters, activation, kernel_size, conv_stride,\n", " conv_border_mode, recur_layers, units, output_dim=29):\n", " # Input\n", " input_data = Input(name='the_input', shape=(None, input_dim))\n", " # Convolutional layer\n", " conv_1d = Conv1D(filters, kernel_size, \n", " strides=conv_stride, \n", " padding=conv_border_mode,\n", " activation=activation,\n", " name='conv1d')(input_data)\n", " # Batch normalization\n", " bn_cnn = BatchNormalization()(conv_1d)\n", " # Bidirectional recurrent layer\n", " brnn = Bidirectional(GRU(units, activation=activation, \n", " return_sequences=True, name='brnn'))(bn_cnn)\n", " # Batch normalization \n", " bn_rnn = BatchNormalization()(brnn)\n", " # Loop for additional layers\n", " for i in range(recur_layers - 1):\n", " name = 'brnn_' + str(i + 1)\n", " brnn = Bidirectional(GRU(units, activation=activation, \n", " return_sequences=True, implementation=2, name=name))(bn_rnn)\n", " bn_rnn = BatchNormalization()(brnn)\n", " # TimeDistributed Dense layer\n", " time_dense = TimeDistributed(Dense(output_dim))(bn_rnn)\n", " # Softmax activation layer\n", " y_pred = Activation('softmax', name='softmax')(time_dense)\n", " # Specifying the model\n", " model = Model(inputs=input_data, outputs=y_pred)\n", " model.output_length = lambda x: cnn_output_length(\n", " x, kernel_size, conv_border_mode, conv_stride)\n", " print(model.summary())\n", " return model" ] }, { "cell_type": "code", "execution_count": 38, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "_________________________________________________________________\n", "Layer (type) Output Shape Param # \n", "=================================================================\n", "the_input (InputLayer) (None, None, 161) 0 \n", "_________________________________________________________________\n", "conv1d (Conv1D) (None, None, 256) 453632 \n", "_________________________________________________________________\n", "batch_normalization_15 (Batc (None, None, 256) 1024 \n", "_________________________________________________________________\n", "bidirectional_8 (Bidirection (None, None, 512) 787968 \n", "_________________________________________________________________\n", "batch_normalization_16 (Batc (None, None, 512) 2048 \n", "_________________________________________________________________\n", "bidirectional_9 (Bidirection (None, None, 512) 1181184 \n", "_________________________________________________________________\n", "batch_normalization_17 (Batc (None, None, 512) 2048 \n", "_________________________________________________________________\n", "time_distributed_8 (TimeDist (None, None, 29) 14877 \n", "_________________________________________________________________\n", "softmax (Activation) (None, None, 29) 0 \n", "=================================================================\n", "Total params: 2,442,781\n", "Trainable params: 2,440,221\n", "Non-trainable params: 2,560\n", "_________________________________________________________________\n", "None\n" ] } ], "source": [ "model_8 = agg_model(input_dim=161, # 161 for Spectrogram/13 for MFCC\n", " filters=256,\n", " activation='relu',\n", " kernel_size=11, \n", " conv_stride=2,\n", " conv_border_mode='valid',\n", " recur_layers=2,\n", " units=256)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "train_model(input_to_softmax=model_8, \n", " pickle_path='model_8.pickle', \n", " save_model_path='model_8.h5', \n", " spectrogram=True) # True for Spectrogram/False for MFCC" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Training with MFCC's\n", "Let's train this model using MFCC's just to see if there is a difference in performance:" ] }, { "cell_type": "code", "execution_count": 39, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "_________________________________________________________________\n", "Layer (type) Output Shape Param # \n", "=================================================================\n", "the_input (InputLayer) (None, None, 13) 0 \n", "_________________________________________________________________\n", "conv1d (Conv1D) (None, None, 256) 36864 \n", "_________________________________________________________________\n", "batch_normalization_18 (Batc (None, None, 256) 1024 \n", "_________________________________________________________________\n", "bidirectional_10 (Bidirectio (None, None, 512) 787968 \n", "_________________________________________________________________\n", "batch_normalization_19 (Batc (None, None, 512) 2048 \n", "_________________________________________________________________\n", "bidirectional_11 (Bidirectio (None, None, 512) 1181184 \n", "_________________________________________________________________\n", "batch_normalization_20 (Batc (None, None, 512) 2048 \n", "_________________________________________________________________\n", "time_distributed_9 (TimeDist (None, None, 29) 14877 \n", "_________________________________________________________________\n", "softmax (Activation) (None, None, 29) 0 \n", "=================================================================\n", "Total params: 2,026,013\n", "Trainable params: 2,023,453\n", "Non-trainable params: 2,560\n", "_________________________________________________________________\n", "None\n" ] } ], "source": [ "model_9 = agg_model(input_dim=13, # 161 for Spectrogram/13 for MFCC\n", " filters=256,\n", " activation='relu',\n", " kernel_size=11, \n", " conv_stride=2,\n", " conv_border_mode='valid',\n", " recur_layers=2,\n", " units=256)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "train_model(input_to_softmax=model_9, \n", " pickle_path='model_9.pickle', \n", " save_model_path='model_9.h5', \n", " spectrogram=False) # True for Spectrogram/False for MFCC" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Looks like using MFCC's lead to a model that didn't perform quite as well, but did come with a speed up.\n", "\n", "\n", "### Deep Aggregate Model\n", "\n", "Now we will train a deeper version of this model architecture on the full 960 hour data set. For this, we will reintroduce dilated convolutions and recurrent dropout." ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [], "source": [ "def hey_jetson(input_dim, filters, activation, kernel_size, conv_stride,\n", " conv_border_mode, recur_layers, dilation_rate, units, conv_layers, output_dim=29):\n", " # Input\n", " input_data = Input(name='the_input', shape=(None, input_dim))\n", " # Convolutional layer\n", " conv_1d = Conv1D(filters, kernel_size, \n", " strides=conv_stride, \n", " padding=conv_border_mode,\n", " activation=activation,\n", " name='conv1d')(input_data)\n", " # Batch normalization\n", " bn_cnn = BatchNormalization()(conv_1d)\n", " for i in range(conv_layers - 1):\n", " conv_1d = Conv1D(filters, kernel_size,\n", " padding=conv_border_mode,\n", " activation=activation,\n", " dilation_rate=2**i,\n", " name=\"conv_1d_\"+str(i))(bn_cnn)\n", " bn_cnn = BatchNormalization()(conv_1d)\n", " # Bidirectional recurrent layer\n", " brnn = Bidirectional(GRU(units, activation=activation, \n", " return_sequences=True, implementation=2, recurrent_dropout=0.01, name='brnn'))(bn_cnn)\n", " # Batch normalization \n", " bn_rnn = BatchNormalization()(brnn)\n", " # Loop for additional layers\n", " for i in range(recur_layers - 1):\n", " name = 'brnn_' + str(i + 1)\n", " brnn = Bidirectional(GRU(units, activation=activation, \n", " return_sequences=True, implementation=2, name=name))(bn_rnn)\n", " bn_rnn = BatchNormalization()(brnn)\n", " # TimeDistributed Dense layer\n", " time_distributed_dense = TimeDistributed(Dense(1024))(bn_rnn)\n", " time_dense = TimeDistributed(Dense(output_dim))(time_distributed_dense)\n", " # Softmax activation layer\n", " y_pred = Activation('softmax', name='softmax')(time_dense)\n", " # Specifying the model\n", " model = Model(inputs=input_data, outputs=y_pred)\n", " model.output_length = lambda x: cnn_output_length(\n", " x, kernel_size, conv_border_mode, conv_stride)\n", " print(model.summary())\n", " return model" ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "_________________________________________________________________\n", "Layer (type) Output Shape Param # \n", "=================================================================\n", "the_input (InputLayer) (None, None, 161) 0 \n", "_________________________________________________________________\n", "conv1d (Conv1D) (None, None, 256) 206336 \n", "_________________________________________________________________\n", "batch_normalization_1 (Batch (None, None, 256) 1024 \n", "_________________________________________________________________\n", "conv_1d_0 (Conv1D) (None, None, 256) 327936 \n", "_________________________________________________________________\n", "batch_normalization_2 (Batch (None, None, 256) 1024 \n", "_________________________________________________________________\n", "conv_1d_1 (Conv1D) (None, None, 256) 327936 \n", "_________________________________________________________________\n", "batch_normalization_3 (Batch (None, None, 256) 1024 \n", "_________________________________________________________________\n", "bidirectional_1 (Bidirection (None, None, 512) 787968 \n", "_________________________________________________________________\n", "batch_normalization_4 (Batch (None, None, 512) 2048 \n", "_________________________________________________________________\n", "bidirectional_2 (Bidirection (None, None, 512) 1181184 \n", "_________________________________________________________________\n", "batch_normalization_5 (Batch (None, None, 512) 2048 \n", "_________________________________________________________________\n", "bidirectional_3 (Bidirection (None, None, 512) 1181184 \n", "_________________________________________________________________\n", "batch_normalization_6 (Batch (None, None, 512) 2048 \n", "_________________________________________________________________\n", "bidirectional_4 (Bidirection (None, None, 512) 1181184 \n", "_________________________________________________________________\n", "batch_normalization_7 (Batch (None, None, 512) 2048 \n", "_________________________________________________________________\n", "bidirectional_5 (Bidirection (None, None, 512) 1181184 \n", "_________________________________________________________________\n", "batch_normalization_8 (Batch (None, None, 512) 2048 \n", "_________________________________________________________________\n", "bidirectional_6 (Bidirection (None, None, 512) 1181184 \n", "_________________________________________________________________\n", "batch_normalization_9 (Batch (None, None, 512) 2048 \n", "_________________________________________________________________\n", "bidirectional_7 (Bidirection (None, None, 512) 1181184 \n", "_________________________________________________________________\n", "batch_normalization_10 (Batc (None, None, 512) 2048 \n", "_________________________________________________________________\n", "time_distributed_1 (TimeDist (None, None, 1024) 525312 \n", "_________________________________________________________________\n", "time_distributed_2 (TimeDist (None, None, 29) 29725 \n", "_________________________________________________________________\n", "softmax (Activation) (None, None, 29) 0 \n", "=================================================================\n", "Total params: 9,309,725\n", "Trainable params: 9,301,021\n", "Non-trainable params: 8,704\n", "_________________________________________________________________\n", "None\n" ] } ], "source": [ "model_10 = hey_jetson(input_dim=161, # 161 for Spectrogram/13 for MFCC\n", " filters=256,\n", " activation='relu',\n", " kernel_size=5, \n", " conv_stride=2,\n", " recur_layers=7,\n", " conv_border_mode='causal',\n", " conv_layers=3,\n", " dilation_rate=2,\n", " units=256)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "train_model(input_to_softmax=model_10, \n", " pickle_path='model_10.pickle', \n", " save_model_path='model_10.h5', \n", " spectrogram=True) # True for Spectrogram/False for MFCC" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "## Attention\n", "\n", "Now, we will add a single Attention layer to the model that will take as input the output from the encoder(the RNN layers). The decoder portion of the model will include the ability to \"attend\" to different parts of the audio clip at each time step. This lets the model learn what to pay attention to based on the input and what it has predicted the output to be so far. Attention allows the network to refer back to the input sequence by giving the network access to its internal memory, which is the hidden state of the encoder.\n", "\n", "Let's define the class that will make up the Attention layer." ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [], "source": [ "class Attention(keras.layers.Layer):\n", "\n", " ATTENTION_TYPE_ADD = 'additive'\n", " ATTENTION_TYPE_MUL = 'multiplicative'\n", "\n", " def __init__(self,\n", " units=512,\n", " attention_width=None,\n", " attention_type=ATTENTION_TYPE_MUL,\n", " return_attention=False,\n", " history_only=False,\n", " kernel_initializer='glorot_normal',\n", " bias_initializer='zeros',\n", " kernel_regularizer=None,\n", " bias_regularizer=None,\n", " kernel_constraint=None,\n", " bias_constraint=None,\n", " use_additive_bias=True,\n", " use_attention_bias=True,\n", " attention_activation=None,\n", " attention_regularizer_weight=0.0,\n", " **kwargs):\n", " \"\"\"Layer initialization.\n", "\n", " For additive attention, see: https://arxiv.org/pdf/1806.01264.pdf\n", "\n", " :param units: The dimension of the vectors that used to calculate the attention weights.\n", " :param attention_width: The width of local attention.\n", " :param attention_type: 'additive' or 'multiplicative'.\n", " :param return_attention: Whether to return the attention weights for visualization.\n", " :param history_only: Only use historical pieces of data.\n", " :param kernel_initializer: The initializer for weight matrices.\n", " :param bias_initializer: The initializer for biases.\n", " :param kernel_regularizer: The regularization for weight matrices.\n", " :param bias_regularizer: The regularization for biases.\n", " :param kernel_constraint: The constraint for weight matrices.\n", " :param bias_constraint: The constraint for biases.\n", " :param use_additive_bias: Whether to use bias while calculating the relevance of inputs features\n", " in additive mode.\n", " :param use_attention_bias: Whether to use bias while calculating the weights of attention.\n", " :param attention_activation: The activation used for calculating the weights of attention.\n", " :param attention_regularizer_weight: The weights of attention regularizer.\n", " :param kwargs: Parameters for parent class.\n", " \"\"\"\n", " super(Attention, self).__init__(**kwargs)\n", " self.supports_masking = True\n", " self.units = units\n", " self.attention_width = attention_width\n", " self.attention_type = attention_type\n", " self.return_attention = return_attention\n", " self.history_only = history_only\n", " if history_only and attention_width is None:\n", " self.attention_width = int(1e9)\n", "\n", " self.use_additive_bias = use_additive_bias\n", " self.use_attention_bias = use_attention_bias\n", " self.kernel_initializer = keras.initializers.get(kernel_initializer)\n", " self.bias_initializer = keras.initializers.get(bias_initializer)\n", " self.kernel_regularizer = keras.regularizers.get(kernel_regularizer)\n", " self.bias_regularizer = keras.regularizers.get(bias_regularizer)\n", " self.kernel_constraint = keras.constraints.get(kernel_constraint)\n", " self.bias_constraint = keras.constraints.get(bias_constraint)\n", " self.attention_activation = keras.activations.get(attention_activation)\n", " self.attention_regularizer_weight = attention_regularizer_weight\n", " self._backend = keras.backend.backend()\n", "\n", " if attention_type == Attention.ATTENTION_TYPE_ADD:\n", " self.Wx, self.Wt, self.bh = None, None, None\n", " self.Wa, self.ba = None, None\n", " elif attention_type == Attention.ATTENTION_TYPE_MUL:\n", " self.Wa, self.ba = None, None\n", " else:\n", " raise NotImplementedError('No implementation for attention type : ' + attention_type)\n", "\n", " def get_config(self):\n", " config = {\n", " 'units': self.units,\n", " 'attention_width': self.attention_width,\n", " 'attention_type': self.attention_type,\n", " 'return_attention': self.return_attention,\n", " 'history_only': self.history_only,\n", " 'use_additive_bias': self.use_additive_bias,\n", " 'use_attention_bias': self.use_attention_bias,\n", " 'kernel_initializer': keras.regularizers.serialize(self.kernel_initializer),\n", " 'bias_initializer': keras.regularizers.serialize(self.bias_initializer),\n", " 'kernel_regularizer': keras.regularizers.serialize(self.kernel_regularizer),\n", " 'bias_regularizer': keras.regularizers.serialize(self.bias_regularizer),\n", " 'kernel_constraint': keras.constraints.serialize(self.kernel_constraint),\n", " 'bias_constraint': keras.constraints.serialize(self.bias_constraint),\n", " 'attention_activation': keras.activations.serialize(self.attention_activation),\n", " 'attention_regularizer_weight': self.attention_regularizer_weight,\n", " }\n", " base_config = super(Attention, self).get_config()\n", " return dict(list(base_config.items()) + list(config.items()))\n", "\n", " def build(self, input_shape):\n", " if self.attention_type == Attention.ATTENTION_TYPE_ADD:\n", " self._build_additive_attention(input_shape)\n", " elif self.attention_type == Attention.ATTENTION_TYPE_MUL:\n", " self._build_multiplicative_attention(input_shape)\n", " super(Attention, self).build(input_shape)\n", "\n", " def _build_additive_attention(self, input_shape):\n", " feature_dim = int(input_shape[2])\n", "\n", " self.Wt = self.add_weight(shape=(feature_dim, self.units),\n", " name='{}_Add_Wt'.format(self.name),\n", " initializer=self.kernel_initializer,\n", " regularizer=self.kernel_regularizer,\n", " constraint=self.kernel_constraint)\n", " self.Wx = self.add_weight(shape=(feature_dim, self.units),\n", " name='{}_Add_Wx'.format(self.name),\n", " initializer=self.kernel_initializer,\n", " regularizer=self.kernel_regularizer,\n", " constraint=self.kernel_constraint)\n", " if self.use_additive_bias:\n", " self.bh = self.add_weight(shape=(self.units,),\n", " name='{}_Add_bh'.format(self.name),\n", " initializer=self.bias_initializer,\n", " regularizer=self.bias_regularizer,\n", " constraint=self.bias_constraint)\n", "\n", " self.Wa = self.add_weight(shape=(self.units, 1),\n", " name='{}_Add_Wa'.format(self.name),\n", " initializer=self.kernel_initializer,\n", " regularizer=self.kernel_regularizer,\n", " constraint=self.kernel_constraint)\n", " if self.use_attention_bias:\n", " self.ba = self.add_weight(shape=(1,),\n", " name='{}_Add_ba'.format(self.name),\n", " initializer=self.bias_initializer,\n", " regularizer=self.bias_regularizer,\n", " constraint=self.bias_constraint)\n", "\n", " def _build_multiplicative_attention(self, input_shape):\n", " feature_dim = int(input_shape[2])\n", "\n", " self.Wa = self.add_weight(shape=(feature_dim, feature_dim),\n", " name='{}_Mul_Wa'.format(self.name),\n", " initializer=self.kernel_initializer,\n", " regularizer=self.kernel_regularizer,\n", " constraint=self.kernel_constraint)\n", " if self.use_attention_bias:\n", " self.ba = self.add_weight(shape=(1,),\n", " name='{}_Mul_ba'.format(self.name),\n", " initializer=self.bias_initializer,\n", " regularizer=self.bias_regularizer,\n", " constraint=self.bias_constraint)\n", "\n", " def call(self, inputs, mask=None, **kwargs):\n", " input_len = K.shape(inputs)[1]\n", "\n", " if self.attention_type == Attention.ATTENTION_TYPE_ADD:\n", " e = self._call_additive_emission(inputs)\n", " elif self.attention_type == Attention.ATTENTION_TYPE_MUL:\n", " e = self._call_multiplicative_emission(inputs)\n", "\n", " if self.attention_activation is not None:\n", " e = self.attention_activation(e)\n", " e = K.exp(e - K.max(e, axis=-1, keepdims=True))\n", " if self.attention_width is not None:\n", " if self.history_only:\n", " lower = K.arange(0, input_len) - (self.attention_width - 1)\n", " else:\n", " lower = K.arange(0, input_len) - self.attention_width // 2\n", " lower = K.expand_dims(lower, axis=-1)\n", " upper = lower + self.attention_width\n", " indices = K.expand_dims(K.arange(0, input_len), axis=0)\n", " e = e * K.cast(lower <= indices, K.floatx()) * K.cast(indices < upper, K.floatx())\n", " if mask is not None:\n", " mask = K.cast(mask, K.floatx())\n", " mask = K.expand_dims(mask)\n", " e = K.permute_dimensions(K.permute_dimensions(e * mask, (0, 2, 1)) * mask, (0, 2, 1))\n", "\n", " # a_{t} = \\text{softmax}(e_t)\n", " s = K.sum(e, axis=-1, keepdims=True)\n", " a = e / (s + K.epsilon())\n", "\n", " # l_t = \\sum_{t'} a_{t, t'} x_{t'}\n", " v = K.batch_dot(a, inputs)\n", " if self.attention_regularizer_weight > 0.0:\n", " self.add_loss(self._attention_regularizer(a))\n", "\n", " if self.return_attention:\n", " return [v, a]\n", " return v\n", "\n", " def _call_additive_emission(self, inputs):\n", " input_shape = K.shape(inputs)\n", " batch_size, input_len = input_shape[0], input_shape[1]\n", "\n", " # h_{t, t'} = \\tanh(x_t^T W_t + x_{t'}^T W_x + b_h)\n", " q = K.expand_dims(K.dot(inputs, self.Wt), 2)\n", " k = K.expand_dims(K.dot(inputs, self.Wx), 1)\n", " if self.use_additive_bias:\n", " h = K.tanh(q + k + self.bh)\n", " else:\n", " h = K.tanh(q + k)\n", "\n", " # e_{t, t'} = W_a h_{t, t'} + b_a\n", " if self.use_attention_bias:\n", " e = K.reshape(K.dot(h, self.Wa) + self.ba, (batch_size, input_len, input_len))\n", " else:\n", " e = K.reshape(K.dot(h, self.Wa), (batch_size, input_len, input_len))\n", " return e\n", "\n", " def _call_multiplicative_emission(self, inputs):\n", " # e_{t, t'} = x_t^T W_a x_{t'} + b_a\n", " e = K.batch_dot(K.dot(inputs, self.Wa), K.permute_dimensions(inputs, (0, 2, 1)))\n", " if self.use_attention_bias:\n", " e += self.ba[0]\n", " return e\n", "\n", " def compute_output_shape(self, input_shape):\n", " output_shape = input_shape\n", " if self.return_attention:\n", " attention_shape = (input_shape[0], output_shape[1], input_shape[1])\n", " return [output_shape, attention_shape]\n", " return output_shape\n", "\n", " def compute_mask(self, inputs, mask=None):\n", " if self.return_attention:\n", " return [mask, None]\n", " return mask\n", "\n", " def _attention_regularizer(self, attention):\n", " batch_size = K.cast(K.shape(attention)[0], K.floatx())\n", " input_len = K.shape(attention)[-1]\n", " indices = K.expand_dims(K.arange(0, input_len), axis=0)\n", " diagonal = K.expand_dims(K.arange(0, input_len), axis=-1)\n", " eye = K.cast(K.equal(indices, diagonal), K.floatx())\n", " return self.attention_regularizer_weight * K.sum(K.square(K.batch_dot(\n", " attention,\n", " K.permute_dimensions(attention, (0, 2, 1))) - eye)) / batch_size" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "### Final Model\n", "\n", "Now we will train the final attention based model architecture on the full 960 hour data set." ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [], "source": [ "def keras_model(input_dim, filters, activation, kernel_size, conv_stride,\n", " conv_border_mode, recur_layers, dilation_rate, units, conv_layers, output_dim=29):\n", " # Input\n", " input_data = Input(name='the_input', shape=(None, input_dim))\n", " # Inital Convolutional layer\n", " conv_1d = Conv1D(filters, kernel_size, \n", " strides=conv_stride, \n", " padding=conv_border_mode,\n", " activation=activation,\n", " name='conv1d')(input_data)\n", " # Batch normalization\n", " bn_cnn = BatchNormalization()(conv_1d)\n", " # Loop for additional layers\n", " for i in range(conv_layers - 1):\n", " conv_1d = Conv1D(filters, kernel_size,\n", " padding=conv_border_mode,\n", " activation=activation,\n", " dilation_rate=2**i,\n", " name=\"conv_1d_\"+str(i))(bn_cnn)\n", " bn_cnn = BatchNormalization()(conv_1d)\n", " # Initial Bidirectional recurrent layer\n", " brnn = Bidirectional(GRU(units, activation=activation, \n", " return_sequences=True, implementation=2, recurrent_dropout=0.02, name='brnn'))(bn_cnn)\n", " # Batch normalization \n", " bn_rnn = BatchNormalization()(brnn)\n", " # Loop for additional layers\n", " for i in range(recur_layers - 1):\n", " name = 'brnn_' + str(i + 1)\n", " brnn = Bidirectional(GRU(units, activation=activation, \n", " return_sequences=True, implementation=2, name=name))(bn_rnn)\n", " bn_rnn = BatchNormalization()(brnn)\n", " # Attention layer\n", " attentive = Attention()(bn_rnn)\n", " # TimeDistributed Dense layers\n", " time_distributed_dense = TimeDistributed(Dense(1024))(attentive)\n", " time_dense = TimeDistributed(Dense(output_dim))(time_distributed_dense)\n", " # Softmax activation layer\n", " y_pred = Activation('softmax', name='softmax')(time_dense)\n", " # Specifying the model\n", " model = Model(inputs=input_data, outputs=y_pred)\n", " model.output_length = lambda x: cnn_output_length(\n", " x, kernel_size, conv_border_mode, conv_stride)\n", " print(model.summary())\n", " return model" ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "_________________________________________________________________\n", "Layer (type) Output Shape Param # \n", "=================================================================\n", "the_input (InputLayer) (None, None, 161) 0 \n", "_________________________________________________________________\n", "conv1d (Conv1D) (None, None, 256) 206336 \n", "_________________________________________________________________\n", "batch_normalization_1 (Batch (None, None, 256) 1024 \n", "_________________________________________________________________\n", "conv_1d_0 (Conv1D) (None, None, 256) 327936 \n", "_________________________________________________________________\n", "batch_normalization_2 (Batch (None, None, 256) 1024 \n", "_________________________________________________________________\n", "conv_1d_1 (Conv1D) (None, None, 256) 327936 \n", "_________________________________________________________________\n", "batch_normalization_3 (Batch (None, None, 256) 1024 \n", "_________________________________________________________________\n", "bidirectional_1 (Bidirection (None, None, 512) 787968 \n", "_________________________________________________________________\n", "batch_normalization_4 (Batch (None, None, 512) 2048 \n", "_________________________________________________________________\n", "bidirectional_2 (Bidirection (None, None, 512) 1181184 \n", "_________________________________________________________________\n", "batch_normalization_5 (Batch (None, None, 512) 2048 \n", "_________________________________________________________________\n", "bidirectional_3 (Bidirection (None, None, 512) 1181184 \n", "_________________________________________________________________\n", "batch_normalization_6 (Batch (None, None, 512) 2048 \n", "_________________________________________________________________\n", "bidirectional_4 (Bidirection (None, None, 512) 1181184 \n", "_________________________________________________________________\n", "batch_normalization_7 (Batch (None, None, 512) 2048 \n", "_________________________________________________________________\n", "bidirectional_5 (Bidirection (None, None, 512) 1181184 \n", "_________________________________________________________________\n", "batch_normalization_8 (Batch (None, None, 512) 2048 \n", "_________________________________________________________________\n", "bidirectional_6 (Bidirection (None, None, 512) 1181184 \n", "_________________________________________________________________\n", "batch_normalization_9 (Batch (None, None, 512) 2048 \n", "_________________________________________________________________\n", "bidirectional_7 (Bidirection (None, None, 512) 1181184 \n", "_________________________________________________________________\n", "batch_normalization_10 (Batc (None, None, 512) 2048 \n", "_________________________________________________________________\n", "attention_1 (Attention) (None, None, 512) 262145 \n", "_________________________________________________________________\n", "time_distributed_1 (TimeDist (None, None, 1024) 525312 \n", "_________________________________________________________________\n", "time_distributed_2 (TimeDist (None, None, 29) 29725 \n", "_________________________________________________________________\n", "softmax (Activation) (None, None, 29) 0 \n", "=================================================================\n", "Total params: 9,571,870\n", "Trainable params: 9,563,166\n", "Non-trainable params: 8,704\n", "_________________________________________________________________\n", "None\n" ] } ], "source": [ "hey_jetson = keras_model(input_dim=161, # 161 for Spectrogram/13 for MFCC\n", " filters=256,\n", " activation='relu',\n", " kernel_size=5, \n", " conv_stride=2,\n", " recur_layers=7,\n", " conv_border_mode='causal',\n", " conv_layers=3,\n", " dilation_rate=2,\n", " units=256)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "train_model(input_to_softmax=hey_jetson, \n", " pickle_path='model_11.pickle', \n", " save_model_path='model_11.h5', \n", " spectrogram=True) # True for Spectrogram/False for MFCC" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "## Visualizing The Final Model Architecture" ] }, { "cell_type": "code", "execution_count": 25, "metadata": { "scrolled": true }, "outputs": [], "source": [ "# Outputting a graph of the model architecture for inclusion in the app and repo\n", "keras.utils.plot_model(hey_jetson, to_file='./app/static/images/model_11.png', show_shapes=True, show_layer_names=True)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now you can visualize the model in TensorBoard by typing ```tensorboard --logdir ./logs``` into a terminal in the repository directory and then navigating to [http://localhost:6006](http://localhost:6006) in your browser.\n", "\n", "Training on our production model has finally concluded!\n", "\n", "With each epoch taking around 9 hours using spectrograms, the total training time on an Nvidia GTX1070(8GB) for each model using the final architecture was roughly 11 days.\n", "\n", "\n", "## Comparing Models\n", "\n", "- [Final Model Performance](#test)\n", "- [Cosine Similarity](#similarity)\n", "- [Word Error Rate](#error_rate)\n", "- [Benchmarking Performance](#benchmark)\n", "\n", "#### First, let's plot the loss from the saved pickle files for each model:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Load saved model pickles\n", "all_pickles = sorted(glob(\"results/*.pickle\"))\n", "# Extract model names\n", "model_names = [item[8:-7] for item in all_pickles]\n", "# Extract loss history\n", "valid_loss = [pickle.load( open( i, \"rb\" ) )['val_loss'] for i in all_pickles]\n", "train_loss = [pickle.load( open( i, \"rb\" ) )['loss'] for i in all_pickles]\n", "# Identify number of epochs each model ran for\n", "num_epochs = [len(valid_loss[i]) for i in range(len(valid_loss))]\n", "\n", "fig = plt.figure(figsize=(16,5))\n", "\n", "# Plot the training loss vs. epochs\n", "ax1 = fig.add_subplot(121)\n", "for i in range(len(all_pickles)):\n", " ax1.plot(np.linspace(1, num_epochs[i], num_epochs[i]), \n", " train_loss[i], label=model_names[i])\n", "ax1.legend() \n", "ax1.set_xlim([1, max(num_epochs)])\n", "plt.xlabel('Epoch')\n", "plt.ylabel('Training Loss')\n", "\n", "# Plot the validation loss vs. epochs\n", "ax2 = fig.add_subplot(122)\n", "for i in range(len(all_pickles)):\n", " ax2.plot(np.linspace(1, num_epochs[i], num_epochs[i]), \n", " valid_loss[i], label=model_names[i])\n", "ax2.legend() \n", "ax2.set_xlim([1, max(num_epochs)])\n", "plt.xlabel('Epoch')\n", "plt.ylabel('Validation Loss')\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "### Final Model Performance\n", "\n", "Language modeling, the component of a speech recognition system that estimates the prior probabilities of spoken sounds, is the system's knowledge of what probable word sequences are. This system uses a class based language model, which allows it to narrow down its search field through the vocabulary of the speech recognizer (the first part of the system) as it will rarely see a sentence that looks like \"the dog the ate sand the water\" so it will assume that 'the' is not likely to come after the word 'sand'. We do this by assigning a probability to every possible sentence and then picking the word with the highest prior probability of occurring. Language model smoothing (often called discounting) will help us overcome the problem that this creates a model that will assign a probability of 0 to anything it hasn't witnessed in training. This is done by distributing non-zero probabilities over all possible occurrences in proportion to the unigram probabilities of words. This overcomes the limitations of traditional n-gram based modeling and is all made possible by the added dimension of time sequences in the recurrent neural network.\n", "\n", "The best performing model is considered the one that gives the highest probabilities to the words that are found in a test set, since it wastes less probability on words that actually occur. More information on comparing models can be found in this [paper](resources/comparingmodels.pdf). \n", "\n", "#### Let's check out our model predictions:\n", "\n", "We'll also benchmark how long it takes the model to produce the predictions." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "def get_predictions(index, partition, input_to_softmax, model_path):\n", " # Load the train and test data\n", " data_gen = AudioGenerator(spectrogram = spectrogram)\n", " data_gen.load_train_data()\n", " data_gen.load_validation_data()\n", " data_gen.load_test_data()\n", " # Obtain ground truth transcriptions and audio features \n", " if partition == 'validation':\n", " transcription = data_gen.valid_texts[index]\n", " audio_path = data_gen.valid_audio_paths[index]\n", " data_point = data_gen.normalize(data_gen.featurize(audio_path))\n", " elif partition == 'train':\n", " transcription = data_gen.train_texts[index]\n", " audio_path = data_gen.train_audio_paths[index]\n", " data_point = data_gen.normalize(data_gen.featurize(audio_path))\n", " elif partition == 'test':\n", " transcription = data_gen.test_texts[index]\n", " audio_path = data_gen.test_audio_paths[index]\n", " data_point = data_gen.normalize(data_gen.featurize(audio_path))\n", " else:\n", " raise Exception('Invalid partition! Must be \"train\", \"test\", or \"validation\"') \n", " # Obtain predictions\n", " input_to_softmax.load_weights(model_path)\n", " prediction = input_to_softmax.predict(np.expand_dims(data_point, axis=0))\n", " output_length = [input_to_softmax.output_length(data_point.shape[0])] \n", " pred_ints = (K.eval(K.ctc_decode(\n", " prediction, output_length)[0][0])+1).flatten().tolist()\n", " # Display ground truth transcription and predicted transcripted.\n", " print('True transcription:\\n' + '\\n' + transcription)\n", " print('Predicted transcription:\\n' + '\\n' + ''.join(int_seq_to_text(pred_ints)))" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "%time get_predictions(index=95, partition='train', input_to_softmax=hey_jetson, model_path='./results/model_11.h5')" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "scrolled": true }, "outputs": [], "source": [ "%time get_predictions(index=95, partition='validation', input_to_softmax=hey_jetson, model_path='./results/model_11.h5')" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "%time get_predictions(index=95, partition='test', input_to_softmax=hey_jetson, model_path='./results/model_11.h5')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Now, let's check the aggregate model:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "%time get_predictions(index=95, partition='test', input_to_softmax=model_10, model_path='./results/model_10.h5')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Now, let's check the spectrogram model trained on 460 hours of audio:" ] }, { "cell_type": "code", "execution_count": 48, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "True transcription:\n", "\n", "in the absence of a hypodermic syringe the remedy may be given by the rectum\n", "Predicted transcription:\n", "\n", "inse absens of the hapademec shaenge sevemety may be gave in vye of recttim\n", "CPU times: user 2.29 s, sys: 89.4 ms, total: 2.37 s\n", "Wall time: 2.48 s\n" ] } ], "source": [ "%time get_predictions(index=95, partition='test', input_to_softmax=model_8, model_path='./results/model_8.h5')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Let's compare the final model's predictions on the test set agains our last 3 developmental models and the original RNN model." ] }, { "cell_type": "code", "execution_count": 49, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "True transcription:\n", "\n", "in the absence of a hypodermic syringe the remedy may be given by the rectum\n", "Predicted transcription:\n", "\n", "en tet fom af e heacedemo fovang the vemat o mo de givven by tha re tem\n", "CPU times: user 2.39 s, sys: 105 ms, total: 2.49 s\n", "Wall time: 2.56 s\n" ] } ], "source": [ "# Dilated Deep CNN + Deep Bidirectional RNN + Time Distributed Dense\n", "%time get_predictions(index=95, partition='test', input_to_softmax=model_7, model_path='./results/model_7.h5')" ] }, { "cell_type": "code", "execution_count": 50, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "True transcription:\n", "\n", "in the absence of a hypodermic syringe the remedy may be given by the rectum\n", "Predicted transcription:\n", "\n", "eensteedsoms of the had edem ofs hemine the veman youmo be given by thevectim\n", "CPU times: user 2.33 s, sys: 105 ms, total: 2.43 s\n", "Wall time: 2.5 s\n" ] } ], "source": [ "# Deep CNN + Deep Bidirectional RNN + Time Distributed Dense w/ Droupout\n", "%time get_predictions(index=95, partition='test', input_to_softmax=model_6, model_path='./results/model_6.h5')" ] }, { "cell_type": "code", "execution_count": 51, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "True transcription:\n", "\n", "in the absence of a hypodermic syringe the remedy may be given by the rectum\n", "Predicted transcription:\n", "\n", "insth at srens of he had a demme sivvems thof remmantd ye mobe gaven by the vectame\n", "CPU times: user 2.34 s, sys: 80.1 ms, total: 2.42 s\n", "Wall time: 2.49 s\n" ] } ], "source": [ "# Model_5 on the 100 hour subset\n", "%time get_predictions(index=95, partition='test', input_to_softmax=model_5, model_path='./results/model_5.h5')" ] }, { "cell_type": "code", "execution_count": 52, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "True transcription:\n", "\n", "in the absence of a hypodermic syringe the remedy may be given by the rectum\n", "Predicted transcription:\n", "\n", " \n", "CPU times: user 2.1 s, sys: 88.9 ms, total: 2.19 s\n", "Wall time: 2.21 s\n" ] } ], "source": [ "# Initial RNN model\n", "%time get_predictions(index=95, partition='test', input_to_softmax=model_0, model_path='./results/model_0.h5')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We've come a long way. Our final model comes close to the actual spoken transcription, while the first few models predicted nothing at all, or the same letter for every utterance. Now, let's quantify the final model's performance.\n", "\n", "#### Calculating error rates:\n", "Fist we need to obtain the ground truth transcriptions and the predicted transcriptions for the validation and test sets. Then we can use several measures to determine accuracy." ] }, { "cell_type": "code", "execution_count": 54, "metadata": {}, "outputs": [], "source": [ "# Function for extracting the ground truth transcriptions from the audio files.\n", "def get_ground_truth(partition):\n", " ground_truth_list = []\n", " data_gen = AudioGenerator(spectrogram = spectrogram)\n", " if partition == 'train':\n", " data_gen.load_train_data()\n", " for i in range(0, 61956):\n", " transcription = data_gen.train_texts[i]\n", " ground_truth_list.append(transcription)\n", " elif partition == 'validation':\n", " data_gen.load_validation_data()\n", " for i in range(0, 4277):\n", " transcription = data_gen.valid_texts[i]\n", " ground_truth_list.append(transcription)\n", " elif partition == 'test':\n", " data_gen.load_test_data()\n", " for i in range(0, 4176):\n", " transcription = data_gen.test_texts[i]\n", " ground_truth_list.append(transcription)\n", " ground_truth = np.asarray(ground_truth_list)\n", " return ground_truth" ] }, { "cell_type": "code", "execution_count": 59, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array(['looking about me i saw a gentleman in a neat black dress smiling and his hand extended to me with great cordiality',\n", " 'he must have realized i was a stranger and wished to tender his hospitality to me i accepted it gratefully i clasped his hand he pressed mine',\n", " \"we gazed for a moment silently into each other's eyes\", ...,\n", " 'that penance hath no blame which magdalen found sweet purging our shame self punishment is virtue all men know',\n", " 'heaven help that body which a little mind housed in a head lacking ears tongue and eyes and senseless but for smell can tyrannise',\n", " 'due to thee their praise of maiden pure of teeming motherhood'],\n", " dtype='\n", "#### Cosine Similarity\n", "\n", "This is a measure where a score of 1 means that the two strings are exactly equal and a score of 0 means the prediction transcription contains none of the words in the ground truth label.\n", "\n", "More info on this metric can be found at [Wikipedia](https://en.wikipedia.org/wiki/Cosine_similarity)." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "def get_sim(partition, input_to_softmax, model_path):\n", " # Getting the cosine similarity using Count Vectorizer\n", " sim_list = []\n", " data_gen = AudioGenerator(spectrogram = spectrogram)\n", " data_gen.load_test_data()\n", " data_gen.load_validation_data()\n", " data_gen.load_train_data()\n", " if partition == 'train':\n", " for i in range(0, 61956):\n", " transcription = data_gen.train_texts[i]\n", " audio_path = data_gen.train_audio_paths[i]\n", " data_point = data_gen.normalize(data_gen.featurize(audio_path))\n", " input_to_softmax.load_weights(model_path)\n", " prediction = input_to_softmax.predict(np.expand_dims(data_point, axis=0))\n", " output_length = [input_to_softmax.output_length(data_point.shape[0])] \n", " pred_ints = (K.eval(K.ctc_decode(\n", " prediction, output_length)[0][0])+1).flatten().tolist()\n", " pred_trans = ''.join(int_seq_to_text(pred_ints))\n", " cv = CountVectorizer()\n", " ground_truth_vec = cv.fit_transform([transcription])\n", " pred_transcription_vec = cv.transform([pred_trans])\n", " sim = cosine_similarity(ground_truth_vec, pred_transcription_vec)\n", " sim_list.append(sim)\n", " if i%2000 == 0: print('Processed {}'.format(i))\n", " \n", " elif partition == 'validation':\n", " for i in range(0, 4277):\n", " transcription = data_gen.valid_texts[i]\n", " audio_path = data_gen.valid_audio_paths[i]\n", " data_point = data_gen.normalize(data_gen.featurize(audio_path))\n", " input_to_softmax.load_weights(model_path)\n", " prediction = input_to_softmax.predict(np.expand_dims(data_point, axis=0))\n", " output_length = [input_to_softmax.output_length(data_point.shape[0])] \n", " pred_ints = (K.eval(K.ctc_decode(\n", " prediction, output_length)[0][0])+1).flatten().tolist()\n", " pred_trans = ''.join(int_seq_to_text(pred_ints))\n", " cv = CountVectorizer()\n", " ground_truth_vec = cv.fit_transform([transcription])\n", " pred_transcription_vec = cv.transform([pred_trans])\n", " sim = cosine_similarity(ground_truth_vec, pred_transcription_vec)\n", " sim_list.append(sim)\n", " if i%200 == 0: print('Processed {}'.format(i))\n", " \n", " elif partition == 'test':\n", " for i in range(0, 4176):\n", " transcription = data_gen.test_texts[i]\n", " audio_path = data_gen.test_audio_paths[i]\n", " data_point = data_gen.normalize(data_gen.featurize(audio_path))\n", " input_to_softmax.load_weights(model_path)\n", " prediction = input_to_softmax.predict(np.expand_dims(data_point, axis=0))\n", " output_length = [input_to_softmax.output_length(data_point.shape[0])] \n", " pred_ints = (K.eval(K.ctc_decode(\n", " prediction, output_length)[0][0])+1).flatten().tolist()\n", " pred_trans = ''.join(int_seq_to_text(pred_ints))\n", " cv = CountVectorizer()\n", " ground_truth_vec = cv.fit_transform([transcription])\n", " pred_transcription_vec = cv.transform([pred_trans])\n", " sim = cosine_similarity(ground_truth_vec, pred_transcription_vec)\n", " sim_list.append(sim)\n", " if i%200 == 0: print('Processed {}'.format(i))\n", "\n", " sim_array = np.asarray(sim_list)\n", " return sim_array" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Extracting the validation count vectorizer cosine similarities\n", "valid_sim = get_sim(partition='validation', \n", " input_to_softmax=hey_jetson, model_path='./results/model_11.h5')\n", "valid_sim" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "valid_sim.mean()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Extracting the test count vectorizer cosine similarities\n", "test_sim = get_sim(partition='test', \n", " input_to_softmax=hey_jetson, model_path='./results/model_11.h5')\n", "test_sim" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "test_sim.mean()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "It looks like we have about an 80% similarity between the predictions and ground truth transcriptions in the validation and a 78% similarity in the test sets when using count vectorization, so let's see if TF-IDF vectorization produces different results:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "def get_tfidf_sim(partition, input_to_softmax, model_path):\n", " # Getting the cosine similarity using Tfidf Vectorizer\n", " sim_list = []\n", " data_gen = AudioGenerator(spectrogram = spectrogram)\n", " data_gen.load_test_data()\n", " data_gen.load_validation_data()\n", " data_gen.load_train_data()\n", " if partition == 'train':\n", " for i in range(0, 61956):\n", " transcription = data_gen.train_texts[i]\n", " audio_path = data_gen.train_audio_paths[i]\n", " data_point = data_gen.normalize(data_gen.featurize(audio_path))\n", " input_to_softmax.load_weights(model_path)\n", " prediction = input_to_softmax.predict(np.expand_dims(data_point, axis=0))\n", " output_length = [input_to_softmax.output_length(data_point.shape[0])] \n", " pred_ints = (K.eval(K.ctc_decode(\n", " prediction, output_length)[0][0])+1).flatten().tolist()\n", " pred_trans = ''.join(int_seq_to_text(pred_ints))\n", " tfidf = TfidfVectorizer()\n", " ground_truth_vec = tfidf.fit_transform([transcription])\n", " pred_transcription_vec = tfidf.transform([pred_trans])\n", " sim = cosine_similarity(ground_truth_vec, pred_transcription_vec)\n", " sim_list.append(sim)\n", " if i%2000 == 0: print('Processed {}'.format(i))\n", " \n", " elif partition == 'validation':\n", " for i in range(0, 4277):\n", " transcription = data_gen.valid_texts[i]\n", " audio_path = data_gen.valid_audio_paths[i]\n", " data_point = data_gen.normalize(data_gen.featurize(audio_path))\n", " input_to_softmax.load_weights(model_path)\n", " prediction = input_to_softmax.predict(np.expand_dims(data_point, axis=0))\n", " output_length = [input_to_softmax.output_length(data_point.shape[0])] \n", " pred_ints = (K.eval(K.ctc_decode(\n", " prediction, output_length)[0][0])+1).flatten().tolist()\n", " pred_trans = ''.join(int_seq_to_text(pred_ints))\n", " tfidf = TfidfVectorizer()\n", " ground_truth_vec = tfidf.fit_transform([transcription])\n", " pred_transcription_vec = tfidf.transform([pred_trans])\n", " sim = cosine_similarity(ground_truth_vec, pred_transcription_vec)\n", " sim_list.append(sim)\n", " if i%200 == 0: print('Processed {}'.format(i))\n", " \n", " elif partition == 'test':\n", " for i in range(0, 4176):\n", " transcription = data_gen.test_texts[i]\n", " audio_path = data_gen.test_audio_paths[i]\n", " data_point = data_gen.normalize(data_gen.featurize(audio_path))\n", " input_to_softmax.load_weights(model_path)\n", " prediction = input_to_softmax.predict(np.expand_dims(data_point, axis=0))\n", " output_length = [input_to_softmax.output_length(data_point.shape[0])] \n", " pred_ints = (K.eval(K.ctc_decode(\n", " prediction, output_length)[0][0])+1).flatten().tolist()\n", " pred_trans = ''.join(int_seq_to_text(pred_ints))\n", " tfidf = TfidfVectorizer()\n", " ground_truth_vec = tfidf.fit_transform([transcription])\n", " pred_transcription_vec = tfidf.transform([pred_trans])\n", " sim = cosine_similarity(ground_truth_vec, pred_transcription_vec)\n", " sim_list.append(sim)\n", " if i%200 == 0: print('Processed {}'.format(i))\n", "\n", " sim_array = np.asarray(sim_list)\n", " return sim_array" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Extracting the validation tfidf cosine similarities\n", "valid_tfidf_sim = get_tfidf_sim(partition='validation', \n", " input_to_softmax=hey_jetson, model_path='./results/model_11.h5')\n", "valid_tfidf_sim" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "valid_tfidf_sim.mean()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Extracting the test tfidf cosine similarities\n", "test_tfidf_sim = get_tfidf_sim(partition='test', \n", " input_to_softmax=hey_jetson, model_path='./results/model_11.h5')\n", "test_tfidf_sim" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "test_tfidf_sim.mean()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "It looks like we have about a 80% similarity between the predictions and ground truth transcriptions in the validation set and around a 78% similarity in the test sets when using TF-IDF vectorization as well.\n", "\n", "\n", "#### Word Error Rate\n", "\n", "Word error rate is defined as (substitutions + deletions + insertions) / # of words in the ground truth transcription. \n", "\n", "More info on this metric can be found at [Wikipedia](https://en.wikipedia.org/wiki/Word_error_rate)." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "def wer_calc(ref, pred):\n", " # Calcualte word error rate\n", " d = np.zeros((len(ref) + 1) * (len(pred) + 1), dtype=np.uint16)\n", " d = d.reshape((len(ref) + 1, len(pred) + 1))\n", " for i in range(len(ref) + 1):\n", " for j in range(len(pred) + 1):\n", " if i == 0:\n", " d[0][j] = j\n", " elif j == 0:\n", " d[i][0] = i\n", "\n", " for i in range(1, len(ref) + 1):\n", " for j in range(1, len(pred) + 1):\n", " if ref[i - 1] == pred[j - 1]:\n", " d[i][j] = d[i - 1][j - 1]\n", " else:\n", " substitution = d[i - 1][j - 1] + 1\n", " insertion = d[i][j - 1] + 1\n", " deletion = d[i - 1][j] + 1\n", " d[i][j] = min(substitution, insertion, deletion)\n", " result = float(d[len(ref)][len(pred)]) / len(ref) * 100\n", " return result\n", " \n", "# Function for extracting the predicted transcriptions from the audio files and calculating word error rate on them\n", "def get_wer(partition, input_to_softmax, model_path):\n", " wer_list = []\n", " data_gen = AudioGenerator(spectrogram = spectrogram)\n", " data_gen.load_test_data()\n", " data_gen.load_validation_data()\n", " data_gen.load_train_data()\n", " if partition == 'train':\n", " for i in range(0, 61956):\n", " transcription = data_gen.train_texts[i]\n", " audio_path = data_gen.train_audio_paths[i]\n", " data_point = data_gen.normalize(data_gen.featurize(audio_path))\n", " input_to_softmax.load_weights(model_path)\n", " prediction = input_to_softmax.predict(np.expand_dims(data_point, axis=0))\n", " output_length = [input_to_softmax.output_length(data_point.shape[0])] \n", " pred_ints = (K.eval(K.ctc_decode(\n", " prediction, output_length)[0][0])+1).flatten().tolist()\n", " pred_trans = ''.join(int_seq_to_text(pred_ints))\n", " error_rate = wer_calc(transcription, pred_trans)\n", " wer_list.append(error_rate)\n", " if i%2000 == 0: print('Processed {}'.format(i))\n", " \n", " elif partition == 'validation':\n", " for i in range(0, 4277):\n", " transcription = data_gen.valid_texts[i]\n", " audio_path = data_gen.valid_audio_paths[i]\n", " data_point = data_gen.normalize(data_gen.featurize(audio_path))\n", " input_to_softmax.load_weights(model_path)\n", " prediction = input_to_softmax.predict(np.expand_dims(data_point, axis=0))\n", " output_length = [input_to_softmax.output_length(data_point.shape[0])] \n", " pred_ints = (K.eval(K.ctc_decode(\n", " prediction, output_length)[0][0])+1).flatten().tolist()\n", " pred_trans = ''.join(int_seq_to_text(pred_ints))\n", " error_rate = wer_calc(transcription, pred_trans)\n", " wer_list.append(error_rate)\n", " if i%200 == 0: print('Processed {}'.format(i))\n", " \n", " elif partition == 'test':\n", " for i in range(0, 4176):\n", " transcription = data_gen.test_texts[i]\n", " audio_path = data_gen.test_audio_paths[i]\n", " data_point = data_gen.normalize(data_gen.featurize(audio_path))\n", " input_to_softmax.load_weights(model_path)\n", " prediction = input_to_softmax.predict(np.expand_dims(data_point, axis=0))\n", " output_length = [input_to_softmax.output_length(data_point.shape[0])] \n", " pred_ints = (K.eval(K.ctc_decode(\n", " prediction, output_length)[0][0])+1).flatten().tolist()\n", " pred_trans = ''.join(int_seq_to_text(pred_ints))\n", " error_rate = wer_calc(transcription, pred_trans)\n", " wer_list.append(error_rate)\n", " if i%200 == 0: print('Processed {}'.format(i))\n", "\n", " wer_array = np.asarray(wer_list)\n", " return wer_array" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Extracting the validation word error rates\n", "valid_wer = get_wer(partition='validation', \n", " input_to_softmax=hey_jetson, model_path='./results/model_11.h5')\n", "valid_wer" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Calculating the word error rate in the validation set\n", "valid_wer.mean()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Extracting the test word error rates\n", "test_wer = get_wer(partition='test', \n", " input_to_softmax=hey_jetson, model_path='./results/model_11.h5')\n", "test_wer" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Calculating the word error rate in the test set\n", "test_wer.mean()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We did pretty well! Our model achieved a word error rate of about 16% in the validation set and 18% in the test set.The error rate of our model is still pretty high compared to some of the models expored in the reference papers, but this is due to the scope of the project, the lack of a pretrained language model, the single 8G GPU and the length of time I had for this project prevented me from exploring further.\n", "\n", "\n", "#### Benchmarking performance\n", "\n", "Let's time inference on the production system running live on the server to get a feel for how quickly we can serve up predictions:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "%time get_predictions(index=12, partition='test', input_to_softmax=hey_jetson, model_path='./results/model_11.h5')" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "%time get_predictions(index=21, partition='test', input_to_softmax=hey_jetson, model_path='./results/model_11.h5')" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "%time get_predictions(index=2012, partition='test', input_to_softmax=hey_jetson, model_path='./results/model_11.h5')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "## Conclusion\n", "\n", "This concludes the model construction demo. You have now trained a strong performing recurrent neural network for speech recognition, from scratch, with a word error rate of <20%. You have built an ASR model ready for deployment in production environments. If you would like to do so, instructions for building and deploying this model on the Nvidia Jetson using the flask RESTful web app framework for python are included in the [GitHub Repository](https://github.com/bricewalker/Hey-Jetson).\n", "\n", "### Next Steps\n", "\n", "Next steps for this project, and things you can try on your own, include: \n", "- Build a deeper model with more layers.\n", "- Train the model on [audio with background noise](https://www.tensorflow.org/versions/master/tutorials/audio_recognition).\n", "- Train the model on [Mozilla's Common Voice](https://voice.mozilla.org/) dataset to identify the speaker's gender and accent using this [reference project](https://github.com/mozilla/DeepSpeech).\n", "- Train the model on conversational speech, like that found in the [Buckeye Corpus](https://buckeyecorpus.osu.edu/), [Santa Barbara Corpus](http://www.linguistics.ucsb.edu/research/santa-barbara-corpus), or [COSINE Corpus](http://melodi.ee.washington.edu/cosine/).\n", "- Develop a production system for handling speech with sensitive personal information like in this reference [paper](resources/privateconversations.pdf). \n", "- Get the audio files into an [SQL database](https://www.mysql.com/) for faster service for the inference engine and for allowing service to end users with [HTML5's audio tag](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/audio) so they can actually hear the audio file.\n", "- Store user recorded audio for online training of the model to improve performance.\n", "- Recreate the model in [TensorFlow](https://www.tensorflow.org/) for [improved performance](https://github.com/tensorflow/tensorflow). [Mozilla](https://github.com/mozilla/DeepSpeech) has demonstrated the incredible power of TensorFlow for ASR.\n", "- Train the model using just the raw audio files, like this project from [Pannous](https://github.com/pannous/tensorflow-speech-recognition).\n", "- Train the model to [identify individual speakers](resources/speakeridentification.pdf) like [Google](resources/googlespeaker.pdf) using the [VoxCeleb](http://www.robots.ox.ac.uk/~vgg/data/voxceleb/) dataset.\n", "- Train the model to identify the speaker's level of [emotion](resources/emotionrecognition.pdf). There are many examples on [Github](https://github.com/).\n", "- Convert the inference engine to Nvidia's [TensorRT](https://developer.nvidia.com/tensorrt) inference platform using their [Developer Guide](http://docs.nvidia.com/deeplearning/sdk/tensorrt-developer-guide/index.html) and the [RESTful interface](https://devblogs.nvidia.com/tensorrt-container/).\n", "- Train the model on other languages, like [Baidu's Deep Speech 2](resources/deepspeech2.pdf).\n", "- Try out a [transducer model](resources/transducers.pdf), like Baidu is doing in [Deep Speech 3](http://research.baidu.com/deep-speech-3%EF%BC%9Aexploring-neural-transducers-end-end-speech-recognition/).\n", "- Build a more traditional [encoder/decoder](resources/encoderdecoder.pdf) model as outlined by [Lu et al](resources/encoderdecoder2.pdf). \n", "- Add other [augmentation methods](https://distill.pub/2016/augmented-rnns/) besides just attention to the model.\n", "- Add [peephole connections](resources/peepholes.pdf) to the [LSTM cells](https://www.tensorflow.org/api_docs/python/tf/contrib/rnn/LSTMCell).\n", "- Add a [Hidden Markov Model](resources/hmm.pdf)/[Gaussian Mixture Model](resources/gmm.pdf).\n", "- Use a pretrained language model like this one from [kaldi](http://www.kaldi-asr.org/downloads/build/6/trunk/egs/).\n", "- Reduce the word error rate to [<10%](https://hacks.mozilla.org/2017/11/a-journey-to-10-word-error-rate/).\n", "- Include [entity extraction](https://towardsdatascience.com/entity-extraction-using-deep-learning-8014acac6bb8) in the model so that it can begin to identify the topic of discussion.\n", "- Implement a [wake-word detection engine](https://github.com/Picovoice/Porcupine).\n", "\n", "### Special Thanks\n", "\n", "I want to thank the following people/organizations for their support and training:\n", "\n", "- The instructional staff including Charles Rice, Riley Davis, and David Yerrington at [General Assembly](https://generalassemb.ly/) for their fantastic training in data science and machine/deep learning.\n", "- Andrew Ng with [deeplearning.ai](https://www.deeplearning.ai/), for developing the [Coursera Course on Sequence Models](https://www.coursera.org/learn/nlp-sequence-models) which helped me understand the mathematics behind recurrent neural networks.\n", "- [Microsoft ](https://www.microsoft.com/en-us/)for putting together the [edX course on Speech Recognition Systems](https://www.edx.org/course/speech-recognition-and-synthesis) which helped me understand the history of and theory behind speech recognition systems.\n", "- Alexis Cook and the staff at [Udacity](https://www.udacity.com/), [IBM's Watson team](https://www.ibm.com/watson/), and the [Amazon Alexa](https://developer.amazon.com/alexa) team for the course on [Artificial Intelligence on Udacity](https://www.udacity.com/course/artificial-intelligence-nanodegree--nd889) which helped me learn how to apply my knowledge on a real world dataset.\n", "- Paolo Prandoni and Martin Vetterli at [École Polytechnique Fédérale de Lausanne](https://www.epfl.ch/) for teaching the course on [Digital Signal Processing on Coursera](https://www.coursera.org/learn/dsp/) that helped me understand the mathematics behind the Fourier transform.\n", "- The staff at [Nvidia](http://www.nvidia.com/page/home.html) who have helped me learn how to run inference on the Jetson.\n", "- The Seattle DSI-3 Cohort at General Assembly for supporting my journey and giving me good constructive feedback in the development phase of this project.\n", "- [Miguel Grinberg](https://blog.miguelgrinberg.com/index) whose book and online tutorial on Flask helped me learn how to deploy web apps in Flask.\n", "- [Jetson Hacks](http://www.jetsonhacks.com/) for providing several tutorials and repos that helped me learn how to develop on the Jetson.\n", "\n", "### Contributions\n", "\n", "If you would like to contribute to this project, please fork and submit a pull request. I am always open to feedback and would love help with this project.\n", "\n", "[Click here to go back to the top of the notebook](#top)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.7.6" } }, "nbformat": 4, "nbformat_minor": 4 }