{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "## Convolutional Neural Networks\n", "\n", "CNNs contain convolutional neurons to process the input locally\n", "![CNN](https://cdn-images-1.medium.com/max/1200/1*XbuW8WuRrAY5pC4t-9DZAQ.jpeg)" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "PACKAGES LOADED\n" ] } ], "source": [ "import numpy as np\n", "import tensorflow as tf\n", "import matplotlib.pyplot as plt\n", "from tensorflow.examples.tutorials.mnist import input_data\n", "%matplotlib inline \n", "print (\"PACKAGES LOADED\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Load the data" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "WARNING:tensorflow:From :1: read_data_sets (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n", "Instructions for updating:\n", "Please use alternatives such as official/mnist/dataset.py from tensorflow/models.\n", "WARNING:tensorflow:From /usr/local/lib/python3.5/dist-packages/tensorflow/contrib/learn/python/learn/datasets/mnist.py:260: maybe_download (from tensorflow.contrib.learn.python.learn.datasets.base) is deprecated and will be removed in a future version.\n", "Instructions for updating:\n", "Please write your own downloading logic.\n", "WARNING:tensorflow:From /usr/local/lib/python3.5/dist-packages/tensorflow/contrib/learn/python/learn/datasets/base.py:252: _internal_retry..wrap..wrapped_fn (from tensorflow.contrib.learn.python.learn.datasets.base) is deprecated and will be removed in a future version.\n", "Instructions for updating:\n", "Please use urllib or similar directly.\n", "Successfully downloaded train-images-idx3-ubyte.gz 9912422 bytes.\n", "WARNING:tensorflow:From /usr/local/lib/python3.5/dist-packages/tensorflow/contrib/learn/python/learn/datasets/mnist.py:262: extract_images (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n", "Instructions for updating:\n", "Please use tf.data to implement this functionality.\n", "Extracting data/train-images-idx3-ubyte.gz\n", "Successfully downloaded train-labels-idx1-ubyte.gz 28881 bytes.\n", "WARNING:tensorflow:From /usr/local/lib/python3.5/dist-packages/tensorflow/contrib/learn/python/learn/datasets/mnist.py:267: extract_labels (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n", "Instructions for updating:\n", "Please use tf.data to implement this functionality.\n", "Extracting data/train-labels-idx1-ubyte.gz\n", "WARNING:tensorflow:From /usr/local/lib/python3.5/dist-packages/tensorflow/contrib/learn/python/learn/datasets/mnist.py:110: dense_to_one_hot (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n", "Instructions for updating:\n", "Please use tf.one_hot on tensors.\n", "Successfully downloaded t10k-images-idx3-ubyte.gz 1648877 bytes.\n", "Extracting data/t10k-images-idx3-ubyte.gz\n", "Successfully downloaded t10k-labels-idx1-ubyte.gz 4542 bytes.\n", "Extracting data/t10k-labels-idx1-ubyte.gz\n", "WARNING:tensorflow:From /usr/local/lib/python3.5/dist-packages/tensorflow/contrib/learn/python/learn/datasets/mnist.py:290: DataSet.__init__ (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n", "Instructions for updating:\n", "Please use alternatives such as official/mnist/dataset.py from tensorflow/models.\n", "MNIST ready\n" ] } ], "source": [ "mnist = input_data.read_data_sets('data/', one_hot=True)\n", "trainimg = mnist.train.images\n", "trainlabel = mnist.train.labels\n", "testimg = mnist.test.images\n", "testlabel = mnist.test.labels\n", "print (\"MNIST ready\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Select GPU\n", "\n", "This code is optional, tensorflow selects automatically the first available GPU." ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "device_type = \"/gpu:0\"\n", "tf.set_random_seed(1024)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# CNN structure\n", "\n", "Important: reshape the input into an image\n", "\n", "Standard structure: \n", "Conv. and relu\n", "Pooling (maxpooling)\n", "\n", "Lastly a dense layer for classification" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "WARNING:tensorflow:From /usr/local/lib/python3.5/dist-packages/tensorflow/python/framework/op_def_library.py:263: colocate_with (from tensorflow.python.framework.ops) is deprecated and will be removed in a future version.\n", "Instructions for updating:\n", "Colocations handled automatically by placer.\n", "CNN ready\n" ] } ], "source": [ "with tf.device(device_type): # <= This is optional\n", " n_input = 784\n", " n_output = 10\n", " weights = {\n", " 'wc1': tf.Variable(tf.random_normal([3, 3, 1, 64], stddev=0.1)),\n", " 'wd1': tf.Variable(tf.random_normal([14*14*64, n_output], stddev=0.1))\n", " }\n", " biases = {\n", " 'bc1': tf.Variable(tf.random_normal([64], stddev=0.1)),\n", " 'bd1': tf.Variable(tf.random_normal([n_output], stddev=0.1))\n", " }\n", " def conv_simple(_input, _w, _b):\n", " # Reshape input\n", " _input_r = tf.reshape(_input, shape=[-1, 28, 28, 1])\n", " # Convolution\n", " _conv1 = tf.nn.conv2d(_input_r, _w['wc1'], strides=[1, 1, 1, 1], padding='SAME')\n", " # Add-bias\n", " _conv2 = tf.nn.bias_add(_conv1, _b['bc1'])\n", " # Pass ReLu\n", " _conv3 = tf.nn.relu(_conv2)\n", " # Max-pooling\n", " _pool = tf.nn.max_pool(_conv3, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')\n", " # Vectorize\n", " _dense = tf.reshape(_pool, [-1, _w['wd1'].get_shape().as_list()[0]])\n", " # Fully-connected layer\n", " _out = tf.add(tf.matmul(_dense, _w['wd1']), _b['bd1'])\n", " # Return everything\n", " out = {\n", " 'input_r': _input_r, 'conv1': _conv1, 'conv2': _conv2, 'conv3': _conv3\n", " , 'pool': _pool, 'dense': _dense, 'out': _out\n", " }\n", " return out\n", "print (\"CNN ready\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Hyperparameters" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Network Ready to Go!\n" ] } ], "source": [ "# tf Graph input\n", "x = tf.placeholder(tf.float32, [None, n_input])\n", "y = tf.placeholder(tf.float32, [None, n_output])\n", "# Parameters\n", "learning_rate = 0.001\n", "training_epochs = 10\n", "batch_size = 100\n", "display_step = 1\n", "# Functions! \n", "with tf.device(device_type): # <= This is optional\n", " _pred = conv_simple(x, weights, biases)['out']\n", " #_pred = vgg(x, True)\n", " cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits_v2(logits=_pred, labels=y))\n", " optm = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(cost)\n", " _corr = tf.equal(tf.argmax(_pred,1), tf.argmax(y,1)) # Count corrects\n", " accr = tf.reduce_mean(tf.cast(_corr, tf.float32)) # Accuracy\n", " init = tf.global_variables_initializer()\n", "tf.summary.scalar(\"loss\", cost)\n", "# Create a summary to monitor accuracy tensor\n", "tf.summary.scalar(\"accuracy\", accr)\n", "# Merge all summaries into a single op\n", "merged_summary_op = tf.summary.merge_all()\n", "# Saver \n", "save_step = 1;\n", "savedir = \"nets/\"\n", "saver = tf.train.Saver(max_to_keep=3) \n", "print (\"Network Ready to Go!\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Training the CNN\n", "\n", "After each epoch we check the test accuracy, this is peeking :(\n", "\n", "Task 1: let's create a dev set, and use it to finetune the hyperparameters\n", "\n", "Extra: summary writer helps use to log the training progress. With tensorboard we can check these logs" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "do_train = 1\n", "sess = tf.Session(config=tf.ConfigProto(allow_soft_placement=True))\n", "sess.run(init)" ] }, { "cell_type": "code", "execution_count": 7, "metadata": { "scrolled": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Epoch: 000/010 cost: 0.302629923\n", " Training accuracy: 0.960\n", " Test accuracy: 0.963\n", "Epoch: 001/010 cost: 0.102711883\n", " Training accuracy: 0.990\n", " Test accuracy: 0.975\n", "Epoch: 002/010 cost: 0.072189818\n", " Training accuracy: 0.970\n", " Test accuracy: 0.979\n", "Epoch: 003/010 cost: 0.057310599\n", " Training accuracy: 0.980\n", " Test accuracy: 0.978\n", "WARNING:tensorflow:From /usr/local/lib/python3.5/dist-packages/tensorflow/python/training/saver.py:966: remove_checkpoint (from tensorflow.python.training.checkpoint_management) is deprecated and will be removed in a future version.\n", "Instructions for updating:\n", "Use standard file APIs to delete files with this prefix.\n", "Epoch: 004/010 cost: 0.048718231\n", " Training accuracy: 0.990\n", " Test accuracy: 0.979\n", "Epoch: 005/010 cost: 0.041819848\n", " Training accuracy: 0.970\n", " Test accuracy: 0.981\n", "Epoch: 006/010 cost: 0.036420892\n", " Training accuracy: 0.990\n", " Test accuracy: 0.982\n", "Epoch: 007/010 cost: 0.032380161\n", " Training accuracy: 1.000\n", " Test accuracy: 0.982\n", "Epoch: 008/010 cost: 0.028830059\n", " Training accuracy: 0.980\n", " Test accuracy: 0.983\n", "Epoch: 009/010 cost: 0.025240376\n", " Training accuracy: 0.990\n", " Test accuracy: 0.984\n", "Optimization Finished.\n" ] } ], "source": [ "summary_writer = tf.summary.FileWriter(\"tb_log/\", graph=tf.get_default_graph())\n", "if do_train == 1:\n", " for epoch in range(training_epochs):\n", " avg_cost = 0.\n", " total_batch = int(mnist.train.num_examples/batch_size)\n", " # Loop over all batches\n", " for i in range(total_batch):\n", " batch_xs, batch_ys = mnist.train.next_batch(batch_size)\n", " # Fit training using batch data\n", " _, summary = sess.run([optm, merged_summary_op], feed_dict={x: batch_xs, y: batch_ys})\n", " summary_writer.add_summary(summary, epoch * total_batch + i)\n", " # Compute average loss\n", " avg_cost += sess.run(cost, feed_dict={x: batch_xs, y: batch_ys})/total_batch\n", "\n", " # Display logs per epoch step\n", " if epoch % display_step == 0: \n", " print (\"Epoch: %03d/%03d cost: %.9f\" % (epoch, training_epochs, avg_cost))\n", " train_acc = sess.run(accr, feed_dict={x: batch_xs, y: batch_ys})\n", " print (\" Training accuracy: %.3f\" % (train_acc))\n", " test_acc = sess.run(accr, feed_dict={x: testimg, y: testlabel})\n", " print (\" Test accuracy: %.3f\" % (test_acc))\n", "\n", " # Save Net\n", " if epoch % save_step == 0:\n", " saver.save(sess, \"nets/cnn_mnist_simple.ckpt-\" + str(epoch))\n", " print (\"Optimization Finished.\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Tensorboard usage\n", "\n", "To use tensorbouard open the 6006 port in the firewall rules \n", "\n", "then in an ssh console: tensorboard --logdir=tb_log" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Restoring a model" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "WARNING:tensorflow:From /usr/local/lib/python3.5/dist-packages/tensorflow/python/training/saver.py:1266: checkpoint_exists (from tensorflow.python.training.checkpoint_management) is deprecated and will be removed in a future version.\n", "Instructions for updating:\n", "Use standard file APIs to check for files with this prefix.\n", "INFO:tensorflow:Restoring parameters from nets/cnn_mnist_simple.ckpt-9\n", "NETWORK RESTORED\n" ] } ], "source": [ "epoch = training_epochs-1\n", "saver.restore(sess, \"nets/cnn_mnist_simple.ckpt-\" + str(epoch))\n", "print (\"NETWORK RESTORED\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Let's see what is inside the CNN!" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [], "source": [ "with tf.device(device_type):\n", " conv_out = conv_simple(x, weights, biases)\n", "\n", "input_r = sess.run(conv_out['input_r'], feed_dict={x: trainimg[0:1, :]})\n", "conv1 = sess.run(conv_out['conv1'], feed_dict={x: trainimg[0:1, :]})\n", "conv2 = sess.run(conv_out['conv2'], feed_dict={x: trainimg[0:1, :]})\n", "conv3 = sess.run(conv_out['conv3'], feed_dict={x: trainimg[0:1, :]})\n", "pool = sess.run(conv_out['pool'], feed_dict={x: trainimg[0:1, :]})\n", "dense = sess.run(conv_out['dense'], feed_dict={x: trainimg[0:1, :]})\n", "out = sess.run(conv_out['out'], feed_dict={x: trainimg[0:1, :]})" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Input" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Size of 'input_r' is (1, 28, 28, 1)\n", "Label is 7\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Let's see 'input_r'\n", "print (\"Size of 'input_r' is %s\" % (input_r.shape,))\n", "label = np.argmax(trainlabel[0, :])\n", "print (\"Label is %d\" % (label))\n", "\n", "# Plot ! \n", "plt.matshow(input_r[0, :, :, 0], cmap=plt.get_cmap('gray'))\n", "plt.title(\"Label of this image is \" + str(label) + \"\")\n", "plt.colorbar()\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Conv1 (1st hidden layer)" ] }, { "cell_type": "code", "execution_count": 11, "metadata": { "scrolled": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Size of 'conv1' is (1, 28, 28, 64)\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Let's see 'conv1'\n", "print (\"Size of 'conv1' is %s\" % (conv1.shape,))\n", "\n", "# Plot ! \n", "for i in range(3):\n", " plt.matshow(conv1[0, :, :, i], cmap=plt.get_cmap('gray'))\n", " plt.title(str(i) + \"th conv1\")\n", " plt.colorbar()\n", " plt.show() " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Conv2 (+bias)" ] }, { "cell_type": "code", "execution_count": 12, "metadata": { "scrolled": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Size of 'conv2' is (1, 28, 28, 64)\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Let's see 'conv2'\n", "print (\"Size of 'conv2' is %s\" % (conv2.shape,))\n", "\n", "# Plot ! \n", "for i in range(3):\n", " plt.matshow(conv2[0, :, :, i], cmap=plt.get_cmap('gray'))\n", " plt.title(str(i) + \"th conv2\")\n", " plt.colorbar()\n", " plt.show() " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Conv3 (+ReLU)" ] }, { "cell_type": "code", "execution_count": 13, "metadata": { "scrolled": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Size of 'conv3' is (1, 28, 28, 64)\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Let's see 'conv3'\n", "print (\"Size of 'conv3' is %s\" % (conv3.shape,))\n", "\n", "# Plot ! \n", "for i in range(3):\n", " plt.matshow(conv3[0, :, :, i], cmap=plt.get_cmap('gray'))\n", " plt.title(str(i) + \"th conv3\")\n", " plt.colorbar()\n", " plt.show() " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Pooling (max_pool)" ] }, { "cell_type": "code", "execution_count": 14, "metadata": { "scrolled": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Size of 'pool' is (1, 14, 14, 64)\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Let's see 'pool'\n", "print (\"Size of 'pool' is %s\" % (pool.shape,))\n", "\n", "# Plot ! \n", "for i in range(3):\n", " plt.matshow(pool[0, :, :, i], cmap=plt.get_cmap('gray'))\n", " plt.title(str(i) + \"th pool\")\n", " plt.colorbar()\n", " plt.show() " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Fully connected layer" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Size of 'dense' is (1, 12544)\n", "Size of 'out' is (1, 10)\n" ] } ], "source": [ "# Let's see 'dense'\n", "print (\"Size of 'dense' is %s\" % (dense.shape,))\n", "# Let's see 'out'\n", "print (\"Size of 'out' is %s\" % (out.shape,))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Conv. filters" ] }, { "cell_type": "code", "execution_count": 16, "metadata": { "scrolled": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Size of 'wc1' is (3, 3, 1, 64)\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Let's see weight! \n", "wc1 = sess.run(weights['wc1'])\n", "print (\"Size of 'wc1' is %s\" % (wc1.shape,))\n", "\n", "# Plot ! \n", "for i in range(3):\n", " plt.matshow(wc1[:, :, 0, i], cmap=plt.get_cmap('gray'))\n", " plt.title(str(i) + \"th conv filter\")\n", " plt.colorbar()\n", " plt.show() " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Keras version\n", "\n", "In Keras it is much easier to create and train a CNN using the Sequential API:" ] }, { "cell_type": "code", "execution_count": 29, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "WARNING:tensorflow:From /usr/local/lib/python3.5/dist-packages/tensorflow/python/ops/math_ops.py:3066: to_int32 (from tensorflow.python.ops.math_ops) is deprecated and will be removed in a future version.\n", "Instructions for updating:\n", "Use tf.cast instead.\n", "Train on 55000 samples, validate on 10000 samples\n", "Epoch 1/10\n", "55000/55000 [==============================] - 15s 279us/step - loss: 0.1373 - acc: 0.9573 - val_loss: 0.0498 - val_acc: 0.9836\n", "Epoch 2/10\n", "55000/55000 [==============================] - 14s 260us/step - loss: 0.0456 - acc: 0.9860 - val_loss: 0.0388 - val_acc: 0.9870\n", "Epoch 3/10\n", "55000/55000 [==============================] - 14s 259us/step - loss: 0.0307 - acc: 0.9907 - val_loss: 0.0353 - val_acc: 0.9884\n", "Epoch 4/10\n", "55000/55000 [==============================] - 14s 260us/step - loss: 0.0229 - acc: 0.9926 - val_loss: 0.0324 - val_acc: 0.9885\n", "Epoch 5/10\n", "55000/55000 [==============================] - 14s 259us/step - loss: 0.0180 - acc: 0.9941 - val_loss: 0.0306 - val_acc: 0.9905\n", "Epoch 6/10\n", "55000/55000 [==============================] - 14s 259us/step - loss: 0.0138 - acc: 0.9953 - val_loss: 0.0289 - val_acc: 0.9910\n", "Epoch 7/10\n", "55000/55000 [==============================] - 14s 259us/step - loss: 0.0112 - acc: 0.9964 - val_loss: 0.0348 - val_acc: 0.9904\n", "Epoch 8/10\n", "55000/55000 [==============================] - 14s 260us/step - loss: 0.0096 - acc: 0.9969 - val_loss: 0.0367 - val_acc: 0.9906\n", "Epoch 9/10\n", "55000/55000 [==============================] - 14s 259us/step - loss: 0.0083 - acc: 0.9971 - val_loss: 0.0425 - val_acc: 0.9900\n", "Epoch 10/10\n", "55000/55000 [==============================] - 14s 260us/step - loss: 0.0077 - acc: 0.9973 - val_loss: 0.0390 - val_acc: 0.9911\n" ] }, { "data": { "text/plain": [ "" ] }, "execution_count": 29, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from keras.models import Sequential\n", "from keras.layers import Dense, Conv2D, Flatten, ZeroPadding2D, MaxPooling2D\n", "\n", "#create model\n", "model = Sequential()\n", "\n", "#add model layers\n", "model.add(ZeroPadding2D((1,1), input_shape=(28,28,1)))\n", "model.add(Conv2D(64, kernel_size=3, activation='relu'))\n", "model.add(MaxPooling2D((2,2), strides=(2,2)))\n", "\n", "model.add(ZeroPadding2D((1,1)))\n", "model.add(Conv2D(32, kernel_size=3, activation='relu'))\n", "model.add(MaxPooling2D((2,2), strides=(2,2)))\n", " \n", "model.add(Flatten())\n", "model.add(Dense(100, activation='relu'))\n", " \n", "model.add(Dense(10, activation='softmax'))\n", " \n", "model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])\n", "\n", "\n", "X_train = trainimg.reshape(55000,28,28,1)\n", "X_test = testimg.reshape(10000,28,28,1)\n", "\n", "model.fit(X_train, trainlabel, validation_data=(X_test, testlabel), epochs=10)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Tasks\n", "1. Usage of a dev set.\n", "2. Try a more complicated structure like VGG or AlexNet\n", "3. Data augmentation: rotate and translate each training example to increase the size of the training data!" ] } ], "metadata": { "kernelspec": { "display_name": "Python 2", "language": "python", "name": "python2" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 2 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython2", "version": "2.7.12" } }, "nbformat": 4, "nbformat_minor": 1 }