From 3ce85e539f974189380802eec151fb822684a8dc Mon Sep 17 00:00:00 2001 From: Dheeraj Mohan Date: Thu, 15 Aug 2019 22:27:37 +0530 Subject: [PATCH] Feat: Implement Dropout in Gluon Changes to be committed: modified: DropOutScratch.ipynb new file: DropoutGluon.ipynb --- DropOutScratch.ipynb | 23 +++--- DropoutGluon.ipynb | 183 +++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 197 insertions(+), 9 deletions(-) create mode 100644 DropoutGluon.ipynb diff --git a/DropOutScratch.ipynb b/DropOutScratch.ipynb index 6defc37..79fc607 100644 --- a/DropOutScratch.ipynb +++ b/DropOutScratch.ipynb @@ -143,7 +143,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 33, "metadata": {}, "outputs": [], "source": [ @@ -152,30 +152,35 @@ "num_inputs = 28*28\n", "num_hidden1, num_hidden2 = 256, 256\n", "num_output = 10\n", - "drop_probs = [0.0, 0.0]\n", + "drop_probs = [0.2, 0.5]\n", "\n", "params = init_params(num_inputs, num_hidden1, num_hidden2, num_output)" ] }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 35, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Epoch 0, acc: 0.798250 loss: 0.545852\n", - "Epoch 1, acc: 0.827333 loss: 0.483884\n", - "Epoch 2, acc: 0.840633 loss: 0.448361\n", - "Epoch 3, acc: 0.854817 loss: 0.406807\n", - "Epoch 4, acc: 0.861367 loss: 0.389544\n" + "Epoch 0, acc: 0.843933 loss: 0.449781\n", + "Epoch 1, acc: 0.849133 loss: 0.423806\n", + "Epoch 2, acc: 0.853700 loss: 0.407548\n", + "Epoch 3, acc: 0.857400 loss: 0.393078\n", + "Epoch 4, acc: 0.865700 loss: 0.377074\n", + "Epoch 5, acc: 0.869967 loss: 0.364002\n", + "Epoch 6, acc: 0.872833 loss: 0.356155\n", + "Epoch 7, acc: 0.871917 loss: 0.355115\n", + "Epoch 8, acc: 0.874833 loss: 0.346407\n", + "Epoch 9, acc: 0.881317 loss: 0.328503\n" ] } ], "source": [ - "epochs = 5\n", + "epochs = 10\n", "lr = 0.1\n", "loss = gluon.loss.SoftmaxCrossEntropyLoss()\n", "for epoch in range(epochs):\n", diff --git a/DropoutGluon.ipynb b/DropoutGluon.ipynb new file mode 100644 index 0000000..b950322 --- /dev/null +++ b/DropoutGluon.ipynb @@ -0,0 +1,183 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "from mxnet import nd, autograd, gluon, init\n", + "from mxnet.gluon import nn\n", + "from mxnet.gluon.data.vision import transforms" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "def get_dataloader(batch_size):\n", + " transformer = transforms.Compose([\n", + " transforms.ToTensor()\n", + " ])\n", + " train = gluon.data.vision.datasets.FashionMNIST(train=True)\n", + " train = train.transform_first(transformer)\n", + " train_iter = gluon.data.DataLoader(train, batch_size, shuffle=True, num_workers=4)\n", + " test = gluon.data.vision.datasets.FashionMNIST(train=False)\n", + " test = test.transform_first(transformer)\n", + " test_iter = gluon.data.DataLoader(test, batch_size, shuffle=False, num_workers=4)\n", + " return train_iter, test_iter" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "def show_images(X, nrows, ncols):\n", + " _, axes = plt.subplots(nrows, ncols)\n", + " axes = axes.flatten()\n", + " for ax, img in zip(axes, X):\n", + " ax.imshow(img)\n", + " ax.get_xaxis().set_visible(False)\n", + " ax.get_yaxis().set_visible(False)\n", + " return axes" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "def softmax(X):\n", + " X_exp = X.exp()\n", + " normalization = X_exp.sum(axis=1, keepdims=True)\n", + " return X_exp / normalization" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "def accuracy(net, data_iter):\n", + " acc = 0\n", + " size = 0\n", + " for X, y in data_iter:\n", + " result = net(X)\n", + " y_hat = softmax(result)\n", + " acc += (y_hat.argmax(axis=1) == y.astype('float32')).sum().asscalar()\n", + " size += len(y)\n", + " return acc / size" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "batch_size = 256\n", + "train_iter, test_iter = get_dataloader(batch_size)\n", + "\n", + "net = nn.Sequential()\n", + "net.add(nn.Dense(256))\n", + "net.add(nn.Dropout(0.2))\n", + "net.add(nn.Dense(256))\n", + "net.add(nn.Dropout(0.5))\n", + "net.add(nn.Dense(10))\n", + "\n", + "net.initialize(init.Normal(0.01))\n", + "\n", + "trainer = gluon.Trainer(net.collect_params(), 'sgd', {'learning_rate':0.1})\n", + "\n", + "loss = gluon.loss.SoftmaxCrossEntropyLoss()" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 0, acc: 0.665200\n", + "Epoch 1, acc: 0.773100\n", + "Epoch 2, acc: 0.803400\n", + "Epoch 3, acc: 0.819400\n", + "Epoch 4, acc: 0.829000\n", + "Epoch 5, acc: 0.828800\n", + "Epoch 6, acc: 0.833100\n", + "Epoch 7, acc: 0.838100\n", + "Epoch 8, acc: 0.840300\n", + "Epoch 9, acc: 0.847100\n" + ] + } + ], + "source": [ + "epochs = 10\n", + "for epoch in range(epochs):\n", + " for X, y in train_iter:\n", + " with autograd.record():\n", + " result = net(X)\n", + " l = loss(result, y)\n", + " l.backward()\n", + " trainer.step(batch_size)\n", + " epoch_acc = accuracy(net, test_iter)\n", + " print(\"Epoch %d, acc: %f\" % (epoch, epoch_acc))" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "for X, y in train_iter:\n", + " show_images(X.squeeze(axis=1).asnumpy(), 2, 5)\n", + " break" + ] + } + ], + "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.6.7" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}