convnet_1.0.0.29l_alt.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is model 1.0.0.29 trained on dataset 8 classifying to all five categories. The model was actually trained on a Google Cloud instance with GPU as it was far too computationally expensive to train on my laptop. When training the metrics were saved to disk and those are used for the plots below. Metrics were also logged to TensorBoard. Those logs as well as the resulting model are included in the repository."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\eric\\Anaconda2\\envs\\exts-aml2\\lib\\site-packages\\h5py\\__init__.py:36: FutureWarning: Conversion of the second argument of issubdtype from `float` to `np.floating` is deprecated. In future, it will be treated as `np.float64 == np.dtype(float).type`.\n",
      "  from ._conv import register_converters as _register_converters\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import os\n",
    "import wget\n",
    "import tensorflow as tf\n",
    "from training_utils import download_file, get_batches, read_and_decode_single_example, load_validation_data, \\\n",
    "    download_data, evaluate_model, get_training_data, load_weights, flatten\n",
    "import matplotlib.pyplot as plt\n",
    "import math\n",
    "%matplotlib inline\n",
    "#import argparse\n",
    "from tensorboard import summary as summary_lib"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Function to do the data augmentation on the GPU instead of the CPU, doing it on the CPU significantly slowed down training\n",
    "# Taken from https://becominghuman.ai/data-augmentation-on-gpu-in-tensorflow-13d14ecf2b19\n",
    "def augment(images, labels,\n",
    "            horizontal_flip=False,\n",
    "            vertical_flip=False,\n",
    "            #rotate=0,  # Maximum 90 degrees rotations\n",
    "            mixup=0):  # Mixup coeffecient, see https://arxiv.org/abs/1710.09412.pdf\n",
    "\n",
    "    # My experiments showed that casting on GPU improves training performance\n",
    "    if images.dtype != tf.float32:\n",
    "        images = tf.image.convert_image_dtype(images, dtype=tf.float32)\n",
    "        # images = tf.subtract(images, 0.5)\n",
    "        # images = tf.multiply(images, 2.0)\n",
    "    #labels = tf.to_float(labels)\n",
    "\n",
    "    with tf.name_scope('augmentation'):\n",
    "        shp = tf.shape(images)\n",
    "        batch_size, height, width = shp[0], shp[1], shp[2]\n",
    "        width = tf.cast(width, tf.float32)\n",
    "        height = tf.cast(height, tf.float32)\n",
    "\n",
    "        # The list of affine transformations that our image will go under.\n",
    "        # Every element is Nx8 tensor, where N is a batch size.\n",
    "        transforms = []\n",
    "        identity = tf.constant([1, 0, 0, 0, 1, 0, 0, 0], dtype=tf.float32)\n",
    "        if horizontal_flip:\n",
    "            coin = tf.less(tf.random_uniform([batch_size], 0, 1.0), 0.5)\n",
    "            flip_transform = tf.convert_to_tensor(\n",
    "                [-1., 0., width, 0., 1., 0., 0., 0.], dtype=tf.float32)\n",
    "            transforms.append(\n",
    "                tf.where(coin,\n",
    "                         tf.tile(tf.expand_dims(flip_transform, 0), [batch_size, 1]),\n",
    "                         tf.tile(tf.expand_dims(identity, 0), [batch_size, 1])))\n",
    "\n",
    "        if vertical_flip:\n",
    "            coin = tf.less(tf.random_uniform([batch_size], 0, 1.0), 0.5)\n",
    "            flip_transform = tf.convert_to_tensor(\n",
    "                [1, 0, 0, 0, -1, height, 0, 0], dtype=tf.float32)\n",
    "            transforms.append(\n",
    "                tf.where(coin,\n",
    "                         tf.tile(tf.expand_dims(flip_transform, 0), [batch_size, 1]),\n",
    "                         tf.tile(tf.expand_dims(identity, 0), [batch_size, 1])))\n",
    "\n",
    "        if transforms:\n",
    "            images = tf.contrib.image.transform(\n",
    "                images,\n",
    "                tf.contrib.image.compose_transforms(*transforms),\n",
    "                interpolation='BILINEAR')  # or 'NEAREST'\n",
    "\n",
    "        def cshift(values):  # Circular shift in batch dimension\n",
    "            return tf.concat([values[-1:, ...], values[:-1, ...]], 0)\n",
    "\n",
    "        if mixup > 0:\n",
    "            beta = tf.distributions.Beta(mixup, mixup)\n",
    "            lam = beta.sample(batch_size)\n",
    "            ll = tf.expand_dims(tf.expand_dims(tf.expand_dims(lam, -1), -1), -1)\n",
    "            images = ll * images + (1 - ll) * cshift(images)\n",
    "            labels = lam * labels + (1 - lam) * cshift(labels)\n",
    "\n",
    "    return images, labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# arguments\n",
    "epochs = 35\n",
    "dataset = 9\n",
    "init_model = None\n",
    "how = \"normal\"\n",
    "action = \"train\"\n",
    "threshold = 0.5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# download the data\n",
    "#download_data(what=dataset)\n",
    "batch_size = 32\n",
    "train_files, total_records = get_training_data(what=dataset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Steps per epoch: 1366\n",
      "Number of classes: 2\n"
     ]
    }
   ],
   "source": [
    "## Hyperparameters\n",
    "epsilon = 1e-8\n",
    "\n",
    "# learning rate\n",
    "epochs_per_decay = 10\n",
    "starting_rate = 0.001\n",
    "decay_factor = 0.80\n",
    "staircase = True\n",
    "\n",
    "# learning rate decay variables\n",
    "steps_per_epoch = int(total_records / batch_size)\n",
    "print(\"Steps per epoch:\", steps_per_epoch)\n",
    "\n",
    "# lambdas\n",
    "lamC = 0.00001\n",
    "lamF = 0.00250\n",
    "\n",
    "mu = 104\n",
    "\n",
    "# use dropout\n",
    "dropout = True\n",
    "fcdropout_rate = 0.5\n",
    "convdropout_rate = 0.001\n",
    "pooldropout_rate = 0.1\n",
    "\n",
    "if how == \"label\":\n",
    "    num_classes = 5\n",
    "elif how == \"normal\":\n",
    "    num_classes = 2\n",
    "elif how == \"mass\":\n",
    "    num_classes = 3\n",
    "elif how == \"benign\":\n",
    "    num_classes = 3\n",
    "\n",
    "print(\"Number of classes:\", num_classes)\n",
    "\n",
    "config = tf.ConfigProto()\n",
    "config.gpu_options.allocator_type = 'BFC'\n",
    "config.gpu_options.per_process_gpu_memory_fraction = 0.6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From C:\\Users\\eric\\Anaconda2\\envs\\exts-aml2\\lib\\site-packages\\tensorflow\\contrib\\learn\\python\\learn\\datasets\\base.py:198: retry (from tensorflow.contrib.learn.python.learn.datasets.base) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use the retry module or similar alternatives.\n",
      "Graph created...\n"
     ]
    }
   ],
   "source": [
    "model_name = \"model_s1.0.0.29l.14\"\n",
    "## Change Log\n",
    "# 0.0.0.4 - increase pool3 to 3x3 with stride 3\n",
    "# 0.0.0.6 - reduce pool 3 stride back to 2\n",
    "# 0.0.0.7 - reduce lambda for l2 reg\n",
    "# 0.0.0.8 - increase conv1 to 7x7 stride 2\n",
    "# 0.0.0.9 - disable per image normalization\n",
    "# 0.0.0.10 - commented out batch norm in conv layers, added conv4 and changed stride of convs to 1, increased FC lambda\n",
    "# 0.0.0.11 - turn dropout for conv layers on\n",
    "# 0.0.0.12 - added batch norm after pooling layers, increase pool dropout, decrease conv dropout, added extra conv layer to reduce data dimensionality\n",
    "# 0.0.0.13 - added precision and f1 summaries\n",
    "# 0.0.0.14 - fixing batch normalization, I don't think it's going to work after each pool\n",
    "# 0.0.0.15 - reduced xentropy weighting term\n",
    "# 0.0.0.17 - replaced initial 5x5 conv layers with 3 3x3 layers\n",
    "# 0.0.0.18 - changed stride of first conv to 2 from 1\n",
    "# 0.0.0.19 - doubled units in two fc layers\n",
    "# 0.0.0.20 - lowered learning rate, put a batch norm back in\n",
    "# 0.0.0.21 - put all batch norms back in\n",
    "# 0.0.0.22 - increased lambdaC, removed dropout from conv layers\n",
    "# 1.0.0.23 - added extra conv layers\n",
    "# 1.0.0.27 - updates to training code and metrics\n",
    "# 1.0.0.28 - using weighted x-entropy to improve recall\n",
    "# 1.0.0.29 - updated code to work training to classify for multiple classes\n",
    "# 1.0.0.29f - putting weighted x-entropy back\n",
    "\n",
    "graph = tf.Graph()\n",
    "with graph.as_default():\n",
    "    training = tf.placeholder(dtype=tf.bool, name=\"is_training\")\n",
    "    is_testing = tf.placeholder(dtype=bool, shape=(), name=\"is_testing\")\n",
    "\n",
    "    # create global step for decaying learning rate\n",
    "    global_step = tf.Variable(0, trainable=False)\n",
    "\n",
    "    learning_rate = tf.train.exponential_decay(starting_rate,\n",
    "                                               global_step,\n",
    "                                               steps_per_epoch * epochs_per_decay,\n",
    "                                               decay_factor,\n",
    "                                               staircase=staircase)\n",
    "\n",
    "    with tf.name_scope('inputs') as scope:\n",
    "        image, label = read_and_decode_single_example(train_files, label_type=how, normalize=False)\n",
    "\n",
    "        X_def, y_def = tf.train.shuffle_batch([image, label], batch_size=batch_size, capacity=2000,\n",
    "                                              min_after_dequeue=1000)\n",
    "\n",
    "        # Placeholders\n",
    "        X = tf.placeholder_with_default(X_def, shape=[None, 299, 299, 1])\n",
    "        y = tf.placeholder_with_default(y_def, shape=[None])\n",
    "        \n",
    "        X_adj = tf.image.adjust_contrast(X, 2.0)\n",
    "        X_adj = tf.cast(X_adj, dtype=tf.float32)\n",
    "\n",
    "        # center the pixel data\n",
    "        mu = tf.constant(127.0, name=\"pixel_mean\", dtype=tf.float32)\n",
    "        X_adj = tf.subtract(X_adj, mu, name=\"centered_input\")\n",
    "\n",
    "        # scale the data\n",
    "        X_adj = tf.divide(X_adj, 255.0)\n",
    "        \n",
    "        X_adj, y = augment(X_adj, y, horizontal_flip=True, vertical_flip=True, mixup=0)\n",
    "    # Convolutional layer 1\n",
    "    with tf.name_scope('conv1') as scope:\n",
    "        conv1 = tf.layers.conv2d(\n",
    "            X_adj,  # Input data\n",
    "            filters=32,\n",
    "            kernel_size=(3, 3),\n",
    "            strides=(2, 2),\n",
    "            padding='SAME',\n",
    "            activation=None,\n",
    "            kernel_initializer=tf.truncated_normal_initializer(stddev=5e-2, seed=100),\n",
    "            kernel_regularizer=tf.contrib.layers.l2_regularizer(scale=lamC),\n",
    "            name='conv1'\n",
    "        )\n",
    "\n",
    "        conv1_bn = tf.layers.batch_normalization(\n",
    "            conv1,\n",
    "            axis=-1,\n",
    "            momentum=0.99,\n",
    "            epsilon=epsilon,\n",
    "            center=True,\n",
    "            scale=True,\n",
    "            beta_initializer=tf.zeros_initializer(),\n",
    "            gamma_initializer=tf.ones_initializer(),\n",
    "            moving_mean_initializer=tf.zeros_initializer(),\n",
    "            moving_variance_initializer=tf.ones_initializer(),\n",
    "            training=training,\n",
    "            name='bn1'\n",
    "        )\n",
    "\n",
    "        # apply relu\n",
    "        conv1_bn = tf.nn.relu(conv1_bn, name='relu1')\n",
    "        \n",
    "    print(\"Graph created...\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "## CONFIGURE OPTIONS\n",
    "# if we are initializing the weights from a pre-trained model make sure it exists\n",
    "if init_model is not None:\n",
    "    if os.path.exists(os.path.join(\"model\", init_model + '.ckpt.index')):\n",
    "        init = False\n",
    "    else:\n",
    "        init = True\n",
    "# otherwise if this model exists let's continue training it rather than reinitializing it\n",
    "else:\n",
    "    if os.path.exists(os.path.join(\"model\", model_name + '.ckpt.index')):\n",
    "        init = False\n",
    "    else:\n",
    "        init = True\n",
    "\n",
    "meta_data_every = 1\n",
    "log_to_tensorboard = True\n",
    "print_every = 5  # how often to print metrics\n",
    "checkpoint_every = 1  # how often to save model in epochs\n",
    "use_gpu = False  # whether or not to use the GPU\n",
    "print_metrics = True  # whether to print or plot metrics, if False a plot will be created and updated every epoch\n",
    "\n",
    "config = tf.ConfigProto(device_count = {'GPU': 0})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Initializing model...\n",
      "Training model model_s1.0.0.29l.14 ...\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1fa952c50b8>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1fa95399550>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Train Raw Mean: 106.15787190579523\n",
      "Train Raw Min: 0\n",
      "Train Raw Max: 224\n",
      "Train Raw Std: 39.69775572877064\n",
      "\n",
      "Train Adj Mean: -0.08118102\n",
      "Train Adj Min: -0.49803925\n",
      "Train Adj Max: 0.5019608\n",
      "Train Adj Std: 0.200746\n",
      "\n",
      "Train C1 Mean: -0.00060820003\n",
      "Train C1 Min: -0.14106955\n",
      "Train C1 Max: 0.14170626\n",
      "INFO:tensorflow:Error reported to Coordinator: <class 'tensorflow.python.framework.errors_impl.CancelledError'>, Enqueue operation was cancelled\n",
      "\t [[Node: inputs/input_producer/input_producer_EnqueueMany = QueueEnqueueManyV2[Tcomponents=[DT_STRING], timeout_ms=-1, _device=\"/job:localhost/replica:0/task:0/device:CPU:0\"](inputs/input_producer, inputs/input_producer/RandomShuffle)]]\n"
     ]
    },
    {
     "ename": "FileNotFoundError",
     "evalue": "[Errno 2] No such file or directory: 'data\\\\cv9_data.npy'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mFileNotFoundError\u001b[0m                         Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-8-a8ef94d8ddb5>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[0;32m     73\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     74\u001b[0m             \u001b[1;31m# load the test data\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 75\u001b[1;33m             \u001b[0mX_cv\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0my_cv\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mload_validation_data\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mpercentage\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mhow\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mhow\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mwhich\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mdataset\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     76\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     77\u001b[0m             \u001b[1;31m# evaluate the test data\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\Documents\\Courses\\Applied ML 2\\mammography\\training_utils.py\u001b[0m in \u001b[0;36mload_validation_data\u001b[1;34m(data, how, which, percentage)\u001b[0m\n\u001b[0;32m    123\u001b[0m             \u001b[0mlabels\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mload\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mos\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mpath\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mjoin\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"data\"\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m\"cv8_labels.npy\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    124\u001b[0m         \u001b[1;32melif\u001b[0m \u001b[0mwhich\u001b[0m \u001b[1;33m==\u001b[0m \u001b[1;36m9\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 125\u001b[1;33m             \u001b[0mX_cv\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mload\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mos\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mpath\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mjoin\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"data\"\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m\"cv9_data.npy\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    126\u001b[0m             \u001b[0mlabels\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mload\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mos\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mpath\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mjoin\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"data\"\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m\"cv9_labels.npy\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    127\u001b[0m     \u001b[1;32melif\u001b[0m \u001b[0mdata\u001b[0m \u001b[1;33m==\u001b[0m \u001b[1;34m\"test\"\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\Anaconda2\\envs\\exts-aml2\\lib\\site-packages\\numpy\\lib\\npyio.py\u001b[0m in \u001b[0;36mload\u001b[1;34m(file, mmap_mode, allow_pickle, fix_imports, encoding)\u001b[0m\n\u001b[0;32m    370\u001b[0m     \u001b[0mown_fid\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;32mFalse\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    371\u001b[0m     \u001b[1;32mif\u001b[0m \u001b[0misinstance\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mfile\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mbasestring\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 372\u001b[1;33m         \u001b[0mfid\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mopen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mfile\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m\"rb\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    373\u001b[0m         \u001b[0mown_fid\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;32mTrue\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    374\u001b[0m     \u001b[1;32melif\u001b[0m \u001b[0mis_pathlib_path\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mfile\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mFileNotFoundError\u001b[0m: [Errno 2] No such file or directory: 'data\\\\cv9_data.npy'"
     ]
    }
   ],
   "source": [
    "init = True\n",
    "## train the model\n",
    "with tf.Session(graph=graph, config=config) as sess:\n",
    "    if log_to_tensorboard:\n",
    "        train_writer = tf.summary.FileWriter('./logs/tr_' + model_name, sess.graph)\n",
    "        test_writer = tf.summary.FileWriter('./logs/te_' + model_name)\n",
    "\n",
    "    if not print_metrics:\n",
    "        # create a plot to be updated as model is trained\n",
    "        f, ax = plt.subplots(1, 4, figsize=(24, 5))\n",
    "\n",
    "    # create the saver\n",
    "    saver = tf.train.Saver()\n",
    "    \n",
    "    sess.run(tf.global_variables_initializer())\n",
    "    print(\"Initializing model...\")\n",
    "\n",
    "    # if we are training the model\n",
    "    if action == \"train\":\n",
    "        coord = tf.train.Coordinator()\n",
    "        threads = tf.train.start_queue_runners(coord=coord)\n",
    "\n",
    "        print(\"Training model\", model_name, \"...\")\n",
    "\n",
    "        for epoch in range(2):\n",
    "            sess.run(tf.local_variables_initializer())\n",
    "\n",
    "            for i in range(steps_per_epoch):\n",
    "                # create the metadata\n",
    "                run_options = tf.RunOptions(trace_level=tf.RunOptions.FULL_TRACE)\n",
    "                run_metadata = tf.RunMetadata()\n",
    "\n",
    "            \n",
    "                image_batch, image_batch_adj, conv1_batch = sess.run(\n",
    "                    [X, X_adj, conv1],\n",
    "                    feed_dict={\n",
    "                        training: True,\n",
    "                    },\n",
    "                    options=run_options,\n",
    "                    run_metadata=run_metadata)\n",
    "                \n",
    "                image_arr = np.array(image_batch)\n",
    "                image_arr_adj = np.array(image_batch_adj)\n",
    "                \n",
    "                conv1_batch = np.array(conv1_batch)\n",
    "                plt.imshow(image_arr[0].reshape([299,299]))\n",
    "                plt.title(\"Raw\")\n",
    "                plt.show()\n",
    "                \n",
    "                conv1_batch = np.array(conv1_batch)\n",
    "                plt.imshow(image_arr_adj[0].reshape([299,299]))\n",
    "                plt.title(\"Adj\")\n",
    "                plt.show()\n",
    "                \n",
    "                print()\n",
    "                print(\"Train Raw Mean:\", np.mean(image_arr))\n",
    "                print(\"Train Raw Min:\", np.min(image_arr))\n",
    "                print(\"Train Raw Max:\", np.max(image_arr))\n",
    "                print(\"Train Raw Std:\", np.std(image_arr))\n",
    "                print()\n",
    "                print(\"Train Adj Mean:\", np.mean(image_arr_adj))\n",
    "                print(\"Train Adj Min:\", np.min(image_arr_adj))\n",
    "                print(\"Train Adj Max:\", np.max(image_arr_adj))\n",
    "                print(\"Train Adj Std:\", np.std(image_arr_adj))\n",
    "                print()\n",
    "                print(\"Train C1 Mean:\", np.mean(conv1_batch))\n",
    "                print(\"Train C1 Min:\", np.min(conv1_batch))\n",
    "                print(\"Train C1 Max:\", np.max(conv1_batch))\n",
    "                break\n",
    "            \n",
    "            # initialize the local variables so we have metrics only on the evaluation\n",
    "            sess.run(tf.local_variables_initializer())\n",
    "\n",
    "            # load the test data\n",
    "            X_cv, y_cv = load_validation_data(percentage=1, how=how, which=dataset)\n",
    "\n",
    "            # evaluate the test data\n",
    "            for X_batch, y_batch in get_batches(X_cv, y_cv, batch_size, distort=False):\n",
    "                cv_image_batch, cv_image_batch_adj, cv_conv1_batch = sess.run(\n",
    "                    [X, X_adj, conv1],\n",
    "                    feed_dict={\n",
    "                        X: X_batch,\n",
    "                        y: y_batch,\n",
    "                        training: False\n",
    "                    })\n",
    "                break\n",
    "            \n",
    "            cv_image_arr = np.array(cv_image_batch)\n",
    "            cv_image_arr_adj = np.array(cv_image_batch_adj)\n",
    "            cv_conv1_batch = np.array(cv_conv1_batch)\n",
    "#             plt.imshow(cv_image_arr[0].reshape([299,299]))\n",
    "#             plt.show()\n",
    "            \n",
    "            print()    \n",
    "            print(\"CV Raw Mean:\", np.mean(cv_image_arr))\n",
    "            print(\"CV Raw Min:\", np.min(cv_image_arr))\n",
    "            print(\"CV Raw Max:\", np.max(cv_image_arr))\n",
    "            print(\"CV Raw Std:\", np.std(cv_image_arr))\n",
    "            print()\n",
    "            print(\"CV Adj Mean:\", np.mean(cv_image_arr_adj))\n",
    "            print(\"CV Adj Min:\", np.min(cv_image_arr_adj))\n",
    "            print(\"CV Adj Max:\", np.max(cv_image_arr_adj))\n",
    "            print(\"CV Adj Std:\", np.std(cv_image_arr_adj))\n",
    "            print()\n",
    "            print(\"CV C1 Mean:\", np.mean(cv_conv1_batch))\n",
    "            print(\"CV C1 Min:\", np.min(cv_conv1_batch))\n",
    "            print(\"CV C1 Max:\", np.max(cv_conv1_batch))\n",
    "            \n",
    "            # delete the test data to save memory\n",
    "            del (X_cv)\n",
    "            del (y_cv)\n",
    "\n",
    "            print(\"Done evaluating...\")\n",
    "\n",
    "            break\n",
    "    # stop the coordinator\n",
    "    coord.request_stop()\n",
    "\n",
    "    # Wait for threads to stop\n",
    "    coord.join(threads)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "train_image = image_arr[0]\n",
    "cv_image = cv_image_arr[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(np.mean(train_image))\n",
    "print(np.mean(cv_image))"
   ]
  }
 ],
 "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.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}