diff --git a/contrib/audio/Spoken_Digit_Recognition/MNIST_Speech.bson b/contrib/audio/Spoken_Digit_Recognition/MNIST_Speech.bson
new file mode 100644
index 000000000..2e6d9088d
Binary files /dev/null and b/contrib/audio/Spoken_Digit_Recognition/MNIST_Speech.bson differ
diff --git a/contrib/audio/Spoken_Digit_Recognition/Readme.md b/contrib/audio/Spoken_Digit_Recognition/Readme.md
new file mode 100644
index 000000000..bf20322bd
--- /dev/null
+++ b/contrib/audio/Spoken_Digit_Recognition/Readme.md
@@ -0,0 +1,25 @@
+# Spoken Digit Recognition
+This is an implementation of Spoken Digit Recognition by applying Convolutional Neural Networks using Spectrogram values of WAV audio files.
+Here, to train, [Spoken_Digit_Dataset](https://www.kaggle.com/divyanshu99/spoken-digit-dataset/download) from kaggle is used. 
+
+## Steps for loading the data
+First Download the data from the given link : https://www.kaggle.com/divyanshu99/spoken-digit-dataset/download<br>
+After downloading the data, to your workspace, extract the data and rename the folder as Spoken_Digit. Now, the data is ready to be processed.
+
+## About the Dataset
+Dataset consists of:
+- 4 speakers
+- 2,000 recordings (50 of each digit per speaker) at 8KHz frequency
+- Digits from 0 to 9
+- English pronunciations
+
+## About the Model
+In the model, spectrogram values for the WAV audio files are obatined which are then used to train the model after proper normalisation. Model consists of two layers of Convolution along with MaxPool, BatchNorm and two Dense Layers.
+
+## Test Accuracy
+Test data is assumed after making a 15% split from the total available dataset. Test accuracy of 92.33% was achieved after 20 iterations. Model with best performance was saved as Digit_Speech.bson
+
+## References
+<ul>
+  <li>https://github.com/FluxML/model-zoo/blob/master/vision/mnist/conv.jl</li>
+</ul>
diff --git a/contrib/audio/Spoken_Digit_Recognition/Spoken_Digit/Readme.md b/contrib/audio/Spoken_Digit_Recognition/Spoken_Digit/Readme.md
new file mode 100644
index 000000000..175d57fea
--- /dev/null
+++ b/contrib/audio/Spoken_Digit_Recognition/Spoken_Digit/Readme.md
@@ -0,0 +1 @@
+Here, the <u>recordings</u> folder is to be kept after unzipping the dataset file downloaded using the provided link.
diff --git a/contrib/audio/Spoken_Digit_Recognition/Src.jl b/contrib/audio/Spoken_Digit_Recognition/Src.jl
new file mode 100644
index 000000000..b5dd17b52
--- /dev/null
+++ b/contrib/audio/Spoken_Digit_Recognition/Src.jl
@@ -0,0 +1,166 @@
+using DSP,WAV
+using PyCall
+using PyPlot
+using MFCC
+using FFTW
+using Flux
+using Printf,BSON
+using Flux: onehotbatch, onecold, crossentropy, throttle, Conv,relu
+using Base.Iterators: partition
+using StatsBase
+using MLLabelUtils,MLDataPattern
+IpY = pyimport("IPython")
+using Images
+
+#Loading the data
+cd("./@__dir__")     #Replace the dir with your directory where you have unzipped the Audio Data
+A = readdir("./Spoken_Digit/recordings")
+cd("./Spoken_Digit/recordings")
+X = []
+X_fs = []
+Y = []
+for i in 1:length(A)
+    s,fs = wavread(A[i])
+    push!(X,s)
+    push!(X_fs,fs)
+    push!(Y,Int(A[i][1]-'0'))
+end
+cd("./../../")
+
+#Converting the audio data into Spectrogram images which will then be used for training the model 
+imgs = []
+for i in 1:length(X)
+    b = spectrogram(X[i][:,1])
+    push!(imgs,b.power)
+end
+
+labels = Y;
+#Shuffle the data before minibatch formation 
+imgs_,labels_ = shuffleobs((imgs,labels));
+
+#Normalising the data
+for i in 1:length(imgs)
+    imgs[i] = Flux.normalise(imgs[i],dims=2)
+end
+
+#Use 85% of the total data as train data and rest as test data
+train_X,train_Y = img_[1:1701],labels_[1:1701]
+
+#Since the Spectrogram images of different audio signals will also be different, so they are converted to a common size
+img_size = (256,32)
+m,n = img_size
+
+#Function for minibatch formation
+function make_minibatch(X,Y,idxs)
+    X_batch = Array{Float32}(undef,(img_size)..., 1, length(idxs)) #Declaring an array of images as a batch 
+    for i in 1:length(idxs)
+        img = Float32.(imresize((X[idxs[i]]),(img_size)...))#Resize the image
+        X_batch[:, :, :, i] = img
+    end
+    Y_batch = onehotbatch(Y[idxs], 0:9) #Onehot encode the labels
+    return (X_batch, Y_batch)
+end
+
+
+#Dividing the data into minibatches
+mb_indices = [] #Array of indices to be loaded as minibatches
+batch_size = 32
+for i in range(1,length(train_Y)-1,step = batch_size)
+    idxs = []
+    for j in i:i+batch_size-1
+        push!(idxs,j)
+    end
+    push!(mb_indices,idxs)
+end
+train_set = [make_minibatch(train_X,train_Y,mb_indices[i]) for i in 1:(size(mb_indices)[1]-1)];
+
+#Test data as a single batch
+batch_size=300
+ind = []
+for i in 1701:2000
+    push!(ind,i)
+end
+test_set = [make_minibatch(imgs_,labels_,ind)];
+
+@info("Constructing model...")
+model = Chain(
+    # First convolution, operating upon a m*n image
+    Conv((3, 3), 1=>64, pad=(1,1), relu),
+    MaxPool((2,2)),
+    BatchNorm(64,relu),
+
+    # Second convolution, operating upon a m/2*n/2 image
+    Conv((3, 3), 64=>32, pad=(1,1), relu),
+    MaxPool((2,2)),
+    BatchNorm(32,relu),
+    Dropout(0.10),
+    
+    # Reshape 3d tensor into a 2d one, at this point it should be (m/4,n/4,32, N)
+    # which is where we get the 2048 in the `Dense` layer below:
+    x -> reshape(x, :, size(x, 4)),
+    Dense(Int(floor(m/4)*floor(n/4)*32), 128,relu),
+    
+    Dense(128,10),
+
+    # Finally, softmax to get nice probabilities
+    softmax,
+)
+
+function loss(x, y)
+    # We augment `x` a little bit here, adding in random noise
+    x_aug = x .+ 0.1f0*(randn(eltype(x), size(x)))
+
+    y_hat = model(x_aug)
+    return crossentropy(y_hat, y)
+end
+#Accuracy function
+accuracy(x, y) = mean(onecold(model(x)) .== onecold(y))
+
+#Training the data
+opt = ADAM(0.001)
+epochs = 15
+
+@info("Beginning training loop...")
+best_acc = 0.0
+last_improvement = 0
+for epoch_idx in 1:epochs
+    global best_acc, last_improvement
+    # Train for a single epoch
+    Flux.train!(loss, params(model), train_set, opt)
+    x,y = train_set[1] 
+    print("Epoch[$epoch_idx]: Train_Loss: ",loss(x,y),"\n")
+    
+    # Calculate accuracy:
+    acc = accuracy(test_set[1]...)
+    @info(@sprintf("[%d]: Test accuracy: %.4f", epoch_idx, acc))
+
+    # If our accuracy is good enough, quit out.
+    if acc >= 0.95
+        @info(" -> Early-exiting: We reached our target accuracy of 95.0%")
+        break
+    end
+
+    # If this is the best accuracy we've seen so far, save the model out
+    if acc >= best_acc
+        @info(" -> New best accuracy! Saving model out to MNIST_Speech.bson") #Here, model is saved as MNIST_Speech.bson        
+        BSON.@save joinpath(dirname(@__FILE__), "./MNIST_Speech.bson") model epoch_idx acc
+        best_acc = acc
+        last_improvement = epoch_idx
+    end
+
+    # If we haven't seen improvement in 5 epochs, drop our learning rate:
+    if epoch_idx - last_improvement >= 5 && opt.eta > 1e-4
+        opt.eta /= 10.0
+        @warn(" -> Haven't improved in a while, dropping learning rate to $(opt.eta)!")
+
+        # After dropping learning rate, give it a few epochs to improve
+        last_improvement = epoch_idx
+    end
+
+    if epoch_idx - last_improvement >= 10
+        @warn(" -> We're calling this converged.")
+        break
+    end
+end
+
+
diff --git a/contrib/audio/Spoken_Digit_Recognition/Test_Reproducability.ipynb b/contrib/audio/Spoken_Digit_Recognition/Test_Reproducability.ipynb
new file mode 100644
index 000000000..91ebee3b0
--- /dev/null
+++ b/contrib/audio/Spoken_Digit_Recognition/Test_Reproducability.ipynb
@@ -0,0 +1,303 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Testing Model Reproducibility\n",
+    "Test whether the results are reproducible or not using the same dataset and trained model weights"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "using DSP,WAV\n",
+    "using PyCall\n",
+    "using PyPlot\n",
+    "using MFCC\n",
+    "using FFTW\n",
+    "using Flux\n",
+    "using Printf,BSON\n",
+    "using Flux: onehotbatch, onecold, crossentropy, throttle, Conv,relu\n",
+    "using Base.Iterators: partition\n",
+    "using StatsBase\n",
+    "using MLLabelUtils,MLDataPattern\n",
+    "IpY = pyimport(\"IPython\")\n",
+    "using Images,MLBase\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Loading the data\n",
+    "We will be testing our model on the same dataset. Thouh different audio data can also be tried "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "cd(\"./Downloads\")   # Or the path of folder containing the dataset Folder(Spoken_Digit) after extraction\n",
+    "A = readdir(\"./Spoken_Digit/recordings\")\n",
+    "cd(\"./Spoken_Digit/recordings\")\n",
+    "X = []\n",
+    "X_fs = []\n",
+    "Y = []\n",
+    "for i in 1:length(A)\n",
+    "    s,fs = wavread(A[i])\n",
+    "    push!(X,s)\n",
+    "    push!(X_fs,fs)\n",
+    "    push!(Y,Int(A[i][1]-'0'))\n",
+    "end\n",
+    "cd(\"./../../\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Data Preprocessing\n",
+    "Similar to training data we will change audio files to spectrogram, normalise the data and then use that as test set. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "imgs = []\n",
+    "for i in 1:length(X)\n",
+    "    b = spectrogram(X[i][:,1])\n",
+    "    push!(imgs,b.power)\n",
+    "end\n",
+    "labels = Y;\n",
+    "for i in 1:length(imgs)\n",
+    "    imgs[i] = Flux.normalise(imgs[i],dims=2)\n",
+    "end\n",
+    "\n",
+    "imgs_,labels_ = shuffleobs((imgs,labels));"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Loading the complete data as a single minibatch to test the model performance on the data as a whole"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "make_minibatch (generic function with 1 method)"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "img_size = (256,32)\n",
+    "m,n = img_size\n",
+    "\n",
+    "function make_minibatch(X,Y,idxs)\n",
+    "    X_batch = Array{Float32}(undef,(img_size)..., 1, length(idxs))\n",
+    "    for i in 1:length(idxs)\n",
+    "        img = Float32.(imresize((X[idxs[i]]),(img_size)...))\n",
+    "        X_batch[:, :, :, i] = img\n",
+    "    end\n",
+    "    Y_batch = onehotbatch(Y[idxs], 0:9)\n",
+    "    return (X_batch, Y_batch)\n",
+    "end"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Take any random small chunk from the dataset for testing"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "mb_indices = [] \n",
+    "ind = []\n",
+    "for i in 500:800\n",
+    "    push!(ind,i)\n",
+    "end\n",
+    "test_set = [make_minibatch(imgs_,labels_,ind)];"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "accuracy (generic function with 1 method)"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "accuracy(x, y) = mean(onecold(model(x)) .== onecold(y))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Model Performance Testing of Trained Model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#Model evaluation on Training Data\n",
+    "BSON.@load \"./MNIST_Speech.bson\" model\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0.9833887043189369"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "accuracy(test_set[1]...)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "10×301 Array{Float32,2}:\n",
+       " 3.8437e-13   1.91665e-9   1.57188e-7   …  1.43238e-6   2.79504e-8 \n",
+       " 4.82582e-9   0.999623     0.000236523     2.06655e-8   0.000121791\n",
+       " 4.39358e-7   5.5426e-9    0.000238135     0.000882037  0.00011656 \n",
+       " 3.30992e-11  7.50751e-9   6.39884e-6      2.86941e-5   3.69492e-5 \n",
+       " 0.999999     1.28694e-6   0.995579        0.000281947  0.999325   \n",
+       " 9.67511e-7   8.0464e-5    0.00353203   …  8.95394e-9   0.000340723\n",
+       " 3.90226e-10  1.40138e-9   0.000303763     0.998564     5.52701e-5 \n",
+       " 4.46966e-11  7.38176e-8   2.74527e-5      8.30553e-8   2.76701e-6 \n",
+       " 2.86833e-11  1.60256e-9   6.0581e-5       0.000241771  8.11351e-8 \n",
+       " 2.36902e-11  0.000294738  1.61166e-5      3.64062e-10  6.61961e-7 "
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "y_label = model(test_set[1][1])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Confusion Matrix:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "10×10 Array{Int64,2}:\n",
+       " 28   0   0   0   0   0   0   0   0   0\n",
+       "  0  32   0   0   0   0   0   0   0   0\n",
+       "  0   0  24   0   0   0   0   0   0   0\n",
+       "  0   0   0  27   0   0   0   0   0   0\n",
+       "  0   0   0   0  35   0   0   0   0   0\n",
+       "  0   0   0   0   0  28   0   0   0   1\n",
+       "  0   0   0   0   0   0  26   0   0   0\n",
+       "  0   0   0   0   0   0   0  27   0   0\n",
+       "  0   0   0   1   1   0   1   0  32   0\n",
+       "  0   0   0   0   0   0   0   1   0  37"
+      ]
+     },
+     "execution_count": 29,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "y_true = onecold(test_set[1][2])\n",
+    "y_pred = onecold(y_label)\n",
+    "\n",
+    "MLBase.confusmat(10,y_true,y_pred)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "accelerator": "GPU",
+  "colab": {
+   "name": "Untitled.ipynb",
+   "provenance": [],
+   "version": "0.3.2"
+  },
+  "kernelspec": {
+   "display_name": "Julia 1.3.1",
+   "language": "julia",
+   "name": "julia-1.3"
+  },
+  "language_info": {
+   "file_extension": ".jl",
+   "mimetype": "application/julia",
+   "name": "julia",
+   "version": "1.3.1"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 1
+}
diff --git a/contrib/audio/Spoken_Digit_Recognition/Tutorial.ipynb b/contrib/audio/Spoken_Digit_Recognition/Tutorial.ipynb
new file mode 100644
index 000000000..4ce84460f
--- /dev/null
+++ b/contrib/audio/Spoken_Digit_Recognition/Tutorial.ipynb
@@ -0,0 +1,1040 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Spoken Digit Recognition\n",
+    "Let's have a walk through on using Julia for Spoken Digit Recognition. Here, we will use CNN model on the spectrogram values to predict the Digit.<br>\n",
+    "We begin with importing all the important packages"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "┌ Info: CUDAdrv.jl failed to initialize, GPU functionality unavailable (set JULIA_CUDA_SILENT or JULIA_CUDA_VERBOSE to silence or expand this message)\n",
+      "└ @ CUDAdrv /home/blackforest/.julia/packages/CUDAdrv/mCr0O/src/CUDAdrv.jl:69\n",
+      "WARNING: using StatsBase.crossentropy in module Main conflicts with an existing identifier.\n"
+     ]
+    }
+   ],
+   "source": [
+    "using DSP,WAV\n",
+    "using PyCall\n",
+    "using PyPlot\n",
+    "using MFCC\n",
+    "using FFTW\n",
+    "using Flux\n",
+    "using Printf,BSON\n",
+    "using Flux: onehotbatch, onecold, crossentropy, throttle, Conv,relu\n",
+    "using Base.Iterators: partition\n",
+    "using StatsBase\n",
+    "using MLLabelUtils,MLDataPattern\n",
+    "IpY = pyimport(\"IPython\")\n",
+    "using Images\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Loading the Data\n",
+    "Once we have imported the packages, let's load the data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "cd(\"./Downloads\")\n",
+    "A = readdir(\"./Spoken_Digit/recordings\")\n",
+    "cd(\"./Spoken_Digit/recordings\")\n",
+    "X = []\n",
+    "X_fs = []\n",
+    "Y = []\n",
+    "for i in 1:length(A)\n",
+    "    s,fs = wavread(A[i])\n",
+    "    push!(X,s)\n",
+    "    push!(X_fs,fs)\n",
+    "    push!(Y,Int(A[i][1]-'0'))\n",
+    "end\n",
+    "cd(\"./../../\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Analysing the Data"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Let's first listen to the what these audio WAV files contain. For this, we will use here, IPython.display.Audio. In order "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "PyObject <module 'IPython' from '/home/blackforest/.julia/conda/3/lib/python3.7/site-packages/IPython/__init__.py'>"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "IpY = pyimport(\"IPython\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "\n",
+       "                <audio  controls=\"controls\" >\n",
+       "                    <source src=\"data:audio/x-wav;base64,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\" type=\"audio/x-wav\" />\n",
+       "                    Your browser does not support the audio element.\n",
+       "                </audio>\n",
+       "              "
+      ],
+      "text/plain": [
+       "PyObject <IPython.lib.display.Audio object>"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "┌ Warning: `getindex(o::PyObject, s::AbstractString)` is deprecated in favor of dot overloading (`getproperty`) so elements should now be accessed as e.g. `o.\"s\"` instead of `o[\"s\"]`.\n",
+      "│   caller = show(::IOContext{Base.GenericIOBuffer{Array{UInt8,1}}}, ::MIME{Symbol(\"text/html\")}, ::PyObject) at PyCall.jl:895\n",
+      "└ @ PyCall /home/blackforest/.julia/packages/PyCall/ttONZ/src/PyCall.jl:895\n"
+     ]
+    }
+   ],
+   "source": [
+    "IpY.display.Audio(A[453])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Hmm, that does sound like two. So, similar kind of audio data, we need to classify through our model. Before going into building the model, first pre-analyse the audio files\n",
+    "<br>\n",
+    "First, let's plot our data to see what it looks like.  "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "Figure(PyObject <Figure size 640x480 with 1 Axes>)"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "1-element Array{PyObject,1}:\n",
+       " PyObject <matplotlib.lines.Line2D object at 0x7f6a702369d0>"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "PyPlot.plot(X[1])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "How about an FFT plot?"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "Figure(PyObject <Figure size 640x480 with 1 Axes>)"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "1-element Array{PyObject,1}:\n",
+       " PyObject <matplotlib.lines.Line2D object at 0x7f6a4f78e7d0>"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "PyPlot.plot(fft(X[1]))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now, we will plot the spectrogram of the audio file zero"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "Figure(PyObject <Figure size 640x480 with 1 Axes>)"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "([5.921396503211639e-11 6.144594757755415e-10 … 8.451382701637563e-12 1.756504456288814e-12; 1.8568523198236493e-9 1.0536784714698365e-8 … 2.8469931152361586e-9 5.448721894513743e-10; … ; 1.9158576126187585e-11 1.5013662229371582e-10 … 5.123048834666636e-12 1.0419974773609225e-11; 4.380290940223674e-12 6.62498304638197e-11 … 7.044207901278974e-13 1.4417284840034432e-12], [0.0, 31.25, 62.5, 93.75, 125.0, 156.25, 187.5, 218.75, 250.0, 281.25  …  3718.75, 3750.0, 3781.25, 3812.5, 3843.75, 3875.0, 3906.25, 3937.5, 3968.75, 4000.0], [0.016, 0.032, 0.048, 0.064, 0.08, 0.096, 0.112, 0.128, 0.144, 0.16  …  0.48, 0.496, 0.512, 0.528, 0.544, 0.56, 0.576, 0.592, 0.608, 0.624], PyObject <matplotlib.image.AxesImage object at 0x7f6a4f7b4d10>)"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "c = PyPlot.specgram(X[1][:,1],Fs = X_fs[1])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We will use here, spectrogram function of the DSP.jl to calculate the spectrogram values of the given audio files"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "DSP.Periodograms.Spectrogram{Float64,AbstractFFTs.Frequencies{Float64}}([1.1931071772691992e-5 1.2794204112795591e-5 … 8.094883618521913e-6 3.1319986816039646e-7; 2.8106639028433923e-5 5.084930866656072e-5 … 1.2141545106504503e-5 3.206747897719205e-6; … ; 5.1947719534789895e-6 3.854394968184458e-5 … 3.116387268187047e-7 5.890268409838297e-7; 1.0890568868333794e-5 1.4311608044292973e-6 … 8.204829844873038e-8 9.867262443729622e-8], [0.0, 0.0015432098765432098, 0.0030864197530864196, 0.004629629629629629, 0.006172839506172839, 0.007716049382716049, 0.009259259259259259, 0.010802469135802469, 0.012345679012345678, 0.013888888888888888  …  0.4861111111111111, 0.48765432098765427, 0.4891975308641975, 0.4907407407407407, 0.4922839506172839, 0.49382716049382713, 0.49537037037037035, 0.49691358024691357, 0.4984567901234568, 0.5], 321.5:322.0:4507.5)"
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "Y1_spec = spectrogram(X[1][:,1])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(:power, :freq, :time)"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "fieldnames(typeof(Y1_spec))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "What it returns? It basically returns us the an array of power values in a timeframe of audio over different frequencies"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "325×14 Array{Float64,2}:\n",
+       " 1.19311e-5   1.27942e-5   0.00011184   …  8.09488e-6   3.132e-7   \n",
+       " 2.81066e-5   5.08493e-5   0.000233652     1.21415e-5   3.20675e-6 \n",
+       " 4.0484e-5    0.000131717  0.000272207     1.73776e-5   7.20905e-6 \n",
+       " 6.07955e-5   0.000288517  0.000365978     1.14003e-5   1.46983e-5 \n",
+       " 0.000143712  0.000636645  0.00057366      2.13868e-6   4.70806e-5 \n",
+       " 0.000151799  0.000645508  0.000853296  …  0.00012986   1.36235e-5 \n",
+       " 0.000532065  0.00209559   0.00180169      2.45591e-5   1.48478e-5 \n",
+       " 0.00170353   0.00590174   0.00495622      0.000241027  0.000286993\n",
+       " 0.0141123    0.039983     0.0309246       0.00337389   0.0041309  \n",
+       " 0.260717     0.247433     0.247253        0.0691463    0.0274001  \n",
+       " 0.0209742    0.0233435    0.0205739    …  0.00312731   0.0129292  \n",
+       " 0.0031157    0.00721872   0.0106745       0.000916135  0.0025006  \n",
+       " 0.00265383   0.00263328   0.00643533      0.00131455   0.00261374 \n",
+       " ⋮                                      ⋱                          \n",
+       " 7.07666e-8   9.66128e-5   6.4111e-5       1.96808e-7   1.016e-6   \n",
+       " 9.62174e-6   5.79443e-5   8.89168e-5      8.37519e-8   2.48709e-7 \n",
+       " 1.96166e-6   5.70858e-7   2.52865e-5   …  4.86845e-7   2.51407e-7 \n",
+       " 2.97862e-6   5.49076e-6   0.000142155     3.25063e-7   3.7205e-7  \n",
+       " 1.20512e-5   5.46596e-6   4.24111e-5      7.01023e-7   7.32593e-7 \n",
+       " 3.61834e-6   9.55499e-6   0.00019572      9.9248e-7    1.72722e-7 \n",
+       " 3.73843e-6   7.71323e-5   8.17831e-5      1.00604e-6   7.68411e-7 \n",
+       " 4.92912e-7   2.97574e-5   3.97462e-5   …  1.4376e-7    3.09651e-7 \n",
+       " 7.55749e-7   5.81224e-6   1.39426e-5      3.78868e-7   7.33412e-7 \n",
+       " 1.59308e-6   6.75469e-5   7.42301e-5      4.35238e-7   1.09979e-6 \n",
+       " 5.19477e-6   3.85439e-5   7.91456e-5      3.11639e-7   5.89027e-7 \n",
+       " 1.08906e-5   1.43116e-6   0.000109007     8.20483e-8   9.86726e-8 "
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "Y1_spec.power"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Data Preprocessing\n",
+    "As discussed above, we will be using spectrogram values of the audio files as input to our CNN model. Let's generate the spectrograms of all the audio files. Here,we will be using the power values of the spectrogram as out image data at different frequencies"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "imgs = []\n",
+    "for i in 1:length(X)\n",
+    "    b = spectrogram(X[i][:,1])\n",
+    "    push!(imgs,b.power)\n",
+    "end"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "labels = Y;"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "As our data is arranged in order,we first need to shuffle the data."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Normalising the data\n",
+    "Normalising plays a very crucial role in easy convergence of the data, otherwise there are more chances of the model getting stuck in the local optimum. So we will normalise the data."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "for i in 1:length(imgs)\n",
+    "    imgs[i] = Flux.normalise(imgs[i],dims=2)\n",
+    "end"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "imgs_,labels_ = shuffleobs((imgs,labels));"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now, we will use only 85% of the data as our training data in this example. And the rest of the data, we will use to test our model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "train_X,train_Y = imgs_[1:1701],labels_[1:1701];"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Our spectrogram values will be of different sizes. So we need to change them to into a common size before making batches. So here, we will be resizing spectrograms to image size of (256,32). It is preferable not to keep the size too small, as otherwise while shrinking the size, some data may get lost. Also very large size is not preferrable as it will consequently increase the traning time. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(256, 32)"
+      ]
+     },
+     "execution_count": 23,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "img_size = (256,32)\n",
+    "m,n = img_size"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Using the following function, we will divide the array into minibatches along with resizing the images to the required shape."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "make_minibatch (generic function with 1 method)"
+      ]
+     },
+     "execution_count": 24,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "function make_minibatch(X,Y,idxs)\n",
+    "    X_batch = Array{Float32}(undef,(img_size)..., 1, length(idxs))\n",
+    "    for i in 1:length(idxs)\n",
+    "        img = Float32.(imresize((X[idxs[i]]),(img_size)...))\n",
+    "        X_batch[:, :, :, i] = img\n",
+    "    end\n",
+    "    Y_batch = onehotbatch(Y[idxs], 0:9)\n",
+    "    return (X_batch, Y_batch)\n",
+    "end"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Note that here we are using a batch size of 32, that seems reasonable in this case as the training data size is 1700 which isn't that big. So, batch_size of 32 seems to be an appropriate choice"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "mb_indices = [] \n",
+    "batch_size = 32\n",
+    "\n",
+    "for i in range(1,length(train_Y)-1,step = batch_size)\n",
+    "    idxs = []\n",
+    "    for j in i:i+batch_size-1\n",
+    "        push!(idxs,j)\n",
+    "    end\n",
+    "    push!(mb_indices,idxs)\n",
+    "end\n",
+    "train_set = [make_minibatch(train_X,train_Y,mb_indices[i]) for i in 1:(size(mb_indices)[1]-1)];"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(256, 32, 1, 32)"
+      ]
+     },
+     "execution_count": 26,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "size(train_set[1][1])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We will be supplying our whole test data as a single batch. So let's create our test set"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "batch_size=300\n",
+    "ind = []\n",
+    "for i in 1701:2000\n",
+    "    push!(ind,i)\n",
+    "end\n",
+    "test_set = [make_minibatch(imgs_,labels_,ind)];"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Model\n",
+    "Once, we are done pre-processing tha data and our data is ready to get the model trained, its time to create our model."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "┌ Info: Constructing model...\n",
+      "└ @ Main In[36]:1\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "Chain(Conv((3, 3), 1=>64, relu), MaxPool((2, 2), pad = (0, 0, 0, 0), stride = (2, 2)), BatchNorm(64, λ = relu), Conv((3, 3), 64=>32, relu), MaxPool((2, 2), pad = (0, 0, 0, 0), stride = (2, 2)), BatchNorm(32, λ = relu), Dropout(0.1), #7, Dense(16384, 128, relu), Dense(128, 10), softmax)"
+      ]
+     },
+     "execution_count": 36,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "@info(\"Constructing model...\")\n",
+    "model = Chain(\n",
+    "    # First convolution, operating upon a m*n image\n",
+    "    Conv((3, 3), 1=>64, pad=(1,1), relu),\n",
+    "    MaxPool((2,2)),\n",
+    "    BatchNorm(64,relu),\n",
+    "\n",
+    "    # Second convolution, operating upon a m/2*n/2 image\n",
+    "    Conv((3, 3), 64=>32, pad=(1,1), relu),\n",
+    "    MaxPool((2,2)),\n",
+    "    BatchNorm(32,relu),\n",
+    "    Dropout(0.10),\n",
+    "    \n",
+    "    # Reshape 3d tensor into a 2d one, at this point it should be (m/4,n/4,32, N)\n",
+    "    # which is where we get the 2048 in the `Dense` layer below:\n",
+    "    x -> reshape(x, :, size(x, 4)),\n",
+    "    Dense(Int(floor(m/4)*floor(n/4)*32), 128,relu),\n",
+    "    \n",
+    "    Dense(128,10),\n",
+    "\n",
+    "    # Finally, softmax to get nice probabilities\n",
+    "    softmax,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "In this model, we will use crossentropy loss. While calculating loss, we will simply add some random noise to our data, so as to prevent the overfitting"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 37,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "accuracy (generic function with 1 method)"
+      ]
+     },
+     "execution_count": 37,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "function loss(x, y)\n",
+    "    # We augment `x` a little bit here, adding in random noise\n",
+    "    x_aug = x .+ 0.1f0*(randn(eltype(x), size(x)))\n",
+    "\n",
+    "    y_hat = model(x_aug)\n",
+    "    return crossentropy(y_hat, y)\n",
+    "end\n",
+    "accuracy(x, y) = mean(onecold(model(x)) .== onecold(y))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "What is accuracy before training the model?????<br>\n",
+    "Let's check......."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 38,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0.08333333333333333"
+      ]
+     },
+     "execution_count": 38,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "accuracy(test_set[1]...)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Training\n",
+    "Let's begin training our model. We will use ere ADAM optimiser with a learning rate of 0.001. We will train our model for 15 epochs"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 39,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "┌ Info: Beginning training loop...\n",
+      "└ @ Main In[39]:4\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch[1]: Train_Loss: 0.39074132\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "┌ Info: [1]: Test accuracy: 0.6767\n",
+      "└ @ Main In[39]:16\n",
+      "┌ Info:  -> New best accuracy! Saving model out to MNIST_Speech.bson\n",
+      "└ @ Main In[39]:26\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch[2]: Train_Loss: 0.013040102\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "┌ Info: [2]: Test accuracy: 0.8567\n",
+      "└ @ Main In[39]:16\n",
+      "┌ Info:  -> New best accuracy! Saving model out to MNIST_Speech.bson\n",
+      "└ @ Main In[39]:26\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch[3]: Train_Loss: 0.033996206\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "┌ Info: [3]: Test accuracy: 0.8600\n",
+      "└ @ Main In[39]:16\n",
+      "┌ Info:  -> New best accuracy! Saving model out to MNIST_Speech.bson\n",
+      "└ @ Main In[39]:26\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch[4]: Train_Loss: 0.0029821368\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "┌ Info: [4]: Test accuracy: 0.9200\n",
+      "└ @ Main In[39]:16\n",
+      "┌ Info:  -> New best accuracy! Saving model out to MNIST_Speech.bson\n",
+      "└ @ Main In[39]:26\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch[5]: Train_Loss: 0.0010024133\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "┌ Info: [5]: Test accuracy: 0.9167\n",
+      "└ @ Main In[39]:16\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch[6]: Train_Loss: 0.00067962485\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "┌ Info: [6]: Test accuracy: 0.9200\n",
+      "└ @ Main In[39]:16\n",
+      "┌ Info:  -> New best accuracy! Saving model out to MNIST_Speech.bson\n",
+      "└ @ Main In[39]:26\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch[7]: Train_Loss: 0.0005679158\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "┌ Info: [7]: Test accuracy: 0.9233\n",
+      "└ @ Main In[39]:16\n",
+      "┌ Info:  -> New best accuracy! Saving model out to MNIST_Speech.bson\n",
+      "└ @ Main In[39]:26\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch[8]: Train_Loss: 0.00038421655\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "┌ Info: [8]: Test accuracy: 0.9233\n",
+      "└ @ Main In[39]:16\n",
+      "┌ Info:  -> New best accuracy! Saving model out to MNIST_Speech.bson\n",
+      "└ @ Main In[39]:26\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch[9]: Train_Loss: 0.00037415794\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "┌ Info: [9]: Test accuracy: 0.9233\n",
+      "└ @ Main In[39]:16\n",
+      "┌ Info:  -> New best accuracy! Saving model out to MNIST_Speech.bson\n",
+      "└ @ Main In[39]:26\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch[10]: Train_Loss: 0.00028696572\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "┌ Info: [10]: Test accuracy: 0.9233\n",
+      "└ @ Main In[39]:16\n",
+      "┌ Info:  -> New best accuracy! Saving model out to MNIST_Speech.bson\n",
+      "└ @ Main In[39]:26\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch[11]: Train_Loss: 0.00027806658\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "┌ Info: [11]: Test accuracy: 0.9267\n",
+      "└ @ Main In[39]:16\n",
+      "┌ Info:  -> New best accuracy! Saving model out to MNIST_Speech.bson\n",
+      "└ @ Main In[39]:26\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch[12]: Train_Loss: 0.00019297587\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "┌ Info: [12]: Test accuracy: 0.9267\n",
+      "└ @ Main In[39]:16\n",
+      "┌ Info:  -> New best accuracy! Saving model out to MNIST_Speech.bson\n",
+      "└ @ Main In[39]:26\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch[13]: Train_Loss: 0.00020029144\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "┌ Info: [13]: Test accuracy: 0.9267\n",
+      "└ @ Main In[39]:16\n",
+      "┌ Info:  -> New best accuracy! Saving model out to MNIST_Speech.bson\n",
+      "└ @ Main In[39]:26\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch[14]: Train_Loss: 0.00018595633\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "┌ Info: [14]: Test accuracy: 0.9233\n",
+      "└ @ Main In[39]:16\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch[15]: Train_Loss: 0.00021959198\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "┌ Info: [15]: Test accuracy: 0.9233\n",
+      "└ @ Main In[39]:16\n"
+     ]
+    }
+   ],
+   "source": [
+    "opt = ADAM(0.001)\n",
+    "epochs = 15\n",
+    "\n",
+    "@info(\"Beginning training loop...\")\n",
+    "best_acc = 0.0\n",
+    "last_improvement = 0\n",
+    "for epoch_idx in 1:epochs\n",
+    "    global best_acc, last_improvement\n",
+    "    # Train for a single epoch\n",
+    "    Flux.train!(loss, params(model), train_set, opt)\n",
+    "    x,y = train_set[1] \n",
+    "    print(\"Epoch[$epoch_idx]: Train_Loss: \",loss(x,y),\"\\n\")\n",
+    "    \n",
+    "    # Calculate accuracy:\n",
+    "    acc = accuracy(test_set[1]...)\n",
+    "    @info(@sprintf(\"[%d]: Test accuracy: %.4f\", epoch_idx, acc))\n",
+    "\n",
+    "    # If our accuracy is good enough, quit out.\n",
+    "    if acc >= 0.95\n",
+    "        @info(\" -> Early-exiting: We reached our target accuracy of 95.0%\")\n",
+    "        break\n",
+    "    end\n",
+    "\n",
+    "    # If this is the best accuracy we've seen so far, save the model out\n",
+    "    if acc >= best_acc\n",
+    "        @info(\" -> New best accuracy! Saving model out to MNIST_Speech.bson\") #Here, model is saved as MNIST_Speech.bson        \n",
+    "        BSON.@save joinpath(dirname(@__FILE__), \"./MNIST_Speech.bson\") model epoch_idx acc\n",
+    "        best_acc = acc\n",
+    "        last_improvement = epoch_idx\n",
+    "    end\n",
+    "\n",
+    "    # If we haven't seen improvement in 5 epochs, drop our learning rate:\n",
+    "    if epoch_idx - last_improvement >= 5 && opt.eta > 1e-4\n",
+    "        opt.eta /= 10.0\n",
+    "        @warn(\" -> Haven't improved in a while, dropping learning rate to $(opt.eta)!\")\n",
+    "\n",
+    "        # After dropping learning rate, give it a few epochs to improve\n",
+    "        last_improvement = epoch_idx\n",
+    "    end\n",
+    "\n",
+    "    if epoch_idx - last_improvement >= 10\n",
+    "        @warn(\" -> We're calling this converged.\")\n",
+    "        break\n",
+    "    end\n",
+    "end"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now our model is trained and ready to be tested"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Julia 1.3.1",
+   "language": "julia",
+   "name": "julia-1.3"
+  },
+  "language_info": {
+   "file_extension": ".jl",
+   "mimetype": "application/julia",
+   "name": "julia",
+   "version": "1.3.1"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}