code-16-embedding.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import numpy as np\n",
    "import tensorflow as tf\n",
    "import sys\n",
    "import urllib.request\n",
    "\n",
    "if sys.version_info[0] >= 3:\n",
    "  from urllib.request import urlretrieve\n",
    "else:\n",
    "  from urllib import urlretrieve\n",
    "\n",
    "LOGDIR = './tensorflow_logs/mnist_deep'\n",
    "\n",
    "def weight_variable(shape):\n",
    "  \"\"\"Generates a weight variable of a given shape.\"\"\"\n",
    "  initial = tf.truncated_normal(shape, stddev=0.1)\n",
    "  return tf.Variable(initial, name='weight')\n",
    "\n",
    "\n",
    "def bias_variable(shape):\n",
    "  \"\"\"Generates a bias variable of a given shape.\"\"\"\n",
    "  initial = tf.constant(0.1, shape=shape)\n",
    "  return tf.Variable(initial, name='bias')\n",
    "\n",
    "\n",
    "old_v = tf.logging.get_verbosity()\n",
    "tf.logging.set_verbosity(tf.logging.ERROR)\n",
    "\n",
    "from tensorflow.examples.tutorials.mnist import input_data\n",
    "def main():\n",
    "    mnist = input_data.read_data_sets(\"MNIST_data/\", one_hot=True)\n",
    "\n",
    "    # Placeholder that will be fed image data.\n",
    "    x = tf.placeholder(tf.float32, [None, 784], name='x')\n",
    "    # Placeholder that will be fed the correct labels.\n",
    "    y_ = tf.placeholder(tf.float32, [None, 10], name='labels')\n",
    "\n",
    "    # Reshape to use within a convolutional neural net.\n",
    "    # Last dimension is for \"features\" - there is only one here, since images are\n",
    "    # grayscale -- it would be 3 for an RGB image, 4 for RGBA, etc.\n",
    "    with tf.name_scope('reshape'):\n",
    "        x_image = tf.reshape(x, [-1, 28, 28, 1])\n",
    "        tf.summary.image('input', x_image, 4)\n",
    "\n",
    "    # Convolutional layer - maps one grayscale image to 32 features.\n",
    "    with tf.name_scope('conv1'):\n",
    "        W_conv1 = weight_variable([5, 5, 1, 32])\n",
    "        b_conv1 = bias_variable([32])\n",
    "        x_conv1 = tf.nn.conv2d(x_image, W_conv1, strides=[1, 1, 1, 1], padding='SAME')\n",
    "        h_conv1 = tf.nn.relu(x_conv1 + b_conv1)\n",
    "        tf.summary.histogram(\"weights\", W_conv1)\n",
    "        tf.summary.histogram(\"biases\", b_conv1)\n",
    "        tf.summary.histogram(\"activations\", h_conv1)\n",
    "\n",
    "    # Pooling layer - downsamples by 2X.\n",
    "    with tf.name_scope('pool1'):\n",
    "        h_pool1 = tf.nn.max_pool(h_conv1, ksize=[1, 2, 2, 1],\n",
    "                        strides=[1, 2, 2, 1], padding='SAME')\n",
    "        # Display the image after max pooling on tensorboard\n",
    "        h_pool1_image = tf.reshape(h_pool1, [-1, 14, 14, 1])\n",
    "        tf.summary.image('conv1', h_pool1_image, 4)\n",
    "\n",
    "    # Second convolutional layer -- maps 32 feature maps to 64.\n",
    "    with tf.name_scope('conv2'):\n",
    "        W_conv2 = weight_variable([5, 5, 32, 64])\n",
    "        b_conv2 = bias_variable([64])\n",
    "        x_conv2 = tf.nn.conv2d(h_pool1, W_conv2, strides=[1, 1, 1, 1], padding='SAME')\n",
    "        h_conv2 = tf.nn.relu(x_conv2 + b_conv2)\n",
    "        tf.summary.histogram(\"weights\", W_conv2)\n",
    "        tf.summary.histogram(\"biases\", b_conv2)\n",
    "        tf.summary.histogram(\"activations\", h_conv2)\n",
    "\n",
    "    # Second pooling layer.\n",
    "    with tf.name_scope('pool2'):\n",
    "        h_pool2 = tf.nn.max_pool(h_conv2, ksize=[1, 2, 2, 1],\n",
    "                        strides=[1, 2, 2, 1], padding='SAME')\n",
    "        # Display the image after max pooling on tensorboard\n",
    "        h_pool2_image = tf.reshape(h_pool2, [-1, 7, 7, 1])\n",
    "        tf.summary.image('conv2', h_pool2_image, 4)\n",
    "\n",
    "    # After 2 rounds of downsampling, our 28x28 image\n",
    "    # is down to 7x7 with 64 feature maps.\n",
    "    with tf.name_scope('fc1'):\n",
    "        h_pool_flat = tf.reshape(h_pool2, [-1, 7*7*64])\n",
    "        W_fc1 = weight_variable([7*7*64, 1024])\n",
    "        b_fc1 = bias_variable([1024])\n",
    "        h_fc1 = tf.nn.relu(tf.matmul(h_pool_flat, W_fc1) + b_fc1)\n",
    "        tf.summary.histogram(\"weights\", W_fc1)\n",
    "        tf.summary.histogram(\"biases\", b_fc1)\n",
    "        tf.summary.histogram(\"activations\", h_fc1)\n",
    "\n",
    "    # Dropout - controls the complexity of the model, prevents co-adaptation of\n",
    "    # features.\n",
    "    with tf.name_scope('dropout'):\n",
    "        keep_prob = tf.placeholder(tf.float32)\n",
    "        h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)\n",
    "\n",
    "    # Map the features to 10 classes, one for each digit\n",
    "    with tf.name_scope('fc-classify'):\n",
    "        W_fc2 = weight_variable([1024, 10])\n",
    "        b_fc2 = bias_variable([10])\n",
    "        y = tf.matmul(h_fc1_drop, W_fc2) + b_fc2\n",
    "\n",
    "    ###########################\n",
    "\n",
    "    # Define our loss.\n",
    "    with tf.name_scope('loss'):\n",
    "        # Use more numerically stable cross entropy.\n",
    "        cross_entropy = tf.reduce_mean(\n",
    "            tf.nn.softmax_cross_entropy_with_logits(labels=y_, logits=y),\n",
    "            name='cross_entropy'\n",
    "        )\n",
    "        tf.summary.scalar('loss', cross_entropy)\n",
    "\n",
    "    # Define our optimizer.\n",
    "    with tf.name_scope('optimizer'):\n",
    "        train_step = tf.train.AdamOptimizer(0.0001).minimize(cross_entropy, name='train_step')\n",
    "\n",
    "    # Define accuracy.\n",
    "    with tf.name_scope('accuracy'):\n",
    "        correct_prediction = tf.equal(tf.argmax(y,1), tf.argmax(y_,1))\n",
    "        correct_prediction = tf.cast(correct_prediction, tf.float32, name='correct_prediction')\n",
    "        accuracy = tf.reduce_mean(correct_prediction, name='accuracy')\n",
    "        tf.summary.scalar('accuracy', accuracy)\n",
    "\n",
    "    # Launch session.\n",
    "    sess = tf.InteractiveSession()\n",
    "\n",
    "    # Initialize variables.\n",
    "    tf.global_variables_initializer().run()\n",
    "\n",
    "    # Merge all the summary data\n",
    "    merged = tf.summary.merge_all()\n",
    "\n",
    "    # Create summary writer\n",
    "    writer = tf.summary.FileWriter(LOGDIR, sess.graph)\n",
    "\n",
    "    # Get sprite and labels file for the embedding projector\n",
    "    GITHUB_URL ='https://raw.githubusercontent.com/mamcgrath/TensorBoard-TF-Dev-Summit-Tutorial/master/'\n",
    "    urlretrieve(GITHUB_URL + 'labels_1024.tsv', os.path.join(LOGDIR, 'labels_1024.tsv'))\n",
    "    urlretrieve(GITHUB_URL + 'sprite_1024.png', os.path.join(LOGDIR, 'sprite_1024.png'))\n",
    "\n",
    "    # Setup embedding visualization\n",
    "    embedding = tf.Variable(tf.zeros([1024, 1024]), name=\"test_embedding\")\n",
    "    assignment = embedding.assign(h_fc1_drop)\n",
    "    saver = tf.train.Saver()\n",
    "\n",
    "    config = tf.contrib.tensorboard.plugins.projector.ProjectorConfig()\n",
    "    embedding_config = config.embeddings.add()\n",
    "    embedding_config.tensor_name = embedding.name\n",
    "    embedding_config.sprite.image_path = 'sprite_1024.png'\n",
    "    embedding_config.metadata_path = 'labels_1024.tsv'\n",
    "    # Specify the width and height of a single thumbnail.\n",
    "    embedding_config.sprite.single_image_dim.extend([28, 28])\n",
    "    tf.contrib.tensorboard.plugins.projector.visualize_embeddings(writer, config)\n",
    "\n",
    "    # Do the training.\n",
    "    for i in range(1100):\n",
    "        batch = mnist.train.next_batch(100)\n",
    "        if i % 5 == 0:\n",
    "            summary = sess.run(merged, feed_dict={x: batch[0], y_: batch[1], keep_prob: 1.0})\n",
    "            writer.add_summary(summary, i)\n",
    "        if i % 100 == 0:\n",
    "            train_accuracy = sess.run(accuracy, feed_dict={x:batch[0], y_: batch[1], keep_prob: 1.0})\n",
    "            print(\"Step %d, Training Accuracy %g\" % (i, float(train_accuracy)))\n",
    "        if i % 500 == 0:\n",
    "            sess.run(assignment, feed_dict={x: mnist.test.images[:1024], y_: mnist.test.labels[:1024], keep_prob: 1.0})\n",
    "            saver.save(sess, os.path.join(LOGDIR, \"model.ckpt\"), i)\n",
    "        sess.run(train_step, feed_dict={x: batch[0], y_: batch[1], keep_prob: 0.5})\n",
    "\n",
    "    # See how model did.\n",
    "    print(\"Test Accuracy %g\" % sess.run(accuracy, feed_dict={x: mnist.test.images,\n",
    "                                                             y_: mnist.test.labels,\n",
    "                                                             keep_prob: 1.0}))\n",
    "\n",
    "    # Close summary writer\n",
    "    writer.close()\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    main()\n",
    "tf.logging.set_verbosity(old_v)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "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.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}