retrain.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "retrain.ipynb",
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ei6jVkswDfHf",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 55
        },
        "outputId": "afc915e7-9043-445b-df79-4483c4a5288f"
      },
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/drive')"
      ],
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Drive already mounted at /content/drive; to attempt to forcibly remount, call drive.mount(\"/content/drive\", force_remount=True).\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "o1c50ub08Q_t",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "%tensorflow_version 1.x\n",
        "from __future__ import absolute_import\n",
        "from __future__ import division\n",
        "from __future__ import print_function\n",
        "\n",
        "from absl import logging\n",
        "\n",
        "import argparse\n",
        "import collections\n",
        "from datetime import datetime\n",
        "import hashlib\n",
        "import os\n",
        "import random\n",
        "import re\n",
        "import sys\n",
        "\n",
        "import numpy as np\n",
        "import tensorflow as tf\n",
        "import tensorflow_hub as hub\n",
        "from tensorflow.contrib import quantize as contrib_quantize\n",
        "\n",
        "FLAGS = None\n",
        "\n",
        "MAX_NUM_IMAGES_PER_CLASS = 2 ** 27 - 1  # ~134M\n",
        "\n",
        "# A module is understood as instrumented for quantization with TF-Lite\n",
        "# if it contains any of these ops.\n",
        "FAKE_QUANT_OPS = ('FakeQuantWithMinMaxVars',\n",
        "                  'FakeQuantWithMinMaxVarsPerChannel')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "omWcB9Tg9ClQ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def create_image_lists(image_dir, testing_percentage, validation_percentage):\n",
        "  with tf.device('/device:GPU:0'):\n",
        "    if not tf.gfile.Exists(image_dir):\n",
        "      logging.error(\"Image directory '\" + image_dir + \"' not found.\")\n",
        "      return None\n",
        "    result = collections.OrderedDict()\n",
        "    sub_dirs = sorted(x[0] for x in tf.gfile.Walk(image_dir))\n",
        "    # The root directory comes first, so skip it.\n",
        "    is_root_dir = True\n",
        "    for sub_dir in sub_dirs:\n",
        "      if is_root_dir:\n",
        "        is_root_dir = False\n",
        "        continue\n",
        "      extensions = sorted(set(os.path.normcase(ext)  # Smash case on Windows.\n",
        "                              for ext in ['JPEG', 'JPG', 'jpeg', 'jpg', 'png']))\n",
        "      file_list = []\n",
        "      dir_name = os.path.basename(\n",
        "          # tf.gfile.Walk() returns sub-directory with trailing '/' when it is in\n",
        "          # Google Cloud Storage, which confuses os.path.basename().\n",
        "          sub_dir[:-1] if sub_dir.endswith('/') else sub_dir)\n",
        "\n",
        "      if dir_name == image_dir:\n",
        "        continue\n",
        "      logging.info(\"Looking for images in '%s'\",  dir_name)\n",
        "      for extension in extensions:\n",
        "        file_glob = os.path.join(image_dir, dir_name, '*.' + extension)\n",
        "        file_list.extend(tf.gfile.Glob(file_glob))\n",
        "      if not file_list:\n",
        "        logging.warning('No files found')\n",
        "        continue\n",
        "      if len(file_list) < 20:\n",
        "        logging.warning(\n",
        "            'WARNING: Folder has less than 20 images, which may cause issues.')\n",
        "      elif len(file_list) > MAX_NUM_IMAGES_PER_CLASS:\n",
        "        logging.warning(\n",
        "            'WARNING: Folder %s has more than %s images. Some images will '\n",
        "            'never be selected.', dir_name, MAX_NUM_IMAGES_PER_CLASS)\n",
        "      label_name = re.sub(r'[^a-z0-9]+', ' ', dir_name.lower())\n",
        "      training_images = []\n",
        "      testing_images = []\n",
        "      validation_images = []\n",
        "      for file_name in file_list:\n",
        "        base_name = os.path.basename(file_name)\n",
        "        hash_name = re.sub(r'_nohash_.*$', '', file_name)\n",
        "        hash_name_hashed = hashlib.sha1(tf.compat.as_bytes(hash_name)).hexdigest()\n",
        "        percentage_hash = ((int(hash_name_hashed, 16) %\n",
        "                            (MAX_NUM_IMAGES_PER_CLASS + 1)) *\n",
        "                          (100.0 / MAX_NUM_IMAGES_PER_CLASS))\n",
        "        if len(validation_images) == 0:\n",
        "          validation_images.append(base_name)\n",
        "        elif percentage_hash < validation_percentage:\n",
        "          testing_images.append(base_name)\n",
        "        else:\n",
        "          training_images.append(base_name)\n",
        "      result[label_name] = {\n",
        "          'dir': dir_name,\n",
        "          'training': training_images,\n",
        "          'testing': testing_images,\n",
        "          'validation': validation_images,\n",
        "      }\n",
        "  return result\n",
        "\n",
        "def get_image_path(image_lists, label_name, index, image_dir, category):\n",
        "  if label_name not in image_lists:\n",
        "    logging.fatal('Label does not exist %s.', label_name)\n",
        "  label_lists = image_lists[label_name]\n",
        "  if category not in label_lists:\n",
        "    logging.fatal('Category does not exist %s.', category)\n",
        "  category_list = label_lists[category]\n",
        "  if not category_list:\n",
        "    logging.fatal('Label %s has no images in the category %s.',\n",
        "                  label_name, category)\n",
        "  mod_index = index % len(category_list)\n",
        "  base_name = category_list[mod_index]\n",
        "  sub_dir = label_lists['dir']\n",
        "  full_path = os.path.join(image_dir, sub_dir, base_name)\n",
        "  return full_path\n",
        "\n",
        "def get_bottleneck_path(image_lists, label_name, index, bottleneck_dir,\n",
        "                        category, module_name):\n",
        "  module_name = (module_name.replace('://', '~')  # URL scheme.\n",
        "                 .replace('/', '~')  # URL and Unix paths.\n",
        "                 .replace(':', '~').replace('\\\\', '~'))  # Windows paths.\n",
        "  return get_image_path(image_lists, label_name, index, bottleneck_dir,\n",
        "                        category) + '_' + module_name + '.txt'\n",
        "\n",
        "def create_module_graph(module_spec):\n",
        "  with tf.device('/device:GPU:0'):\n",
        "    height, width = hub.get_expected_image_size(module_spec)\n",
        "    with tf.Graph().as_default() as graph:\n",
        "      resized_input_tensor = tf.placeholder(tf.float32, [None, height, width, 3])\n",
        "      m = hub.Module(module_spec)\n",
        "      bottleneck_tensor = m(resized_input_tensor)\n",
        "      wants_quantization = any(node.op in FAKE_QUANT_OPS\n",
        "                              for node in graph.as_graph_def().node)\n",
        "    return graph, bottleneck_tensor, resized_input_tensor, wants_quantization\n",
        "\n",
        "def run_bottleneck_on_image(sess, image_data, image_data_tensor,\n",
        "                            decoded_image_tensor, resized_input_tensor,\n",
        "                            bottleneck_tensor):\n",
        "  # First decode the JPEG image, resize it, and rescale the pixel values.\n",
        "  resized_input_values = sess.run(decoded_image_tensor,\n",
        "                                  {image_data_tensor: image_data})\n",
        "  # Then run it through the recognition network.\n",
        "  bottleneck_values = sess.run(bottleneck_tensor,\n",
        "                               {resized_input_tensor: resized_input_values})\n",
        "  bottleneck_values = np.squeeze(bottleneck_values)\n",
        "  return bottleneck_values\n",
        "\n",
        "def ensure_dir_exists(dir_name):\n",
        "  if not os.path.exists(dir_name):\n",
        "    os.makedirs(dir_name)\n",
        "\n",
        "\n",
        "def create_bottleneck_file(bottleneck_path, image_lists, label_name, index,\n",
        "                           image_dir, category, sess, jpeg_data_tensor,\n",
        "                           decoded_image_tensor, resized_input_tensor,\n",
        "                           bottleneck_tensor):\n",
        "  with tf.device('/device:GPU:0'):\n",
        "    \"\"\"Create a single bottleneck file.\"\"\"\n",
        "    logging.debug('Creating bottleneck at %s', bottleneck_path)\n",
        "    image_path = get_image_path(image_lists, label_name, index,\n",
        "                                image_dir, category)\n",
        "    if not tf.gfile.Exists(image_path):\n",
        "      logging.fatal('File does not exist %s', image_path)\n",
        "    image_data = tf.gfile.GFile(image_path, 'rb').read()\n",
        "    try:\n",
        "      bottleneck_values = run_bottleneck_on_image(\n",
        "          sess, image_data, jpeg_data_tensor, decoded_image_tensor,\n",
        "          resized_input_tensor, bottleneck_tensor)\n",
        "    except Exception as e:\n",
        "      raise RuntimeError('Error during processing file %s (%s)' % (image_path,\n",
        "                                                                  str(e)))\n",
        "    bottleneck_string = ','.join(str(x) for x in bottleneck_values)\n",
        "    with tf.gfile.GFile(bottleneck_path, 'w') as bottleneck_file:\n",
        "      bottleneck_file.write(bottleneck_string)\n",
        "\n",
        "def get_or_create_bottleneck(sess, image_lists, label_name, index, image_dir,\n",
        "                             category, bottleneck_dir, jpeg_data_tensor,\n",
        "                             decoded_image_tensor, resized_input_tensor,\n",
        "                             bottleneck_tensor, module_name):\n",
        "  with tf.device('/device:GPU:0'):\n",
        "    label_lists = image_lists[label_name]\n",
        "    sub_dir = label_lists['dir']\n",
        "    sub_dir_path = os.path.join(bottleneck_dir, sub_dir)\n",
        "    ensure_dir_exists(sub_dir_path)\n",
        "    bottleneck_path = get_bottleneck_path(image_lists, label_name, index,\n",
        "                                          bottleneck_dir, category, module_name)\n",
        "    if not os.path.exists(bottleneck_path):\n",
        "      create_bottleneck_file(bottleneck_path, image_lists, label_name, index,\n",
        "                            image_dir, category, sess, jpeg_data_tensor,\n",
        "                            decoded_image_tensor, resized_input_tensor,\n",
        "                            bottleneck_tensor)\n",
        "    with tf.gfile.GFile(bottleneck_path, 'r') as bottleneck_file:\n",
        "      bottleneck_string = bottleneck_file.read()\n",
        "    did_hit_error = False\n",
        "    try:\n",
        "      bottleneck_values = [float(x) for x in bottleneck_string.split(',')]\n",
        "    except ValueError:\n",
        "      logging.warning('Invalid float found, recreating bottleneck')\n",
        "      did_hit_error = True\n",
        "    if did_hit_error:\n",
        "      create_bottleneck_file(bottleneck_path, image_lists, label_name, index,\n",
        "                            image_dir, category, sess, jpeg_data_tensor,\n",
        "                            decoded_image_tensor, resized_input_tensor,\n",
        "                            bottleneck_tensor)\n",
        "      with tf.gfile.GFile(bottleneck_path, 'r') as bottleneck_file:\n",
        "        bottleneck_string = bottleneck_file.read()\n",
        "      # Allow exceptions to propagate here, since they shouldn't happen after a\n",
        "      # fresh creation\n",
        "      bottleneck_values = [float(x) for x in bottleneck_string.split(',')]\n",
        "    return bottleneck_values\n",
        "\n",
        "def cache_bottlenecks(sess, image_lists, image_dir, bottleneck_dir,\n",
        "                      jpeg_data_tensor, decoded_image_tensor,\n",
        "                      resized_input_tensor, bottleneck_tensor, module_name):\n",
        "  how_many_bottlenecks = 0\n",
        "  ensure_dir_exists(bottleneck_dir)\n",
        "  for label_name, label_lists in image_lists.items():\n",
        "    for category in ['training', 'testing', 'validation']:\n",
        "      category_list = label_lists[category]\n",
        "      for index, unused_base_name in enumerate(category_list):\n",
        "        get_or_create_bottleneck(\n",
        "            sess, image_lists, label_name, index, image_dir, category,\n",
        "            bottleneck_dir, jpeg_data_tensor, decoded_image_tensor,\n",
        "            resized_input_tensor, bottleneck_tensor, module_name)\n",
        "        how_many_bottlenecks += 1\n",
        "        if how_many_bottlenecks % 100 == 0:\n",
        "          logging.info('%s bottleneck files created.', how_many_bottlenecks)\n",
        "\n",
        "\n",
        "def get_random_cached_bottlenecks(sess, image_lists, how_many, category,\n",
        "                                  bottleneck_dir, image_dir, jpeg_data_tensor,\n",
        "                                  decoded_image_tensor, resized_input_tensor,\n",
        "                                  bottleneck_tensor, module_name):\n",
        "  class_count = len(image_lists.keys())\n",
        "  bottlenecks = []\n",
        "  ground_truths = []\n",
        "  filenames = []\n",
        "  if how_many >= 0:\n",
        "    # Retrieve a random sample of bottlenecks.\n",
        "    for unused_i in range(how_many):\n",
        "      label_index = random.randrange(class_count)\n",
        "      label_name = list(image_lists.keys())[label_index]\n",
        "      image_index = random.randrange(MAX_NUM_IMAGES_PER_CLASS + 1)\n",
        "      image_name = get_image_path(image_lists, label_name, image_index,\n",
        "                                  image_dir, category)\n",
        "      bottleneck = get_or_create_bottleneck(\n",
        "          sess, image_lists, label_name, image_index, image_dir, category,\n",
        "          bottleneck_dir, jpeg_data_tensor, decoded_image_tensor,\n",
        "          resized_input_tensor, bottleneck_tensor, module_name)\n",
        "      bottlenecks.append(bottleneck)\n",
        "      ground_truths.append(label_index)\n",
        "      filenames.append(image_name)\n",
        "  else:\n",
        "    # Retrieve all bottlenecks.\n",
        "    for label_index, label_name in enumerate(image_lists.keys()):\n",
        "      for image_index, image_name in enumerate(\n",
        "          image_lists[label_name][category]):\n",
        "        image_name = get_image_path(image_lists, label_name, image_index,\n",
        "                                    image_dir, category)\n",
        "        bottleneck = get_or_create_bottleneck(\n",
        "            sess, image_lists, label_name, image_index, image_dir, category,\n",
        "            bottleneck_dir, jpeg_data_tensor, decoded_image_tensor,\n",
        "            resized_input_tensor, bottleneck_tensor, module_name)\n",
        "        bottlenecks.append(bottleneck)\n",
        "        ground_truths.append(label_index)\n",
        "        filenames.append(image_name)\n",
        "  return bottlenecks, ground_truths, filenames\n",
        "\n",
        "def get_random_distorted_bottlenecks(\n",
        "    sess, image_lists, how_many, category, image_dir, input_jpeg_tensor,\n",
        "    distorted_image, resized_input_tensor, bottleneck_tensor):\n",
        "  with tf.device('/device:GPU:0'):\n",
        "    class_count = len(image_lists.keys())\n",
        "    bottlenecks = []\n",
        "    ground_truths = []\n",
        "    for unused_i in range(how_many):\n",
        "      label_index = random.randrange(class_count)\n",
        "      label_name = list(image_lists.keys())[label_index]\n",
        "      image_index = random.randrange(MAX_NUM_IMAGES_PER_CLASS + 1)\n",
        "      image_path = get_image_path(image_lists, label_name, image_index, image_dir,\n",
        "                                  category)\n",
        "      if not tf.gfile.Exists(image_path):\n",
        "        logging.fatal('File does not exist %s', image_path)\n",
        "      jpeg_data = tf.gfile.GFile(image_path, 'rb').read()\n",
        "      # Note that we materialize the distorted_image_data as a numpy array before\n",
        "      # sending running inference on the image. This involves 2 memory copies and\n",
        "      # might be optimized in other implementations.\n",
        "      distorted_image_data = sess.run(distorted_image,\n",
        "                                      {input_jpeg_tensor: jpeg_data})\n",
        "      bottleneck_values = sess.run(bottleneck_tensor,\n",
        "                                  {resized_input_tensor: distorted_image_data})\n",
        "      bottleneck_values = np.squeeze(bottleneck_values)\n",
        "      bottlenecks.append(bottleneck_values)\n",
        "      ground_truths.append(label_index)\n",
        "    return bottlenecks, ground_truths\n",
        "\n",
        "def should_distort_images(flip_left_right, random_crop, random_scale,\n",
        "                          random_brightness):\n",
        "  return (flip_left_right or (random_crop != 0) or (random_scale != 0) or\n",
        "          (random_brightness != 0))\n",
        "\n",
        "\n",
        "def add_input_distortions(flip_left_right, random_crop, random_scale,\n",
        "                          random_brightness, module_spec):\n",
        "  with tf.device('/device:GPU:0'):\n",
        "    input_height, input_width = hub.get_expected_image_size(module_spec)\n",
        "    input_depth = hub.get_num_image_channels(module_spec)\n",
        "    jpeg_data = tf.placeholder(tf.string, name='DistortJPGInput')\n",
        "    decoded_image = tf.image.decode_jpeg(jpeg_data, channels=input_depth)\n",
        "    # Convert from full range of uint8 to range [0,1] of float32.\n",
        "    decoded_image_as_float = tf.image.convert_image_dtype(decoded_image,\n",
        "                                                          tf.float32)\n",
        "    decoded_image_4d = tf.expand_dims(decoded_image_as_float, 0)\n",
        "    margin_scale = 1.0 + (random_crop / 100.0)\n",
        "    resize_scale = 1.0 + (random_scale / 100.0)\n",
        "    margin_scale_value = tf.constant(margin_scale)\n",
        "    resize_scale_value = tf.random_uniform(shape=[],\n",
        "                                          minval=1.0,\n",
        "                                          maxval=resize_scale)\n",
        "    scale_value = tf.multiply(margin_scale_value, resize_scale_value)\n",
        "    precrop_width = tf.multiply(scale_value, input_width)\n",
        "    precrop_height = tf.multiply(scale_value, input_height)\n",
        "    precrop_shape = tf.stack([precrop_height, precrop_width])\n",
        "    precrop_shape_as_int = tf.cast(precrop_shape, dtype=tf.int32)\n",
        "    precropped_image = tf.image.resize_bilinear(decoded_image_4d,\n",
        "                                                precrop_shape_as_int)\n",
        "    precropped_image_3d = tf.squeeze(precropped_image, axis=[0])\n",
        "    cropped_image = tf.random_crop(precropped_image_3d,\n",
        "                                  [input_height, input_width, input_depth])\n",
        "    if flip_left_right:\n",
        "      flipped_image = tf.image.random_flip_left_right(cropped_image)\n",
        "    else:\n",
        "      flipped_image = cropped_image\n",
        "    brightness_min = 1.0 - (random_brightness / 100.0)\n",
        "    brightness_max = 1.0 + (random_brightness / 100.0)\n",
        "    brightness_value = tf.random_uniform(shape=[],\n",
        "                                        minval=brightness_min,\n",
        "                                        maxval=brightness_max)\n",
        "    brightened_image = tf.multiply(flipped_image, brightness_value)\n",
        "    distort_result = tf.expand_dims(brightened_image, 0, name='DistortResult')\n",
        "    return jpeg_data, distort_result  \n",
        "\n",
        "def variable_summaries(var):\n",
        "  with tf.device('/device:GPU:0'):\n",
        "    \"\"\"Attach a lot of summaries to a Tensor (for TensorBoard visualization).\"\"\"\n",
        "    with tf.name_scope('summaries'):\n",
        "      mean = tf.reduce_mean(var)\n",
        "      tf.summary.scalar('mean', mean)\n",
        "      with tf.name_scope('stddev'):\n",
        "        stddev = tf.sqrt(tf.reduce_mean(tf.square(var - mean)))\n",
        "      tf.summary.scalar('stddev', stddev)\n",
        "      tf.summary.scalar('max', tf.reduce_max(var))\n",
        "      tf.summary.scalar('min', tf.reduce_min(var))\n",
        "      tf.summary.histogram('histogram', var)\n",
        "\n",
        "\n",
        "def add_final_retrain_ops(class_count, final_tensor_name, bottleneck_tensor,\n",
        "                          quantize_layer, is_training):\n",
        "  with tf.device('/device:GPU:0'):\n",
        "    batch_size, bottleneck_tensor_size = bottleneck_tensor.get_shape().as_list()\n",
        "    assert batch_size is None, 'We want to work with arbitrary batch size.'\n",
        "    with tf.name_scope('input'):\n",
        "      bottleneck_input = tf.placeholder_with_default(\n",
        "          bottleneck_tensor,\n",
        "          shape=[batch_size, bottleneck_tensor_size],\n",
        "          name='BottleneckInputPlaceholder')\n",
        "\n",
        "      ground_truth_input = tf.placeholder(\n",
        "          tf.int64, [batch_size], name='GroundTruthInput')\n",
        "\n",
        "    # Organizing the following ops so they are easier to see in TensorBoard.\n",
        "    layer_name = 'final_retrain_ops'\n",
        "    with tf.name_scope(layer_name):\n",
        "      with tf.name_scope('weights'):\n",
        "        initial_value = tf.truncated_normal(\n",
        "            [bottleneck_tensor_size, class_count], stddev=0.001)\n",
        "        layer_weights = tf.Variable(initial_value, name='final_weights')\n",
        "        variable_summaries(layer_weights)\n",
        "\n",
        "      with tf.name_scope('biases'):\n",
        "        layer_biases = tf.Variable(tf.zeros([class_count]), name='final_biases')\n",
        "        variable_summaries(layer_biases)\n",
        "\n",
        "      with tf.name_scope('Wx_plus_b'):\n",
        "        logits = tf.matmul(bottleneck_input, layer_weights) + layer_biases\n",
        "        tf.summary.histogram('pre_activations', logits)\n",
        "\n",
        "    final_tensor = tf.nn.softmax(logits, name=final_tensor_name)\n",
        "\n",
        "    # The tf.contrib.quantize functions rewrite the graph in place for\n",
        "    # quantization. The imported model graph has already been rewritten, so upon\n",
        "    # calling these rewrites, only the newly added final layer will be\n",
        "    # transformed.\n",
        "    if quantize_layer:\n",
        "      if is_training:\n",
        "        contrib_quantize.create_training_graph()\n",
        "      else:\n",
        "        contrib_quantize.create_eval_graph()\n",
        "        \n",
        "    tf.summary.histogram('activations', final_tensor)\n",
        "\n",
        "    # If this is an eval graph, we don't need to add loss ops or an optimizer.\n",
        "    if not is_training:\n",
        "      return None, None, bottleneck_input, ground_truth_input, final_tensor\n",
        "\n",
        "    with tf.name_scope('cross_entropy'):\n",
        "      cross_entropy_mean = tf.losses.sparse_softmax_cross_entropy(\n",
        "          labels=ground_truth_input, logits=logits)\n",
        "\n",
        "    tf.summary.scalar('cross_entropy', cross_entropy_mean)\n",
        "\n",
        "    with tf.name_scope('train'):\n",
        "      optimizer = tf.train.GradientDescentOptimizer(FLAGS.learning_rate)\n",
        "      train_step = optimizer.minimize(cross_entropy_mean)\n",
        "\n",
        "    return (train_step, cross_entropy_mean, bottleneck_input, ground_truth_input,\n",
        "            final_tensor)\n",
        "\n",
        "def add_evaluation_step(result_tensor, ground_truth_tensor):\n",
        "  with tf.device('/device:GPU:0'):\n",
        "    with tf.name_scope('accuracy'):\n",
        "      with tf.name_scope('correct_prediction'):\n",
        "        prediction = tf.argmax(result_tensor, 1)\n",
        "        correct_prediction = tf.equal(prediction, ground_truth_tensor)\n",
        "      with tf.name_scope('accuracy'):\n",
        "        evaluation_step = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))\n",
        "    tf.summary.scalar('accuracy', evaluation_step)\n",
        "    return evaluation_step, prediction\n",
        "\n",
        "def run_final_eval(train_session, module_spec, class_count, image_lists,\n",
        "                   jpeg_data_tensor, decoded_image_tensor,\n",
        "                   resized_image_tensor, bottleneck_tensor):\n",
        "  test_bottlenecks, test_ground_truth, test_filenames = (\n",
        "      get_random_cached_bottlenecks(train_session, image_lists,\n",
        "                                    FLAGS.test_batch_size,\n",
        "                                    'testing', FLAGS.bottleneck_dir,\n",
        "                                    FLAGS.image_dir, jpeg_data_tensor,\n",
        "                                    decoded_image_tensor, resized_image_tensor,\n",
        "                                    bottleneck_tensor, FLAGS.tfhub_module))\n",
        "\n",
        "  (eval_session, _, bottleneck_input, ground_truth_input, evaluation_step,\n",
        "   prediction) = build_eval_session(module_spec, class_count)\n",
        "  try:\n",
        "    test_accuracy, predictions = eval_session.run(\n",
        "        [evaluation_step, prediction],\n",
        "        feed_dict={\n",
        "            bottleneck_input: test_bottlenecks,\n",
        "            ground_truth_input: test_ground_truth\n",
        "        })\n",
        "  except:\n",
        "    print('Final Test Failed, Moving on...')\n",
        "    return\n",
        "  logging.info('Final test accuracy = %.1f%% (N=%d)',\n",
        "               test_accuracy * 100, len(test_bottlenecks))\n",
        "\n",
        "  if FLAGS.print_misclassified_test_images:\n",
        "    logging.info('=== MISCLASSIFIED TEST IMAGES ===')\n",
        "    for i, test_filename in enumerate(test_filenames):\n",
        "      if predictions[i] != test_ground_truth[i]:\n",
        "        logging.info('%70s  %s', test_filename,\n",
        "                     list(image_lists.keys())[predictions[i]])\n",
        "\n",
        "def build_eval_session(module_spec, class_count):\n",
        "  with tf.device('/device:GPU:0'):\n",
        "    # If quantized, we need to create the correct eval graph for exporting.\n",
        "    eval_graph, bottleneck_tensor, resized_input_tensor, wants_quantization = (\n",
        "        create_module_graph(module_spec))\n",
        "\n",
        "    eval_sess = tf.Session(graph=eval_graph, config=tf.ConfigProto(allow_soft_placement=True, log_device_placement=True))\n",
        "    with eval_graph.as_default():\n",
        "      # Add the new layer for exporting.\n",
        "      (_, _, bottleneck_input,\n",
        "      ground_truth_input, final_tensor) = add_final_retrain_ops(\n",
        "          class_count, FLAGS.final_tensor_name, bottleneck_tensor,\n",
        "          wants_quantization, is_training=False)\n",
        "\n",
        "      # Now we need to restore the values from the training graph to the eval\n",
        "      # graph.\n",
        "      tf.train.Saver().restore(eval_sess, FLAGS.checkpoint_path)\n",
        "\n",
        "      evaluation_step, prediction = add_evaluation_step(final_tensor,\n",
        "                                                        ground_truth_input)\n",
        "\n",
        "    return (eval_sess, resized_input_tensor, bottleneck_input, ground_truth_input,\n",
        "            evaluation_step, prediction)\n",
        "\n",
        "def save_graph_to_file(graph_file_name, module_spec, class_count):\n",
        "  with tf.device('/device:GPU:0'):\n",
        "    \"\"\"Saves an graph to file, creating a valid quantized one if necessary.\"\"\"\n",
        "    sess, _, _, _, _, _ = build_eval_session(module_spec, class_count)\n",
        "    graph = sess.graph\n",
        "\n",
        "    output_graph_def = tf.graph_util.convert_variables_to_constants(\n",
        "        sess, graph.as_graph_def(), [FLAGS.final_tensor_name])\n",
        "\n",
        "    with tf.gfile.GFile(graph_file_name, 'wb') as f:\n",
        "      f.write(output_graph_def.SerializeToString())\n",
        "\n",
        "\n",
        "def prepare_file_system():\n",
        "  with tf.device('/device:GPU:0'):\n",
        "    # Set up the directory we'll write summaries to for TensorBoard\n",
        "    if tf.gfile.Exists(FLAGS.summaries_dir):\n",
        "      tf.gfile.DeleteRecursively(FLAGS.summaries_dir)\n",
        "    tf.gfile.MakeDirs(FLAGS.summaries_dir)\n",
        "    if FLAGS.intermediate_store_frequency > 0:\n",
        "      ensure_dir_exists(FLAGS.intermediate_output_graphs_dir)\n",
        "    return\n",
        "\n",
        "\n",
        "def add_jpeg_decoding(module_spec):\n",
        "  with tf.device('/device:GPU:0'):\n",
        "    input_height, input_width = hub.get_expected_image_size(module_spec)\n",
        "    input_depth = hub.get_num_image_channels(module_spec)\n",
        "    jpeg_data = tf.placeholder(tf.string, name='DecodeJPGInput')\n",
        "    decoded_image = tf.image.decode_jpeg(jpeg_data, channels=input_depth)\n",
        "    # Convert from full range of uint8 to range [0,1] of float32.\n",
        "    decoded_image_as_float = tf.image.convert_image_dtype(decoded_image,\n",
        "                                                          tf.float32)\n",
        "    decoded_image_4d = tf.expand_dims(decoded_image_as_float, 0)\n",
        "    resize_shape = tf.stack([input_height, input_width])\n",
        "    resize_shape_as_int = tf.cast(resize_shape, dtype=tf.int32)\n",
        "    resized_image = tf.image.resize_bilinear(decoded_image_4d,\n",
        "                                            resize_shape_as_int)\n",
        "    return jpeg_data, resized_image\n",
        "\n",
        "\n",
        "def export_model(module_spec, class_count, saved_model_dir):\n",
        "  # The SavedModel should hold the eval graph.\n",
        "  sess, in_image, _, _, _, _ = build_eval_session(module_spec, class_count)\n",
        "  with sess.graph.as_default() as graph:\n",
        "    tf.saved_model.simple_save(\n",
        "        sess,\n",
        "        saved_model_dir,\n",
        "        inputs={'image': in_image},\n",
        "        outputs={'prediction': graph.get_tensor_by_name('final_result:0')},\n",
        "        legacy_init_op=tf.group(tf.tables_initializer(), name='legacy_init_op')\n",
        "    )\n",
        "\n",
        "\n",
        "def logging_level_verbosity(logging_verbosity):\n",
        "  name_to_level = {\n",
        "      'FATAL': logging.FATAL,\n",
        "      'ERROR': logging.ERROR,\n",
        "      'WARN': logging.WARN,\n",
        "      'INFO': logging.INFO,\n",
        "      'DEBUG': logging.DEBUG\n",
        "  }\n",
        "\n",
        "  try:\n",
        "    return name_to_level[logging_verbosity]\n",
        "  except Exception as e:\n",
        "    raise RuntimeError('Not supported logs verbosity (%s). Use one of %s.' %\n",
        "                       (str(e), list(name_to_level)))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "06AUvFkFB4Ib",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def main(_):\n",
        "  with tf.device('/device:GPU:0'):\n",
        "    # Needed to make sure the logging output is visible.\n",
        "    # See https://github.com/tensorflow/tensorflow/issues/3047\n",
        "    logging_verbosity = logging_level_verbosity(FLAGS.logging_verbosity)\n",
        "    logging.set_verbosity(logging_verbosity)\n",
        "\n",
        "    if not FLAGS.image_dir:\n",
        "      logging.error('Must set flag --image_dir.')\n",
        "      return -1\n",
        "\n",
        "    # Prepare necessary directories that can be used during training\n",
        "    prepare_file_system()\n",
        "\n",
        "    # Look at the folder structure, and create lists of all the images.\n",
        "    image_lists = create_image_lists(FLAGS.image_dir, FLAGS.testing_percentage,\n",
        "                                    FLAGS.validation_percentage)\n",
        "    class_count = len(image_lists.keys())\n",
        "    if class_count == 0:\n",
        "      logging.error('No valid folders of images found at %s', FLAGS.image_dir)\n",
        "      return -1\n",
        "    if class_count == 1:\n",
        "      logging.error('Only one valid folder of images found at %s '\n",
        "                    ' - multiple classes are needed for classification.',\n",
        "                    FLAGS.image_dir)\n",
        "      return -1\n",
        "\n",
        "    # See if the command-line flags mean we're applying any distortions.\n",
        "    do_distort_images = should_distort_images(\n",
        "        FLAGS.flip_left_right, FLAGS.random_crop, FLAGS.random_scale,\n",
        "        FLAGS.random_brightness)\n",
        "\n",
        "    # Set up the pre-trained graph.\n",
        "    module_spec = hub.load_module_spec(FLAGS.tfhub_module)\n",
        "    graph, bottleneck_tensor, resized_image_tensor, wants_quantization = (\n",
        "        create_module_graph(module_spec))\n",
        "    \n",
        "      # Add the new layer that we'll be training.\n",
        "    with graph.as_default():\n",
        "      (train_step, cross_entropy, bottleneck_input,\n",
        "      ground_truth_input, final_tensor) = add_final_retrain_ops(\n",
        "          class_count, FLAGS.final_tensor_name, bottleneck_tensor,\n",
        "          wants_quantization, is_training=True)\n",
        "\n",
        "    with tf.Session(graph=graph, config=tf.ConfigProto(allow_soft_placement=True, log_device_placement=True)) as sess:\n",
        "      # Initialize all weights: for the module to their pretrained values,\n",
        "      # and for the newly added retraining layer to random initial values.\n",
        "      init = tf.global_variables_initializer()\n",
        "      sess.run(init)\n",
        "\n",
        "      # Set up the image decoding sub-graph.\n",
        "      jpeg_data_tensor, decoded_image_tensor = add_jpeg_decoding(module_spec)\n",
        "\n",
        "      if do_distort_images:\n",
        "        # We will be applying distortions, so set up the operations we'll need.\n",
        "        (distorted_jpeg_data_tensor,\n",
        "        distorted_image_tensor) = add_input_distortions(\n",
        "            FLAGS.flip_left_right, FLAGS.random_crop, FLAGS.random_scale,\n",
        "            FLAGS.random_brightness, module_spec)\n",
        "      else:\n",
        "        # We'll make sure we've calculated the 'bottleneck' image summaries and\n",
        "        # cached them on disk.\n",
        "        cache_bottlenecks(sess, image_lists, FLAGS.image_dir,\n",
        "                          FLAGS.bottleneck_dir, jpeg_data_tensor,\n",
        "                          decoded_image_tensor, resized_image_tensor,\n",
        "                          bottleneck_tensor, FLAGS.tfhub_module)\n",
        "\n",
        "      # Create the operations we need to evaluate the accuracy of our new layer.\n",
        "      evaluation_step, _ = add_evaluation_step(final_tensor, ground_truth_input)\n",
        "\n",
        "      # Merge all the summaries and write them out to the summaries_dir\n",
        "      merged = tf.summary.merge_all()\n",
        "      train_writer = tf.summary.FileWriter(FLAGS.summaries_dir + '/train',\n",
        "                                          sess.graph)\n",
        "      \n",
        "      validation_writer = tf.summary.FileWriter(\n",
        "          FLAGS.summaries_dir + '/validation')\n",
        "\n",
        "      # Create a train saver that is used to restore values into an eval graph\n",
        "      # when exporting models.\n",
        "      train_saver = tf.train.Saver()\n",
        "\n",
        "      # Run the training for as many cycles as requested on the command line.\n",
        "      for i in range(FLAGS.how_many_training_steps):\n",
        "        # Get a batch of input bottleneck values, either calculated fresh every\n",
        "        # time with distortions applied, or from the cache stored on disk.\n",
        "        if do_distort_images:\n",
        "          (train_bottlenecks,\n",
        "          train_ground_truth) = get_random_distorted_bottlenecks(\n",
        "              sess, image_lists, FLAGS.train_batch_size, 'training',\n",
        "              FLAGS.image_dir, distorted_jpeg_data_tensor,\n",
        "              distorted_image_tensor, resized_image_tensor, bottleneck_tensor)\n",
        "        else:\n",
        "          (train_bottlenecks,\n",
        "          train_ground_truth, _) = get_random_cached_bottlenecks(\n",
        "              sess, image_lists, FLAGS.train_batch_size, 'training',\n",
        "              FLAGS.bottleneck_dir, FLAGS.image_dir, jpeg_data_tensor,\n",
        "              decoded_image_tensor, resized_image_tensor, bottleneck_tensor,\n",
        "              FLAGS.tfhub_module)\n",
        "        # Feed the bottlenecks and ground truth into the graph, and run a training\n",
        "        # step. Capture training summaries for TensorBoard with the `merged` op.\n",
        "        train_summary, _ = sess.run(\n",
        "            [merged, train_step],\n",
        "            feed_dict={bottleneck_input: train_bottlenecks,\n",
        "                      ground_truth_input: train_ground_truth})\n",
        "        train_writer.add_summary(train_summary, i)\n",
        "\n",
        "        # Every so often, print out how well the graph is training.\n",
        "        is_last_step = (i + 1 == FLAGS.how_many_training_steps)\n",
        "        if (i % FLAGS.eval_step_interval) == 0 or is_last_step:\n",
        "          train_accuracy, cross_entropy_value = sess.run(\n",
        "              [evaluation_step, cross_entropy],\n",
        "              feed_dict={bottleneck_input: train_bottlenecks,\n",
        "                                                ground_truth_input: train_ground_truth})\n",
        "          logging.info('%s: Step %d: Train accuracy = %.1f%%',\n",
        "                      datetime.now(), i, train_accuracy * 100)\n",
        "          logging.info('%s: Step %d: Cross entropy = %f',\n",
        "                      datetime.now(), i, cross_entropy_value)\n",
        "          # TODO: Make this use an eval graph, to avoid quantization\n",
        "          # moving averages being updated by the validation set, though in\n",
        "          # practice this makes a negligable difference.\n",
        "          validation_bottlenecks, validation_ground_truth, _ = (\n",
        "              get_random_cached_bottlenecks(\n",
        "                  sess, image_lists, FLAGS.validation_batch_size, 'validation',\n",
        "                  FLAGS.bottleneck_dir, FLAGS.image_dir, jpeg_data_tensor,\n",
        "                  decoded_image_tensor, resized_image_tensor, bottleneck_tensor,\n",
        "                  FLAGS.tfhub_module))\n",
        "          # Run a validation step and capture training summaries for TensorBoard\n",
        "          # with the `merged` op.\n",
        "          validation_summary, validation_accuracy = sess.run(\n",
        "              [merged, evaluation_step],\n",
        "              feed_dict={bottleneck_input: validation_bottlenecks,\n",
        "                        ground_truth_input: validation_ground_truth})\n",
        "          validation_writer.add_summary(validation_summary, i)\n",
        "          logging.info('%s: Step %d: Validation accuracy = %.1f%% (N=%d)',\n",
        "                      datetime.now(), i, validation_accuracy * 100,\n",
        "                      len(validation_bottlenecks))\n",
        "\n",
        "        # Store intermediate results\n",
        "        intermediate_frequency = FLAGS.intermediate_store_frequency\n",
        "\n",
        "        if (intermediate_frequency > 0 and (i % intermediate_frequency == 0)\n",
        "            and i > 0):\n",
        "          # If we want to do an intermediate save, save a checkpoint of the train\n",
        "          # graph, to restore into the eval graph.\n",
        "          train_saver.save(sess, FLAGS.checkpoint_path)\n",
        "          intermediate_file_name = (FLAGS.intermediate_output_graphs_dir +\n",
        "                                    'intermediate_' + str(i) + '.pb')\n",
        "          logging.info('Save intermediate result to : %s', intermediate_file_name)\n",
        "          save_graph_to_file(intermediate_file_name, module_spec,\n",
        "                            class_count)\n",
        "          \n",
        "          \n",
        "      # After training is complete, force one last save of the train checkpoint.\n",
        "      train_saver.save(sess, FLAGS.checkpoint_path)\n",
        "\n",
        "      # We've completed all our training, so run a final test evaluation on\n",
        "      # some new images we haven't used before.\n",
        "      run_final_eval(sess, module_spec, class_count, image_lists,\n",
        "                    jpeg_data_tensor, decoded_image_tensor, resized_image_tensor,\n",
        "                    bottleneck_tensor)\n",
        "\n",
        "      # Write out the trained graph and labels with the weights stored as\n",
        "      # constants.\n",
        "      logging.info('Save final result to : %s', FLAGS.output_graph)\n",
        "      if wants_quantization:\n",
        "        logging.info('The model is instrumented for quantization with TF-Lite')\n",
        "      save_graph_to_file(FLAGS.output_graph, module_spec, class_count)\n",
        "      with tf.gfile.GFile(FLAGS.output_labels, 'w') as f:\n",
        "        f.write('\\n'.join(image_lists.keys()) + '\\n')\n",
        "\n",
        "      if FLAGS.saved_model_dir:\n",
        "        export_model(module_spec, class_count, FLAGS.saved_model_dir)\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JK3dQUJTDRbn",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "outputId": "316221da-f000-4c27-8549-3538304f85cb"
      },
      "source": [
        "if __name__ == '__main__':\n",
        "  if not os.path.isdir(\"/content/drive/My Drive/TensorFlow_model/tmp/retrain_tmp\"):\n",
        "    os.mkdir(\"/content/drive/My Drive/TensorFlow_model/tmp/retrain_tmp\")\n",
        "  parser = argparse.ArgumentParser()\n",
        "  parser.add_argument(\n",
        "      '--image_dir',\n",
        "      type=str,\n",
        "      default='/content/drive/My Drive/TensorFlow_model/training_data/',\n",
        "      help='Path to folders of labeled images.'\n",
        "  )\n",
        "  parser.add_argument(\n",
        "      '--output_graph',\n",
        "      type=str,\n",
        "      default='/content/drive/My Drive/TensorFlow_model/tmp/retrain_tmp/output_graph.pb',\n",
        "      help='Where to save the trained graph.'\n",
        "  )\n",
        "  parser.add_argument(\n",
        "      '--intermediate_output_graphs_dir',\n",
        "      type=str,\n",
        "      default='/content/drive/My Drive/TensorFlow_model/tmp/retrain_tmp/intermediate_graph/',\n",
        "      help='Where to save the intermediate graphs.'\n",
        "  )\n",
        "  parser.add_argument(\n",
        "      '--intermediate_store_frequency',\n",
        "      type=int,\n",
        "      default=0,\n",
        "      help=\"\"\"\\\n",
        "         How many steps to store intermediate graph. If \"0\" then will not\n",
        "         store.\\\n",
        "      \"\"\"\n",
        "  )\n",
        "  parser.add_argument(\n",
        "      '--output_labels',\n",
        "      type=str,\n",
        "      default='/content/drive/My Drive/TensorFlow_model/tmp/retrain_tmp/output_labels.txt',\n",
        "      help='Where to save the trained graph\\'s labels.'\n",
        "  )\n",
        "  parser.add_argument(\n",
        "      '--summaries_dir',\n",
        "      type=str,\n",
        "      default='/content/drive/My Drive/TensorFlow_model/tmp/retrain_tmp/retrain_logs',\n",
        "      help='Where to save summary logs for TensorBoard.'\n",
        "  )\n",
        "  parser.add_argument(\n",
        "      '--how_many_training_steps',\n",
        "      type=int,\n",
        "      default=4000,\n",
        "      help='How many training steps to run before ending.'\n",
        "  )\n",
        "  parser.add_argument(\n",
        "      '--learning_rate',\n",
        "      type=float,\n",
        "      default=0.01,\n",
        "      help='How large a learning rate to use when training.'\n",
        "  )\n",
        "  parser.add_argument(\n",
        "      '--testing_percentage',\n",
        "      type=int,\n",
        "      default=10,\n",
        "      help='What percentage of images to use as a test set.'\n",
        "  )\n",
        "  parser.add_argument(\n",
        "      '--validation_percentage',\n",
        "      type=int,\n",
        "      default=10,\n",
        "      help='What percentage of images to use as a validation set.'\n",
        "  )\n",
        "  parser.add_argument(\n",
        "      '--eval_step_interval',\n",
        "      type=int,\n",
        "      default=10,\n",
        "      help='How often to evaluate the training results.'\n",
        "  )\n",
        "  parser.add_argument(\n",
        "      '--train_batch_size',\n",
        "      type=int,\n",
        "      default=100,\n",
        "      help='How many images to train on at a time.'\n",
        "  )\n",
        "  parser.add_argument(\n",
        "      '--test_batch_size',\n",
        "      type=int,\n",
        "      default=-1,\n",
        "      help=\"\"\"\\\n",
        "      How many images to test on. This test set is only used once, to evaluate\n",
        "      the final accuracy of the model after training completes.\n",
        "      A value of -1 causes the entire test set to be used, which leads to more\n",
        "      stable results across runs.\\\n",
        "      \"\"\"\n",
        "  )\n",
        "  parser.add_argument(\n",
        "      '--validation_batch_size',\n",
        "      type=int,\n",
        "      default=100,\n",
        "      help=\"\"\"\\\n",
        "      How many images to use in an evaluation batch. This validation set is\n",
        "      used much more often than the test set, and is an early indicator of how\n",
        "      accurate the model is during training.\n",
        "      A value of -1 causes the entire validation set to be used, which leads to\n",
        "      more stable results across training iterations, but may be slower on large\n",
        "      training sets.\\\n",
        "      \"\"\"\n",
        "  )\n",
        "  parser.add_argument(\n",
        "      '--print_misclassified_test_images',\n",
        "      default=False,\n",
        "      help=\"\"\"\\\n",
        "      Whether to print out a list of all misclassified test images.\\\n",
        "      \"\"\",\n",
        "      action='store_true'\n",
        "  )\n",
        "  parser.add_argument(\n",
        "      '--bottleneck_dir',\n",
        "      type=str,\n",
        "      default='/content/drive/My Drive/TensorFlow_model/tmp/retrain_tmp/bottleneck',\n",
        "      help='Path to cache bottleneck layer values as files.'\n",
        "  )\n",
        "  parser.add_argument(\n",
        "      '--final_tensor_name',\n",
        "      type=str,\n",
        "      default='final_result',\n",
        "      help=\"\"\"\\\n",
        "      The name of the output classification layer in the retrained graph.\\\n",
        "      \"\"\"\n",
        "  )\n",
        "  parser.add_argument(\n",
        "      '--flip_left_right',\n",
        "      default=False,\n",
        "      help=\"\"\"\\\n",
        "      Whether to randomly flip half of the training images horizontally.\\\n",
        "      \"\"\",\n",
        "      action='store_true'\n",
        "  )\n",
        "  parser.add_argument(\n",
        "      '--random_crop',\n",
        "      type=int,\n",
        "      default=0,\n",
        "      help=\"\"\"\\\n",
        "      A percentage determining how much of a margin to randomly crop off the\n",
        "      training images.\\\n",
        "      \"\"\"\n",
        "  )\n",
        "  parser.add_argument(\n",
        "      '--random_scale',\n",
        "      type=int,\n",
        "      default=0,\n",
        "      help=\"\"\"\\\n",
        "      A percentage determining how much to randomly scale up the size of the\n",
        "      training images by.\\\n",
        "      \"\"\"\n",
        "  )\n",
        "  parser.add_argument(\n",
        "      '--random_brightness',\n",
        "      type=int,\n",
        "      default=0,\n",
        "      help=\"\"\"\\\n",
        "      A percentage determining how much to randomly multiply the training image\n",
        "      input pixels up or down by.\\\n",
        "      \"\"\"\n",
        "  )\n",
        "  parser.add_argument(\n",
        "      '--tfhub_module',\n",
        "      type=str,\n",
        "      default=(\n",
        "          'https://tfhub.dev/google/imagenet/inception_v3/feature_vector/3'),\n",
        "      help=\"\"\"\\\n",
        "      Which TensorFlow Hub module to use. For more options,\n",
        "      search https://tfhub.dev for image feature vector modules.\\\n",
        "      \"\"\")\n",
        "  parser.add_argument(\n",
        "      '--saved_model_dir',\n",
        "      type=str,\n",
        "      default='',\n",
        "      help='Where to save the exported graph.')\n",
        "  parser.add_argument(\n",
        "      '--logging_verbosity',\n",
        "      type=str,\n",
        "      default='INFO',\n",
        "      choices=['DEBUG', 'INFO', 'WARN', 'ERROR', 'FATAL'],\n",
        "      help='How much logging output should be produced.')\n",
        "  parser.add_argument(\n",
        "      '--checkpoint_path',\n",
        "      type=str,\n",
        "      default='/content/drive/My Drive/TensorFlow_model/tmp/retrain_tmp/_retrain_checkpoint',\n",
        "      help='Where to save checkpoint files.'\n",
        "  )\n",
        "  FLAGS, unparsed = parser.parse_known_args()\n",
        "  with tf.device('/device:GPU:0'):\n",
        "    tf.app.run(main=main, argv=[sys.argv[0]] + unparsed)"
      ],
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "I1227 00:32:45.384862 140210095409024 <ipython-input-13-b93e9db069e1>:24] Looking for images in 'Candy Canes'\n",
            "I1227 00:32:48.451291 140210095409024 <ipython-input-13-b93e9db069e1>:24] Looking for images in 'Christmas Trees'\n",
            "I1227 00:32:50.706753 140210095409024 <ipython-input-13-b93e9db069e1>:24] Looking for images in 'Ornaments'\n",
            "I1227 00:32:52.993061 140210095409024 <ipython-input-13-b93e9db069e1>:24] Looking for images in 'Presents'\n",
            "I1227 00:32:55.281810 140210095409024 <ipython-input-13-b93e9db069e1>:24] Looking for images in 'Santa Hats'\n",
            "I1227 00:32:57.566283 140210095409024 <ipython-input-13-b93e9db069e1>:24] Looking for images in 'Stockings'\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Saver not created because there are no variables in the graph to restore\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "I1227 00:33:03.790576 140210095409024 saver.py:1503] Saver not created because there are no variables in the graph to restore\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "Device mapping:\n",
            "/job:localhost/replica:0/task:0/device:XLA_CPU:0 -> device: XLA_CPU device\n",
            "/job:localhost/replica:0/task:0/device:XLA_GPU:0 -> device: XLA_GPU device\n",
            "/job:localhost/replica:0/task:0/device:GPU:0 -> device: 0, name: Tesla P100-PCIE-16GB, pci bus id: 0000:00:04.0, compute capability: 6.0\n",
            "\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "I1227 00:34:29.046128 140210095409024 <ipython-input-13-b93e9db069e1>:189] 100 bottleneck files created.\n",
            "I1227 00:35:20.337855 140210095409024 <ipython-input-13-b93e9db069e1>:189] 200 bottleneck files created.\n",
            "I1227 00:36:09.382315 140210095409024 <ipython-input-13-b93e9db069e1>:189] 300 bottleneck files created.\n",
            "I1227 00:36:55.923660 140210095409024 <ipython-input-13-b93e9db069e1>:189] 400 bottleneck files created.\n",
            "I1227 00:37:45.665906 140210095409024 <ipython-input-13-b93e9db069e1>:189] 500 bottleneck files created.\n",
            "I1227 00:38:32.095029 140210095409024 <ipython-input-13-b93e9db069e1>:189] 600 bottleneck files created.\n",
            "I1227 00:39:19.366408 140210095409024 <ipython-input-13-b93e9db069e1>:189] 700 bottleneck files created.\n",
            "I1227 00:40:04.035723 140210095409024 <ipython-input-13-b93e9db069e1>:189] 800 bottleneck files created.\n",
            "I1227 00:40:50.161872 140210095409024 <ipython-input-13-b93e9db069e1>:189] 900 bottleneck files created.\n",
            "I1227 00:41:42.804122 140210095409024 <ipython-input-13-b93e9db069e1>:189] 1000 bottleneck files created.\n",
            "I1227 00:42:31.253220 140210095409024 <ipython-input-13-b93e9db069e1>:189] 1100 bottleneck files created.\n",
            "I1227 00:43:16.360126 140210095409024 <ipython-input-13-b93e9db069e1>:189] 1200 bottleneck files created.\n",
            "I1227 00:44:04.005849 140210095409024 <ipython-input-13-b93e9db069e1>:189] 1300 bottleneck files created.\n",
            "I1227 00:44:57.402349 140210095409024 <ipython-input-13-b93e9db069e1>:189] 1400 bottleneck files created.\n",
            "I1227 00:45:41.755177 140210095409024 <ipython-input-13-b93e9db069e1>:189] 1500 bottleneck files created.\n",
            "I1227 00:46:29.196559 140210095409024 <ipython-input-13-b93e9db069e1>:189] 1600 bottleneck files created.\n",
            "I1227 00:47:32.820441 140210095409024 <ipython-input-13-b93e9db069e1>:189] 1700 bottleneck files created.\n",
            "I1227 00:48:26.696204 140210095409024 <ipython-input-13-b93e9db069e1>:189] 1800 bottleneck files created.\n",
            "I1227 00:49:14.720338 140210095409024 <ipython-input-13-b93e9db069e1>:189] 1900 bottleneck files created.\n",
            "I1227 00:50:00.098386 140210095409024 <ipython-input-13-b93e9db069e1>:189] 2000 bottleneck files created.\n",
            "I1227 00:50:53.713330 140210095409024 <ipython-input-13-b93e9db069e1>:189] 2100 bottleneck files created.\n",
            "I1227 00:51:42.514392 140210095409024 <ipython-input-13-b93e9db069e1>:189] 2200 bottleneck files created.\n",
            "I1227 00:52:33.632759 140210095409024 <ipython-input-13-b93e9db069e1>:189] 2300 bottleneck files created.\n",
            "I1227 00:53:23.592485 140210095409024 <ipython-input-13-b93e9db069e1>:189] 2400 bottleneck files created.\n",
            "I1227 00:54:11.896139 140210095409024 <ipython-input-13-b93e9db069e1>:189] 2500 bottleneck files created.\n",
            "I1227 00:55:04.012300 140210095409024 <ipython-input-13-b93e9db069e1>:189] 2600 bottleneck files created.\n",
            "I1227 00:55:53.572385 140210095409024 <ipython-input-13-b93e9db069e1>:189] 2700 bottleneck files created.\n",
            "I1227 00:56:40.846087 140210095409024 <ipython-input-13-b93e9db069e1>:189] 2800 bottleneck files created.\n",
            "I1227 00:57:33.234472 140210095409024 <ipython-input-13-b93e9db069e1>:189] 2900 bottleneck files created.\n",
            "I1227 00:58:24.773664 140210095409024 <ipython-input-13-b93e9db069e1>:189] 3000 bottleneck files created.\n",
            "I1227 00:59:14.158128 140210095409024 <ipython-input-13-b93e9db069e1>:189] 3100 bottleneck files created.\n",
            "I1227 01:00:02.912268 140210095409024 <ipython-input-13-b93e9db069e1>:189] 3200 bottleneck files created.\n",
            "I1227 01:00:50.903282 140210095409024 <ipython-input-13-b93e9db069e1>:189] 3300 bottleneck files created.\n",
            "I1227 01:01:39.967867 140210095409024 <ipython-input-13-b93e9db069e1>:189] 3400 bottleneck files created.\n",
            "I1227 01:02:32.265824 140210095409024 <ipython-input-13-b93e9db069e1>:189] 3500 bottleneck files created.\n",
            "I1227 01:03:21.685975 140210095409024 <ipython-input-13-b93e9db069e1>:189] 3600 bottleneck files created.\n",
            "I1227 01:04:09.959942 140210095409024 <ipython-input-13-b93e9db069e1>:189] 3700 bottleneck files created.\n",
            "I1227 01:04:59.973708 140210095409024 <ipython-input-13-b93e9db069e1>:189] 3800 bottleneck files created.\n",
            "I1227 01:05:48.084208 140210095409024 <ipython-input-13-b93e9db069e1>:189] 3900 bottleneck files created.\n",
            "I1227 01:06:37.656033 140210095409024 <ipython-input-13-b93e9db069e1>:189] 4000 bottleneck files created.\n",
            "I1227 01:07:26.137259 140210095409024 <ipython-input-13-b93e9db069e1>:189] 4100 bottleneck files created.\n",
            "I1227 01:08:12.794007 140210095409024 <ipython-input-13-b93e9db069e1>:189] 4200 bottleneck files created.\n",
            "I1227 01:09:06.176425 140210095409024 <ipython-input-13-b93e9db069e1>:189] 4300 bottleneck files created.\n",
            "I1227 01:09:53.859914 140210095409024 <ipython-input-13-b93e9db069e1>:189] 4400 bottleneck files created.\n",
            "I1227 01:10:44.559027 140210095409024 <ipython-input-13-b93e9db069e1>:189] 4500 bottleneck files created.\n",
            "I1227 01:11:35.104601 140210095409024 <ipython-input-13-b93e9db069e1>:189] 4600 bottleneck files created.\n",
            "I1227 01:12:25.688916 140210095409024 <ipython-input-13-b93e9db069e1>:189] 4700 bottleneck files created.\n",
            "I1227 01:13:11.151933 140210095409024 <ipython-input-13-b93e9db069e1>:189] 4800 bottleneck files created.\n",
            "I1227 01:13:59.727762 140210095409024 <ipython-input-13-b93e9db069e1>:189] 4900 bottleneck files created.\n",
            "I1227 01:14:52.597862 140210095409024 <ipython-input-13-b93e9db069e1>:189] 5000 bottleneck files created.\n",
            "I1227 01:15:41.985110 140210095409024 <ipython-input-13-b93e9db069e1>:189] 5100 bottleneck files created.\n",
            "I1227 01:16:31.742257 140210095409024 <ipython-input-13-b93e9db069e1>:189] 5200 bottleneck files created.\n",
            "I1227 01:17:23.234367 140210095409024 <ipython-input-13-b93e9db069e1>:189] 5300 bottleneck files created.\n",
            "I1227 01:18:09.973340 140210095409024 <ipython-input-13-b93e9db069e1>:189] 5400 bottleneck files created.\n",
            "I1227 01:18:58.907669 140210095409024 <ipython-input-13-b93e9db069e1>:189] 5500 bottleneck files created.\n",
            "I1227 01:19:49.031636 140210095409024 <ipython-input-13-b93e9db069e1>:189] 5600 bottleneck files created.\n",
            "I1227 01:20:42.362360 140210095409024 <ipython-input-13-b93e9db069e1>:189] 5700 bottleneck files created.\n",
            "I1227 01:21:30.907238 140210095409024 <ipython-input-13-b93e9db069e1>:189] 5800 bottleneck files created.\n",
            "I1227 01:22:25.396067 140210095409024 <ipython-input-13-b93e9db069e1>:189] 5900 bottleneck files created.\n",
            "I1227 01:23:13.213881 140210095409024 <ipython-input-13-b93e9db069e1>:189] 6000 bottleneck files created.\n",
            "I1227 01:24:02.788134 140210095409024 <ipython-input-13-b93e9db069e1>:189] 6100 bottleneck files created.\n",
            "I1227 01:24:51.041478 140210095409024 <ipython-input-13-b93e9db069e1>:189] 6200 bottleneck files created.\n",
            "I1227 01:25:36.138770 140210095409024 <ipython-input-13-b93e9db069e1>:189] 6300 bottleneck files created.\n",
            "I1227 01:26:27.894728 140210095409024 <ipython-input-13-b93e9db069e1>:189] 6400 bottleneck files created.\n",
            "I1227 01:27:14.706475 140210095409024 <ipython-input-13-b93e9db069e1>:189] 6500 bottleneck files created.\n",
            "I1227 01:28:03.464632 140210095409024 <ipython-input-13-b93e9db069e1>:189] 6600 bottleneck files created.\n",
            "I1227 01:28:51.069372 140210095409024 <ipython-input-13-b93e9db069e1>:189] 6700 bottleneck files created.\n",
            "I1227 01:29:35.726366 140210095409024 <ipython-input-13-b93e9db069e1>:189] 6800 bottleneck files created.\n",
            "I1227 01:30:23.359564 140210095409024 <ipython-input-13-b93e9db069e1>:189] 6900 bottleneck files created.\n",
            "I1227 01:31:09.877540 140210095409024 <ipython-input-13-b93e9db069e1>:189] 7000 bottleneck files created.\n",
            "I1227 01:31:59.516408 140210095409024 <ipython-input-13-b93e9db069e1>:189] 7100 bottleneck files created.\n",
            "I1227 01:32:52.493795 140210095409024 <ipython-input-13-b93e9db069e1>:189] 7200 bottleneck files created.\n",
            "I1227 01:33:50.784548 140210095409024 <ipython-input-13-b93e9db069e1>:189] 7300 bottleneck files created.\n",
            "I1227 01:34:43.059052 140210095409024 <ipython-input-13-b93e9db069e1>:189] 7400 bottleneck files created.\n",
            "I1227 01:35:31.528258 140210095409024 <ipython-input-13-b93e9db069e1>:189] 7500 bottleneck files created.\n",
            "I1227 01:36:18.954046 140210095409024 <ipython-input-13-b93e9db069e1>:189] 7600 bottleneck files created.\n",
            "I1227 01:37:05.371989 140210095409024 <ipython-input-13-b93e9db069e1>:189] 7700 bottleneck files created.\n",
            "I1227 01:37:55.588303 140210095409024 <ipython-input-13-b93e9db069e1>:189] 7800 bottleneck files created.\n",
            "I1227 01:38:43.821139 140210095409024 <ipython-input-13-b93e9db069e1>:189] 7900 bottleneck files created.\n",
            "I1227 01:39:32.866828 140210095409024 <ipython-input-13-b93e9db069e1>:189] 8000 bottleneck files created.\n",
            "I1227 01:40:19.416718 140210095409024 <ipython-input-13-b93e9db069e1>:189] 8100 bottleneck files created.\n",
            "I1227 01:41:05.610766 140210095409024 <ipython-input-13-b93e9db069e1>:189] 8200 bottleneck files created.\n",
            "I1227 01:41:51.716077 140210095409024 <ipython-input-13-b93e9db069e1>:189] 8300 bottleneck files created.\n",
            "I1227 01:42:38.619729 140210095409024 <ipython-input-13-b93e9db069e1>:189] 8400 bottleneck files created.\n",
            "I1227 01:43:25.083030 140210095409024 <ipython-input-13-b93e9db069e1>:189] 8500 bottleneck files created.\n",
            "I1227 01:44:10.709593 140210095409024 <ipython-input-13-b93e9db069e1>:189] 8600 bottleneck files created.\n",
            "I1227 01:44:59.929131 140210095409024 <ipython-input-13-b93e9db069e1>:189] 8700 bottleneck files created.\n",
            "I1227 01:45:47.160819 140210095409024 <ipython-input-13-b93e9db069e1>:189] 8800 bottleneck files created.\n",
            "I1227 01:46:36.112142 140210095409024 <ipython-input-13-b93e9db069e1>:189] 8900 bottleneck files created.\n",
            "I1227 01:47:23.562791 140210095409024 <ipython-input-13-b93e9db069e1>:189] 9000 bottleneck files created.\n",
            "I1227 01:48:12.425068 140210095409024 <ipython-input-13-b93e9db069e1>:189] 9100 bottleneck files created.\n",
            "I1227 01:49:00.154718 140210095409024 <ipython-input-13-b93e9db069e1>:189] 9200 bottleneck files created.\n",
            "I1227 01:49:49.255981 140210095409024 <ipython-input-13-b93e9db069e1>:189] 9300 bottleneck files created.\n",
            "I1227 01:50:37.220627 140210095409024 <ipython-input-13-b93e9db069e1>:189] 9400 bottleneck files created.\n",
            "I1227 01:51:22.836952 140210095409024 <ipython-input-13-b93e9db069e1>:189] 9500 bottleneck files created.\n",
            "I1227 01:52:10.131406 140210095409024 <ipython-input-13-b93e9db069e1>:189] 9600 bottleneck files created.\n",
            "I1227 01:53:03.524147 140210095409024 <ipython-input-13-b93e9db069e1>:189] 9700 bottleneck files created.\n",
            "I1227 01:53:54.033893 140210095409024 <ipython-input-13-b93e9db069e1>:189] 9800 bottleneck files created.\n",
            "I1227 01:54:44.823198 140210095409024 <ipython-input-13-b93e9db069e1>:189] 9900 bottleneck files created.\n",
            "I1227 01:55:34.081524 140210095409024 <ipython-input-13-b93e9db069e1>:189] 10000 bottleneck files created.\n",
            "I1227 01:56:23.135633 140210095409024 <ipython-input-13-b93e9db069e1>:189] 10100 bottleneck files created.\n",
            "I1227 01:57:15.440411 140210095409024 <ipython-input-13-b93e9db069e1>:189] 10200 bottleneck files created.\n",
            "I1227 01:58:09.502332 140210095409024 <ipython-input-13-b93e9db069e1>:189] 10300 bottleneck files created.\n",
            "I1227 01:58:58.583506 140210095409024 <ipython-input-13-b93e9db069e1>:189] 10400 bottleneck files created.\n",
            "I1227 01:59:49.603407 140210095409024 <ipython-input-13-b93e9db069e1>:189] 10500 bottleneck files created.\n",
            "I1227 02:00:40.815188 140210095409024 <ipython-input-13-b93e9db069e1>:189] 10600 bottleneck files created.\n",
            "I1227 02:01:30.452938 140210095409024 <ipython-input-13-b93e9db069e1>:189] 10700 bottleneck files created.\n",
            "I1227 02:02:21.467549 140210095409024 <ipython-input-13-b93e9db069e1>:189] 10800 bottleneck files created.\n",
            "I1227 02:03:12.530122 140210095409024 <ipython-input-13-b93e9db069e1>:189] 10900 bottleneck files created.\n",
            "I1227 02:04:07.111883 140210095409024 <ipython-input-13-b93e9db069e1>:189] 11000 bottleneck files created.\n",
            "I1227 02:04:59.495497 140210095409024 <ipython-input-13-b93e9db069e1>:189] 11100 bottleneck files created.\n",
            "I1227 02:05:50.679868 140210095409024 <ipython-input-13-b93e9db069e1>:189] 11200 bottleneck files created.\n",
            "I1227 02:06:40.616204 140210095409024 <ipython-input-13-b93e9db069e1>:189] 11300 bottleneck files created.\n",
            "I1227 02:07:40.405555 140210095409024 <ipython-input-13-b93e9db069e1>:189] 11400 bottleneck files created.\n",
            "I1227 02:08:30.668843 140210095409024 <ipython-input-13-b93e9db069e1>:189] 11500 bottleneck files created.\n",
            "I1227 02:09:18.849903 140210095409024 <ipython-input-13-b93e9db069e1>:189] 11600 bottleneck files created.\n",
            "I1227 02:10:09.101086 140210095409024 <ipython-input-13-b93e9db069e1>:189] 11700 bottleneck files created.\n",
            "I1227 02:10:58.366756 140210095409024 <ipython-input-13-b93e9db069e1>:189] 11800 bottleneck files created.\n",
            "I1227 02:11:47.190813 140210095409024 <ipython-input-13-b93e9db069e1>:189] 11900 bottleneck files created.\n",
            "I1227 02:12:30.509256 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:12:30.509141: Step 0: Train accuracy = 52.0%\n",
            "I1227 02:12:30.510469 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:12:30.510442: Step 0: Cross entropy = 1.694867\n",
            "I1227 02:12:31.488454 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:12:31.488319: Step 0: Validation accuracy = 52.0% (N=100)\n",
            "I1227 02:12:34.938632 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:12:34.938529: Step 10: Train accuracy = 98.0%\n",
            "I1227 02:12:34.939878 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:12:34.939858: Step 10: Cross entropy = 1.110401\n",
            "I1227 02:12:35.263027 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:12:35.262904: Step 10: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:12:38.622539 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:12:38.622437: Step 20: Train accuracy = 100.0%\n",
            "I1227 02:12:38.623763 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:12:38.623741: Step 20: Cross entropy = 0.794858\n",
            "I1227 02:12:38.946636 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:12:38.946550: Step 20: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:12:42.146626 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:12:42.146506: Step 30: Train accuracy = 99.0%\n",
            "I1227 02:12:42.148146 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:12:42.148125: Step 30: Cross entropy = 0.575402\n",
            "I1227 02:12:42.475691 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:12:42.475597: Step 30: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:12:45.836058 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:12:45.835932: Step 40: Train accuracy = 99.0%\n",
            "I1227 02:12:45.837406 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:12:45.837385: Step 40: Cross entropy = 0.480595\n",
            "I1227 02:12:46.192227 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:12:46.192113: Step 40: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:12:49.760162 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:12:49.760025: Step 50: Train accuracy = 100.0%\n",
            "I1227 02:12:49.761464 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:12:49.761443: Step 50: Cross entropy = 0.352687\n",
            "I1227 02:12:50.076669 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:12:50.076564: Step 50: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:12:53.433550 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:12:53.433460: Step 60: Train accuracy = 98.0%\n",
            "I1227 02:12:53.434791 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:12:53.434769: Step 60: Cross entropy = 0.354714\n",
            "I1227 02:12:53.765873 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:12:53.765780: Step 60: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:12:57.185741 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:12:57.185649: Step 70: Train accuracy = 100.0%\n",
            "I1227 02:12:57.187356 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:12:57.187329: Step 70: Cross entropy = 0.272299\n",
            "I1227 02:12:57.554557 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:12:57.554463: Step 70: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:13:00.960946 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:13:00.960839: Step 80: Train accuracy = 100.0%\n",
            "I1227 02:13:00.963086 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:13:00.963058: Step 80: Cross entropy = 0.236215\n",
            "I1227 02:13:01.264791 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:13:01.264699: Step 80: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:13:04.561809 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:13:04.561701: Step 90: Train accuracy = 100.0%\n",
            "I1227 02:13:04.562859 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:13:04.562837: Step 90: Cross entropy = 0.233403\n",
            "I1227 02:13:04.860598 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:13:04.860489: Step 90: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:13:08.273887 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:13:08.273772: Step 100: Train accuracy = 100.0%\n",
            "I1227 02:13:08.274890 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:13:08.274864: Step 100: Cross entropy = 0.188768\n",
            "I1227 02:13:08.579928 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:13:08.579841: Step 100: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:13:11.939504 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:13:11.939388: Step 110: Train accuracy = 100.0%\n",
            "I1227 02:13:11.947074 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:13:11.947038: Step 110: Cross entropy = 0.186837\n",
            "I1227 02:13:12.256575 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:13:12.256469: Step 110: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:13:15.686109 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:13:15.685948: Step 120: Train accuracy = 100.0%\n",
            "I1227 02:13:15.687410 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:13:15.687381: Step 120: Cross entropy = 0.163156\n",
            "I1227 02:13:16.028993 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:13:16.028861: Step 120: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:13:19.420005 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:13:19.419901: Step 130: Train accuracy = 100.0%\n",
            "I1227 02:13:19.421529 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:13:19.421507: Step 130: Cross entropy = 0.162501\n",
            "I1227 02:13:19.733654 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:13:19.733559: Step 130: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:13:22.959424 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:13:22.959325: Step 140: Train accuracy = 100.0%\n",
            "I1227 02:13:22.960626 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:13:22.960604: Step 140: Cross entropy = 0.143940\n",
            "I1227 02:13:23.284027 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:13:23.283915: Step 140: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:13:26.609755 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:13:26.609626: Step 150: Train accuracy = 100.0%\n",
            "I1227 02:13:26.612087 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:13:26.612058: Step 150: Cross entropy = 0.127049\n",
            "I1227 02:13:26.942783 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:13:26.942674: Step 150: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:13:30.325821 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:13:30.325724: Step 160: Train accuracy = 100.0%\n",
            "I1227 02:13:30.327204 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:13:30.327180: Step 160: Cross entropy = 0.121180\n",
            "I1227 02:13:30.664914 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:13:30.664829: Step 160: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:13:34.170921 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:13:34.170820: Step 170: Train accuracy = 100.0%\n",
            "I1227 02:13:34.172193 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:13:34.172172: Step 170: Cross entropy = 0.123299\n",
            "I1227 02:13:34.504316 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:13:34.504207: Step 170: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:13:37.771208 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:13:37.771066: Step 180: Train accuracy = 100.0%\n",
            "I1227 02:13:37.775441 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:13:37.775415: Step 180: Cross entropy = 0.098465\n",
            "I1227 02:13:38.071894 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:13:38.071810: Step 180: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:13:41.236597 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:13:41.236497: Step 190: Train accuracy = 100.0%\n",
            "I1227 02:13:41.237805 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:13:41.237783: Step 190: Cross entropy = 0.096001\n",
            "I1227 02:13:41.542276 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:13:41.542128: Step 190: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:13:44.865567 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:13:44.865467: Step 200: Train accuracy = 100.0%\n",
            "I1227 02:13:44.867083 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:13:44.867056: Step 200: Cross entropy = 0.091179\n",
            "I1227 02:13:45.202374 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:13:45.202273: Step 200: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:13:48.450846 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:13:48.450742: Step 210: Train accuracy = 98.0%\n",
            "I1227 02:13:48.452263 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:13:48.452241: Step 210: Cross entropy = 0.110846\n",
            "I1227 02:13:48.767524 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:13:48.767434: Step 210: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:13:52.013128 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:13:52.013045: Step 220: Train accuracy = 100.0%\n",
            "I1227 02:13:52.014299 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:13:52.014279: Step 220: Cross entropy = 0.125757\n",
            "I1227 02:13:52.336121 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:13:52.335981: Step 220: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:13:55.599029 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:13:55.598903: Step 230: Train accuracy = 100.0%\n",
            "I1227 02:13:55.600143 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:13:55.600117: Step 230: Cross entropy = 0.088664\n",
            "I1227 02:13:55.932529 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:13:55.932430: Step 230: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:13:59.255720 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:13:59.255610: Step 240: Train accuracy = 100.0%\n",
            "I1227 02:13:59.256922 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:13:59.256899: Step 240: Cross entropy = 0.113205\n",
            "I1227 02:13:59.567605 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:13:59.567518: Step 240: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:14:02.812371 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:14:02.812256: Step 250: Train accuracy = 100.0%\n",
            "I1227 02:14:02.813672 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:14:02.813653: Step 250: Cross entropy = 0.087152\n",
            "I1227 02:14:03.130701 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:14:03.130583: Step 250: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:14:06.374786 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:14:06.374655: Step 260: Train accuracy = 100.0%\n",
            "I1227 02:14:06.379220 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:14:06.379187: Step 260: Cross entropy = 0.092105\n",
            "I1227 02:14:06.694348 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:14:06.694260: Step 260: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:14:09.886066 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:14:09.885927: Step 270: Train accuracy = 100.0%\n",
            "I1227 02:14:09.887276 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:14:09.887252: Step 270: Cross entropy = 0.078946\n",
            "I1227 02:14:10.212590 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:14:10.212505: Step 270: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:14:13.501461 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:14:13.501339: Step 280: Train accuracy = 100.0%\n",
            "I1227 02:14:13.502984 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:14:13.502942: Step 280: Cross entropy = 0.088476\n",
            "I1227 02:14:13.840707 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:14:13.840613: Step 280: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:14:17.123171 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:14:17.123053: Step 290: Train accuracy = 99.0%\n",
            "I1227 02:14:17.127524 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:14:17.127474: Step 290: Cross entropy = 0.077524\n",
            "I1227 02:14:17.460074 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:14:17.459882: Step 290: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:14:20.661409 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:14:20.661284: Step 300: Train accuracy = 100.0%\n",
            "I1227 02:14:20.662658 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:14:20.662632: Step 300: Cross entropy = 0.072809\n",
            "I1227 02:14:21.006567 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:14:21.006472: Step 300: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:14:24.243050 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:14:24.242927: Step 310: Train accuracy = 99.0%\n",
            "I1227 02:14:24.244424 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:14:24.244402: Step 310: Cross entropy = 0.101452\n",
            "I1227 02:14:24.552123 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:14:24.552041: Step 310: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:14:27.759297 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:14:27.759205: Step 320: Train accuracy = 100.0%\n",
            "I1227 02:14:27.760553 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:14:27.760528: Step 320: Cross entropy = 0.058208\n",
            "I1227 02:14:28.060610 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:14:28.060494: Step 320: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:14:31.339082 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:14:31.338976: Step 330: Train accuracy = 100.0%\n",
            "I1227 02:14:31.343076 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:14:31.343046: Step 330: Cross entropy = 0.061411\n",
            "I1227 02:14:31.656394 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:14:31.656268: Step 330: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:14:34.958555 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:14:34.958405: Step 340: Train accuracy = 99.0%\n",
            "I1227 02:14:34.960027 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:14:34.959997: Step 340: Cross entropy = 0.073847\n",
            "I1227 02:14:35.263435 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:14:35.263349: Step 340: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:14:38.548215 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:14:38.548064: Step 350: Train accuracy = 100.0%\n",
            "I1227 02:14:38.549422 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:14:38.549396: Step 350: Cross entropy = 0.072307\n",
            "I1227 02:14:38.855749 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:14:38.855670: Step 350: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:14:42.116242 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:14:42.116144: Step 360: Train accuracy = 100.0%\n",
            "I1227 02:14:42.117529 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:14:42.117505: Step 360: Cross entropy = 0.059846\n",
            "I1227 02:14:42.487692 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:14:42.487567: Step 360: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:14:45.699216 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:14:45.699114: Step 370: Train accuracy = 99.0%\n",
            "I1227 02:14:45.700339 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:14:45.700320: Step 370: Cross entropy = 0.085701\n",
            "I1227 02:14:46.015747 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:14:46.015663: Step 370: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:14:49.249746 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:14:49.249621: Step 380: Train accuracy = 100.0%\n",
            "I1227 02:14:49.252901 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:14:49.252876: Step 380: Cross entropy = 0.059934\n",
            "I1227 02:14:49.554036 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:14:49.553926: Step 380: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:14:52.900308 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:14:52.900222: Step 390: Train accuracy = 100.0%\n",
            "I1227 02:14:52.901449 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:14:52.901424: Step 390: Cross entropy = 0.042458\n",
            "I1227 02:14:53.225212 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:14:53.225131: Step 390: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:14:56.450375 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:14:56.450207: Step 400: Train accuracy = 100.0%\n",
            "I1227 02:14:56.451573 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:14:56.451553: Step 400: Cross entropy = 0.050545\n",
            "I1227 02:14:56.752006 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:14:56.751897: Step 400: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:14:59.863623 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:14:59.863499: Step 410: Train accuracy = 100.0%\n",
            "I1227 02:14:59.865074 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:14:59.865055: Step 410: Cross entropy = 0.049791\n",
            "I1227 02:15:00.165544 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:15:00.165457: Step 410: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:15:03.338237 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:15:03.338147: Step 420: Train accuracy = 100.0%\n",
            "I1227 02:15:03.339396 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:15:03.339371: Step 420: Cross entropy = 0.059834\n",
            "I1227 02:15:03.650939 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:15:03.650820: Step 420: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:15:06.677665 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:15:06.677516: Step 430: Train accuracy = 99.0%\n",
            "I1227 02:15:06.679171 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:15:06.679151: Step 430: Cross entropy = 0.071687\n",
            "I1227 02:15:06.962538 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:15:06.962421: Step 430: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:15:10.029725 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:15:10.029646: Step 440: Train accuracy = 100.0%\n",
            "I1227 02:15:10.035023 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:15:10.034996: Step 440: Cross entropy = 0.063919\n",
            "I1227 02:15:10.320262 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:15:10.320174: Step 440: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:15:13.461441 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:15:13.461356: Step 450: Train accuracy = 100.0%\n",
            "I1227 02:15:13.462805 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:15:13.462764: Step 450: Cross entropy = 0.048247\n",
            "I1227 02:15:13.780462 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:15:13.780381: Step 450: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:15:17.139681 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:15:17.139562: Step 460: Train accuracy = 100.0%\n",
            "I1227 02:15:17.141243 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:15:17.141216: Step 460: Cross entropy = 0.052921\n",
            "I1227 02:15:17.505772 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:15:17.505657: Step 460: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:15:20.717051 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:15:20.716910: Step 470: Train accuracy = 100.0%\n",
            "I1227 02:15:20.718938 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:15:20.718910: Step 470: Cross entropy = 0.066281\n",
            "I1227 02:15:21.075646 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:15:21.075538: Step 470: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:15:24.372175 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:15:24.372085: Step 480: Train accuracy = 99.0%\n",
            "I1227 02:15:24.373377 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:15:24.373351: Step 480: Cross entropy = 0.063245\n",
            "I1227 02:15:24.701636 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:15:24.701546: Step 480: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:15:27.957365 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:15:27.957246: Step 490: Train accuracy = 100.0%\n",
            "I1227 02:15:27.958469 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:15:27.958444: Step 490: Cross entropy = 0.054541\n",
            "I1227 02:15:28.274718 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:15:28.274632: Step 490: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:15:31.461012 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:15:31.460860: Step 500: Train accuracy = 100.0%\n",
            "I1227 02:15:31.462269 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:15:31.462249: Step 500: Cross entropy = 0.051864\n",
            "I1227 02:15:31.760560 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:15:31.760468: Step 500: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:15:35.016176 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:15:35.016084: Step 510: Train accuracy = 100.0%\n",
            "I1227 02:15:35.017476 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:15:35.017457: Step 510: Cross entropy = 0.035803\n",
            "I1227 02:15:35.328217 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:15:35.328138: Step 510: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:15:38.425195 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:15:38.425065: Step 520: Train accuracy = 100.0%\n",
            "I1227 02:15:38.429394 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:15:38.429343: Step 520: Cross entropy = 0.058852\n",
            "I1227 02:15:38.732822 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:15:38.732701: Step 520: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:15:41.935342 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:15:41.935248: Step 530: Train accuracy = 99.0%\n",
            "I1227 02:15:41.936532 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:15:41.936509: Step 530: Cross entropy = 0.069649\n",
            "I1227 02:15:42.251188 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:15:42.251088: Step 530: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:15:45.563769 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:15:45.563685: Step 540: Train accuracy = 99.0%\n",
            "I1227 02:15:45.564994 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:15:45.564953: Step 540: Cross entropy = 0.051430\n",
            "I1227 02:15:45.876057 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:15:45.875912: Step 540: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:15:49.107027 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:15:49.106902: Step 550: Train accuracy = 100.0%\n",
            "I1227 02:15:49.108406 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:15:49.108379: Step 550: Cross entropy = 0.056897\n",
            "I1227 02:15:49.416620 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:15:49.416539: Step 550: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:15:52.544002 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:15:52.543842: Step 560: Train accuracy = 100.0%\n",
            "I1227 02:15:52.545182 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:15:52.545159: Step 560: Cross entropy = 0.045102\n",
            "I1227 02:15:52.852765 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:15:52.852644: Step 560: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:15:56.139896 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:15:56.139760: Step 570: Train accuracy = 100.0%\n",
            "I1227 02:15:56.141290 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:15:56.141270: Step 570: Cross entropy = 0.042006\n",
            "I1227 02:15:56.461202 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:15:56.461095: Step 570: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:15:59.660412 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:15:59.660298: Step 580: Train accuracy = 100.0%\n",
            "I1227 02:15:59.661561 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:15:59.661538: Step 580: Cross entropy = 0.049747\n",
            "I1227 02:15:59.966481 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:15:59.966384: Step 580: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:16:03.172606 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:16:03.172494: Step 590: Train accuracy = 100.0%\n",
            "I1227 02:16:03.174023 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:16:03.173998: Step 590: Cross entropy = 0.049113\n",
            "I1227 02:16:03.474861 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:16:03.474755: Step 590: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:16:06.774394 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:16:06.774303: Step 600: Train accuracy = 100.0%\n",
            "I1227 02:16:06.777837 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:16:06.777809: Step 600: Cross entropy = 0.038013\n",
            "I1227 02:16:07.090257 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:16:07.090140: Step 600: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:16:10.277113 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:16:10.277001: Step 610: Train accuracy = 100.0%\n",
            "I1227 02:16:10.278482 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:16:10.278461: Step 610: Cross entropy = 0.036871\n",
            "I1227 02:16:10.605360 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:16:10.605280: Step 610: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:16:13.842705 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:16:13.842617: Step 620: Train accuracy = 100.0%\n",
            "I1227 02:16:13.844064 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:16:13.844043: Step 620: Cross entropy = 0.034496\n",
            "I1227 02:16:14.138186 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:16:14.138071: Step 620: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:16:17.380752 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:16:17.380641: Step 630: Train accuracy = 100.0%\n",
            "I1227 02:16:17.382056 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:16:17.382022: Step 630: Cross entropy = 0.033779\n",
            "I1227 02:16:17.710047 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:16:17.709939: Step 630: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:16:20.986510 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:16:20.986412: Step 640: Train accuracy = 97.0%\n",
            "I1227 02:16:20.987852 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:16:20.987826: Step 640: Cross entropy = 0.071471\n",
            "I1227 02:16:21.321065 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:16:21.320937: Step 640: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:16:24.634895 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:16:24.634744: Step 650: Train accuracy = 100.0%\n",
            "I1227 02:16:24.636245 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:16:24.636224: Step 650: Cross entropy = 0.043636\n",
            "I1227 02:16:24.990158 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:16:24.990050: Step 650: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:16:28.352265 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:16:28.352166: Step 660: Train accuracy = 100.0%\n",
            "I1227 02:16:28.353471 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:16:28.353449: Step 660: Cross entropy = 0.039916\n",
            "I1227 02:16:28.678720 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:16:28.678639: Step 660: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:16:31.957947 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:16:31.957789: Step 670: Train accuracy = 100.0%\n",
            "I1227 02:16:31.959839 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:16:31.959818: Step 670: Cross entropy = 0.045869\n",
            "I1227 02:16:32.292073 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:16:32.291904: Step 670: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:16:35.569904 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:16:35.569809: Step 680: Train accuracy = 100.0%\n",
            "I1227 02:16:35.571245 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:16:35.571221: Step 680: Cross entropy = 0.042909\n",
            "I1227 02:16:35.888420 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:16:35.888230: Step 680: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:16:39.127638 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:16:39.127537: Step 690: Train accuracy = 100.0%\n",
            "I1227 02:16:39.128880 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:16:39.128857: Step 690: Cross entropy = 0.026445\n",
            "I1227 02:16:39.429686 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:16:39.429599: Step 690: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:16:42.652634 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:16:42.652537: Step 700: Train accuracy = 100.0%\n",
            "I1227 02:16:42.653832 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:16:42.653811: Step 700: Cross entropy = 0.052970\n",
            "I1227 02:16:42.988614 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:16:42.988522: Step 700: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:16:46.180235 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:16:46.180137: Step 710: Train accuracy = 100.0%\n",
            "I1227 02:16:46.185131 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:16:46.185099: Step 710: Cross entropy = 0.022901\n",
            "I1227 02:16:46.495822 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:16:46.495672: Step 710: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:16:49.616384 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:16:49.616275: Step 720: Train accuracy = 100.0%\n",
            "I1227 02:16:49.617774 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:16:49.617734: Step 720: Cross entropy = 0.023161\n",
            "I1227 02:16:49.947811 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:16:49.947694: Step 720: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:16:53.063256 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:16:53.063123: Step 730: Train accuracy = 100.0%\n",
            "I1227 02:16:53.064621 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:16:53.064593: Step 730: Cross entropy = 0.043824\n",
            "I1227 02:16:53.407307 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:16:53.407199: Step 730: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:16:56.649416 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:16:56.649291: Step 740: Train accuracy = 100.0%\n",
            "I1227 02:16:56.650809 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:16:56.650786: Step 740: Cross entropy = 0.036618\n",
            "I1227 02:16:56.951452 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:16:56.951361: Step 740: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:17:00.219347 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:17:00.219210: Step 750: Train accuracy = 100.0%\n",
            "I1227 02:17:00.220626 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:17:00.220588: Step 750: Cross entropy = 0.038334\n",
            "I1227 02:17:00.569153 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:17:00.569023: Step 750: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:17:03.741795 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:17:03.741675: Step 760: Train accuracy = 99.0%\n",
            "I1227 02:17:03.743033 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:17:03.743009: Step 760: Cross entropy = 0.058290\n",
            "I1227 02:17:04.102718 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:17:04.102607: Step 760: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:17:07.251628 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:17:07.251533: Step 770: Train accuracy = 100.0%\n",
            "I1227 02:17:07.252939 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:17:07.252920: Step 770: Cross entropy = 0.035660\n",
            "I1227 02:17:07.557417 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:17:07.557326: Step 770: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:17:10.603703 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:17:10.603608: Step 780: Train accuracy = 100.0%\n",
            "I1227 02:17:10.604809 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:17:10.604784: Step 780: Cross entropy = 0.037793\n",
            "I1227 02:17:10.885069 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:17:10.884921: Step 780: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:17:14.068532 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:17:14.068454: Step 790: Train accuracy = 100.0%\n",
            "I1227 02:17:14.069730 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:17:14.069692: Step 790: Cross entropy = 0.033459\n",
            "I1227 02:17:14.352829 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:17:14.352739: Step 790: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:17:17.460575 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:17:17.460452: Step 800: Train accuracy = 100.0%\n",
            "I1227 02:17:17.461752 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:17:17.461728: Step 800: Cross entropy = 0.024786\n",
            "I1227 02:17:17.775470 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:17:17.775382: Step 800: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:17:20.933129 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:17:20.933043: Step 810: Train accuracy = 100.0%\n",
            "I1227 02:17:20.936496 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:17:20.936473: Step 810: Cross entropy = 0.025694\n",
            "I1227 02:17:21.252722 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:17:21.252612: Step 810: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:17:24.690304 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:17:24.690187: Step 820: Train accuracy = 100.0%\n",
            "I1227 02:17:24.691410 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:17:24.691386: Step 820: Cross entropy = 0.026811\n",
            "I1227 02:17:25.010937 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:17:25.010850: Step 820: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:17:28.693782 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:17:28.693688: Step 830: Train accuracy = 100.0%\n",
            "I1227 02:17:28.694916 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:17:28.694893: Step 830: Cross entropy = 0.026642\n",
            "I1227 02:17:29.038799 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:17:29.038705: Step 830: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:17:32.894892 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:17:32.894796: Step 840: Train accuracy = 99.0%\n",
            "I1227 02:17:32.896062 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:17:32.896041: Step 840: Cross entropy = 0.044227\n",
            "I1227 02:17:33.296502 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:17:33.296401: Step 840: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:17:37.045598 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:17:37.045472: Step 850: Train accuracy = 100.0%\n",
            "I1227 02:17:37.046650 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:17:37.046628: Step 850: Cross entropy = 0.033264\n",
            "I1227 02:17:37.439584 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:17:37.439507: Step 850: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:17:41.118634 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:17:41.118531: Step 860: Train accuracy = 100.0%\n",
            "I1227 02:17:41.123703 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:17:41.123683: Step 860: Cross entropy = 0.029049\n",
            "I1227 02:17:41.462591 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:17:41.462491: Step 860: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:17:44.685713 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:17:44.685616: Step 870: Train accuracy = 100.0%\n",
            "I1227 02:17:44.687031 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:17:44.687002: Step 870: Cross entropy = 0.039768\n",
            "I1227 02:17:45.014159 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:17:45.014071: Step 870: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:17:48.132462 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:17:48.132354: Step 880: Train accuracy = 100.0%\n",
            "I1227 02:17:48.133677 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:17:48.133653: Step 880: Cross entropy = 0.025808\n",
            "I1227 02:17:48.456200 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:17:48.456105: Step 880: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:17:51.439084 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:17:51.439002: Step 890: Train accuracy = 100.0%\n",
            "I1227 02:17:51.440127 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:17:51.440095: Step 890: Cross entropy = 0.033403\n",
            "I1227 02:17:51.755534 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:17:51.755439: Step 890: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:17:54.882591 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:17:54.882506: Step 900: Train accuracy = 100.0%\n",
            "I1227 02:17:54.883649 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:17:54.883625: Step 900: Cross entropy = 0.019356\n",
            "I1227 02:17:55.189886 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:17:55.189798: Step 900: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:17:58.356779 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:17:58.356678: Step 910: Train accuracy = 99.0%\n",
            "I1227 02:17:58.358089 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:17:58.358069: Step 910: Cross entropy = 0.042173\n",
            "I1227 02:17:58.684570 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:17:58.684432: Step 910: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:18:01.923061 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:18:01.922942: Step 920: Train accuracy = 100.0%\n",
            "I1227 02:18:01.924367 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:18:01.924344: Step 920: Cross entropy = 0.033140\n",
            "I1227 02:18:02.257672 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:18:02.257562: Step 920: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:18:05.438458 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:18:05.438359: Step 930: Train accuracy = 100.0%\n",
            "I1227 02:18:05.442859 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:18:05.442818: Step 930: Cross entropy = 0.031107\n",
            "I1227 02:18:05.708582 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:18:05.708487: Step 930: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:18:08.901743 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:18:08.901662: Step 940: Train accuracy = 100.0%\n",
            "I1227 02:18:08.902952 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:18:08.902918: Step 940: Cross entropy = 0.026927\n",
            "I1227 02:18:09.206351 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:18:09.206217: Step 940: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:18:12.353567 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:18:12.353482: Step 950: Train accuracy = 100.0%\n",
            "I1227 02:18:12.354798 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:18:12.354779: Step 950: Cross entropy = 0.028454\n",
            "I1227 02:18:12.671511 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:18:12.671414: Step 950: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:18:15.994509 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:18:15.994426: Step 960: Train accuracy = 100.0%\n",
            "I1227 02:18:15.995630 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:18:15.995607: Step 960: Cross entropy = 0.016712\n",
            "I1227 02:18:16.323982 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:18:16.323836: Step 960: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:18:19.538652 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:18:19.538552: Step 970: Train accuracy = 100.0%\n",
            "I1227 02:18:19.541289 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:18:19.541263: Step 970: Cross entropy = 0.020721\n",
            "I1227 02:18:19.871879 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:18:19.871788: Step 970: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:18:23.141154 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:18:23.141019: Step 980: Train accuracy = 100.0%\n",
            "I1227 02:18:23.145423 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:18:23.145391: Step 980: Cross entropy = 0.031981\n",
            "I1227 02:18:23.451217 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:18:23.451140: Step 980: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:18:26.548931 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:18:26.548819: Step 990: Train accuracy = 100.0%\n",
            "I1227 02:18:26.550089 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:18:26.550064: Step 990: Cross entropy = 0.026557\n",
            "I1227 02:18:26.848587 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:18:26.848457: Step 990: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:18:29.968457 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:18:29.968369: Step 1000: Train accuracy = 100.0%\n",
            "I1227 02:18:29.969658 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:18:29.969638: Step 1000: Cross entropy = 0.029104\n",
            "I1227 02:18:30.285109 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:18:30.284990: Step 1000: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:18:33.573867 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:18:33.573772: Step 1010: Train accuracy = 100.0%\n",
            "I1227 02:18:33.577756 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:18:33.577726: Step 1010: Cross entropy = 0.019393\n",
            "I1227 02:18:33.894699 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:18:33.894614: Step 1010: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:18:37.094725 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:18:37.094643: Step 1020: Train accuracy = 99.0%\n",
            "I1227 02:18:37.095844 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:18:37.095816: Step 1020: Cross entropy = 0.035853\n",
            "I1227 02:18:37.387550 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:18:37.387448: Step 1020: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:18:40.562737 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:18:40.562655: Step 1030: Train accuracy = 100.0%\n",
            "I1227 02:18:40.564143 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:18:40.564124: Step 1030: Cross entropy = 0.025646\n",
            "I1227 02:18:40.868657 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:18:40.868564: Step 1030: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:18:44.017406 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:18:44.017303: Step 1040: Train accuracy = 100.0%\n",
            "I1227 02:18:44.018850 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:18:44.018827: Step 1040: Cross entropy = 0.030897\n",
            "I1227 02:18:44.368806 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:18:44.368715: Step 1040: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:18:47.648180 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:18:47.648082: Step 1050: Train accuracy = 100.0%\n",
            "I1227 02:18:47.653118 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:18:47.653089: Step 1050: Cross entropy = 0.042471\n",
            "I1227 02:18:47.978660 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:18:47.978552: Step 1050: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:18:51.354610 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:18:51.354506: Step 1060: Train accuracy = 100.0%\n",
            "I1227 02:18:51.356011 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:18:51.355989: Step 1060: Cross entropy = 0.033804\n",
            "I1227 02:18:51.690940 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:18:51.690851: Step 1060: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:18:54.981471 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:18:54.981372: Step 1070: Train accuracy = 100.0%\n",
            "I1227 02:18:54.986393 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:18:54.986343: Step 1070: Cross entropy = 0.021328\n",
            "I1227 02:18:55.283228 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:18:55.283148: Step 1070: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:18:58.427169 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:18:58.427042: Step 1080: Train accuracy = 100.0%\n",
            "I1227 02:18:58.428367 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:18:58.428330: Step 1080: Cross entropy = 0.019413\n",
            "I1227 02:18:58.729188 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:18:58.729105: Step 1080: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:19:01.918890 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:19:01.918795: Step 1090: Train accuracy = 100.0%\n",
            "I1227 02:19:01.920423 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:19:01.920368: Step 1090: Cross entropy = 0.022527\n",
            "I1227 02:19:02.273833 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:19:02.273684: Step 1090: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:19:05.580612 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:19:05.580514: Step 1100: Train accuracy = 100.0%\n",
            "I1227 02:19:05.581727 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:19:05.581707: Step 1100: Cross entropy = 0.025862\n",
            "I1227 02:19:05.880534 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:19:05.880443: Step 1100: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:19:09.059912 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:19:09.059820: Step 1110: Train accuracy = 100.0%\n",
            "I1227 02:19:09.061151 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:19:09.061130: Step 1110: Cross entropy = 0.019005\n",
            "I1227 02:19:09.363734 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:19:09.363601: Step 1110: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:19:12.498342 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:19:12.498222: Step 1120: Train accuracy = 100.0%\n",
            "I1227 02:19:12.499398 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:19:12.499374: Step 1120: Cross entropy = 0.017869\n",
            "I1227 02:19:12.806604 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:19:12.806454: Step 1120: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:19:16.069036 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:19:16.068931: Step 1130: Train accuracy = 99.0%\n",
            "I1227 02:19:16.070053 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:19:16.070028: Step 1130: Cross entropy = 0.027155\n",
            "I1227 02:19:16.387242 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:19:16.387163: Step 1130: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:19:19.626650 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:19:19.626548: Step 1140: Train accuracy = 100.0%\n",
            "I1227 02:19:19.628051 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:19:19.628012: Step 1140: Cross entropy = 0.029438\n",
            "I1227 02:19:19.949980 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:19:19.949881: Step 1140: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:19:23.285211 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:19:23.285099: Step 1150: Train accuracy = 100.0%\n",
            "I1227 02:19:23.286593 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:19:23.286571: Step 1150: Cross entropy = 0.021047\n",
            "I1227 02:19:23.627543 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:19:23.627443: Step 1150: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:19:26.959902 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:19:26.959797: Step 1160: Train accuracy = 100.0%\n",
            "I1227 02:19:26.962095 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:19:26.962067: Step 1160: Cross entropy = 0.028356\n",
            "I1227 02:19:27.270165 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:19:27.270078: Step 1160: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:19:30.680498 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:19:30.680385: Step 1170: Train accuracy = 100.0%\n",
            "I1227 02:19:30.682277 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:19:30.682249: Step 1170: Cross entropy = 0.030522\n",
            "I1227 02:19:30.984521 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:19:30.984345: Step 1170: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:19:34.297452 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:19:34.297356: Step 1180: Train accuracy = 100.0%\n",
            "I1227 02:19:34.298800 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:19:34.298779: Step 1180: Cross entropy = 0.017037\n",
            "I1227 02:19:34.634841 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:19:34.634681: Step 1180: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:19:37.990426 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:19:37.990269: Step 1190: Train accuracy = 100.0%\n",
            "I1227 02:19:37.991871 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:19:37.991846: Step 1190: Cross entropy = 0.033398\n",
            "I1227 02:19:38.349461 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:19:38.349365: Step 1190: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:19:41.670056 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:19:41.669936: Step 1200: Train accuracy = 100.0%\n",
            "I1227 02:19:41.671356 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:19:41.671336: Step 1200: Cross entropy = 0.023316\n",
            "I1227 02:19:41.992320 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:19:41.992238: Step 1200: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:19:45.264356 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:19:45.264270: Step 1210: Train accuracy = 100.0%\n",
            "I1227 02:19:45.265732 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:19:45.265710: Step 1210: Cross entropy = 0.030908\n",
            "I1227 02:19:45.576415 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:19:45.576320: Step 1210: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:19:48.838751 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:19:48.838662: Step 1220: Train accuracy = 100.0%\n",
            "I1227 02:19:48.841384 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:19:48.841358: Step 1220: Cross entropy = 0.017433\n",
            "I1227 02:19:49.195064 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:19:49.194979: Step 1220: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:19:52.415717 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:19:52.415623: Step 1230: Train accuracy = 100.0%\n",
            "I1227 02:19:52.416822 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:19:52.416801: Step 1230: Cross entropy = 0.019444\n",
            "I1227 02:19:52.735525 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:19:52.735405: Step 1230: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:19:55.977366 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:19:55.977256: Step 1240: Train accuracy = 100.0%\n",
            "I1227 02:19:55.981360 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:19:55.981333: Step 1240: Cross entropy = 0.021534\n",
            "I1227 02:19:56.304601 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:19:56.304455: Step 1240: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:19:59.575066 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:19:59.574918: Step 1250: Train accuracy = 100.0%\n",
            "I1227 02:19:59.576311 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:19:59.576269: Step 1250: Cross entropy = 0.016087\n",
            "I1227 02:19:59.875317 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:19:59.875217: Step 1250: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:20:03.211334 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:20:03.211228: Step 1260: Train accuracy = 100.0%\n",
            "I1227 02:20:03.212857 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:20:03.212833: Step 1260: Cross entropy = 0.018616\n",
            "I1227 02:20:03.573745 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:20:03.573648: Step 1260: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:20:06.815690 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:20:06.815603: Step 1270: Train accuracy = 100.0%\n",
            "I1227 02:20:06.816858 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:20:06.816837: Step 1270: Cross entropy = 0.027842\n",
            "I1227 02:20:07.164381 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:20:07.164284: Step 1270: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:20:10.438030 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:20:10.437920: Step 1280: Train accuracy = 100.0%\n",
            "I1227 02:20:10.439343 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:20:10.439323: Step 1280: Cross entropy = 0.015758\n",
            "I1227 02:20:10.799564 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:20:10.799485: Step 1280: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:20:14.115669 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:20:14.115574: Step 1290: Train accuracy = 99.0%\n",
            "I1227 02:20:14.116918 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:20:14.116884: Step 1290: Cross entropy = 0.042361\n",
            "I1227 02:20:14.473446 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:20:14.473363: Step 1290: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:20:17.658384 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:20:17.658280: Step 1300: Train accuracy = 100.0%\n",
            "I1227 02:20:17.661918 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:20:17.661893: Step 1300: Cross entropy = 0.026425\n",
            "I1227 02:20:17.981637 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:20:17.981550: Step 1300: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:20:21.226732 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:20:21.226624: Step 1310: Train accuracy = 100.0%\n",
            "I1227 02:20:21.232318 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:20:21.232256: Step 1310: Cross entropy = 0.018046\n",
            "I1227 02:20:21.581309 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:20:21.581218: Step 1310: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:20:24.835931 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:20:24.835812: Step 1320: Train accuracy = 100.0%\n",
            "I1227 02:20:24.837057 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:20:24.837031: Step 1320: Cross entropy = 0.015924\n",
            "I1227 02:20:25.167123 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:20:25.166989: Step 1320: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:20:28.619558 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:20:28.619443: Step 1330: Train accuracy = 100.0%\n",
            "I1227 02:20:28.620903 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:20:28.620879: Step 1330: Cross entropy = 0.021402\n",
            "I1227 02:20:28.969339 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:20:28.969230: Step 1330: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:20:32.347882 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:20:32.347774: Step 1340: Train accuracy = 99.0%\n",
            "I1227 02:20:32.349375 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:20:32.349350: Step 1340: Cross entropy = 0.023365\n",
            "I1227 02:20:32.662789 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:20:32.662683: Step 1340: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:20:35.946768 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:20:35.946633: Step 1350: Train accuracy = 100.0%\n",
            "I1227 02:20:35.947984 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:20:35.947941: Step 1350: Cross entropy = 0.014916\n",
            "I1227 02:20:36.268076 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:20:36.267973: Step 1350: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:20:39.513632 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:20:39.513549: Step 1360: Train accuracy = 100.0%\n",
            "I1227 02:20:39.515072 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:20:39.515053: Step 1360: Cross entropy = 0.040532\n",
            "I1227 02:20:39.806823 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:20:39.806727: Step 1360: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:20:43.112364 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:20:43.112284: Step 1370: Train accuracy = 100.0%\n",
            "I1227 02:20:43.113765 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:20:43.113744: Step 1370: Cross entropy = 0.016607\n",
            "I1227 02:20:43.411350 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:20:43.411267: Step 1370: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:20:46.707724 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:20:46.707612: Step 1380: Train accuracy = 100.0%\n",
            "I1227 02:20:46.709108 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:20:46.709087: Step 1380: Cross entropy = 0.025110\n",
            "I1227 02:20:47.000758 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:20:47.000671: Step 1380: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:20:50.266352 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:20:50.266240: Step 1390: Train accuracy = 100.0%\n",
            "I1227 02:20:50.270900 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:20:50.270848: Step 1390: Cross entropy = 0.016111\n",
            "I1227 02:20:50.582595 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:20:50.582498: Step 1390: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:20:53.781061 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:20:53.780944: Step 1400: Train accuracy = 100.0%\n",
            "I1227 02:20:53.782146 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:20:53.782126: Step 1400: Cross entropy = 0.017487\n",
            "I1227 02:20:54.121288 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:20:54.121173: Step 1400: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:20:57.521772 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:20:57.521673: Step 1410: Train accuracy = 100.0%\n",
            "I1227 02:20:57.524411 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:20:57.524381: Step 1410: Cross entropy = 0.014868\n",
            "I1227 02:20:57.848066 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:20:57.847909: Step 1410: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:21:01.239315 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:21:01.239211: Step 1420: Train accuracy = 100.0%\n",
            "I1227 02:21:01.240896 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:21:01.240874: Step 1420: Cross entropy = 0.017835\n",
            "I1227 02:21:01.581177 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:21:01.581083: Step 1420: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:21:04.813064 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:21:04.812941: Step 1430: Train accuracy = 100.0%\n",
            "I1227 02:21:04.815093 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:21:04.815065: Step 1430: Cross entropy = 0.018131\n",
            "I1227 02:21:05.151605 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:21:05.151503: Step 1430: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:21:08.368580 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:21:08.368457: Step 1440: Train accuracy = 100.0%\n",
            "I1227 02:21:08.369913 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:21:08.369892: Step 1440: Cross entropy = 0.017390\n",
            "I1227 02:21:08.669841 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:21:08.669745: Step 1440: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:21:11.793165 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:21:11.793059: Step 1450: Train accuracy = 100.0%\n",
            "I1227 02:21:11.794450 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:21:11.794428: Step 1450: Cross entropy = 0.025854\n",
            "I1227 02:21:12.134944 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:21:12.134851: Step 1450: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:21:15.419622 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:21:15.419526: Step 1460: Train accuracy = 100.0%\n",
            "I1227 02:21:15.420917 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:21:15.420877: Step 1460: Cross entropy = 0.016456\n",
            "I1227 02:21:15.744915 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:21:15.744813: Step 1460: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:21:18.950437 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:21:18.950291: Step 1470: Train accuracy = 100.0%\n",
            "I1227 02:21:18.951716 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:21:18.951695: Step 1470: Cross entropy = 0.019108\n",
            "I1227 02:21:19.274310 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:21:19.274229: Step 1470: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:21:22.575718 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:21:22.575539: Step 1480: Train accuracy = 99.0%\n",
            "I1227 02:21:22.577099 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:21:22.577076: Step 1480: Cross entropy = 0.028461\n",
            "I1227 02:21:22.933053 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:21:22.932944: Step 1480: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:21:26.068577 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:21:26.068483: Step 1490: Train accuracy = 100.0%\n",
            "I1227 02:21:26.069684 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:21:26.069662: Step 1490: Cross entropy = 0.019859\n",
            "I1227 02:21:26.389277 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:21:26.389188: Step 1490: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:21:29.835253 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:21:29.835147: Step 1500: Train accuracy = 100.0%\n",
            "I1227 02:21:29.836420 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:21:29.836396: Step 1500: Cross entropy = 0.022190\n",
            "I1227 02:21:30.157289 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:21:30.157166: Step 1500: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:21:33.608122 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:21:33.608037: Step 1510: Train accuracy = 100.0%\n",
            "I1227 02:21:33.610635 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:21:33.610610: Step 1510: Cross entropy = 0.016411\n",
            "I1227 02:21:33.923489 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:21:33.923405: Step 1510: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:21:37.134176 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:21:37.134070: Step 1520: Train accuracy = 99.0%\n",
            "I1227 02:21:37.135188 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:21:37.135165: Step 1520: Cross entropy = 0.026182\n",
            "I1227 02:21:37.454804 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:21:37.454708: Step 1520: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:21:40.712708 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:21:40.712595: Step 1530: Train accuracy = 100.0%\n",
            "I1227 02:21:40.713837 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:21:40.713816: Step 1530: Cross entropy = 0.016477\n",
            "I1227 02:21:41.027220 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:21:41.027128: Step 1530: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:21:44.264461 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:21:44.264350: Step 1540: Train accuracy = 100.0%\n",
            "I1227 02:21:44.270060 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:21:44.270039: Step 1540: Cross entropy = 0.017174\n",
            "I1227 02:21:44.605057 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:21:44.604916: Step 1540: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:21:47.834532 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:21:47.834412: Step 1550: Train accuracy = 100.0%\n",
            "I1227 02:21:47.835862 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:21:47.835840: Step 1550: Cross entropy = 0.015745\n",
            "I1227 02:21:48.179454 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:21:48.179347: Step 1550: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:21:51.470940 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:21:51.470848: Step 1560: Train accuracy = 100.0%\n",
            "I1227 02:21:51.474815 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:21:51.474786: Step 1560: Cross entropy = 0.018902\n",
            "I1227 02:21:51.796378 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:21:51.796289: Step 1560: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:21:55.133990 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:21:55.133884: Step 1570: Train accuracy = 100.0%\n",
            "I1227 02:21:55.135136 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:21:55.135111: Step 1570: Cross entropy = 0.025612\n",
            "I1227 02:21:55.430133 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:21:55.430050: Step 1570: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:21:58.759869 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:21:58.759711: Step 1580: Train accuracy = 100.0%\n",
            "I1227 02:21:58.762246 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:21:58.762207: Step 1580: Cross entropy = 0.015286\n",
            "I1227 02:21:59.056280 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:21:59.056187: Step 1580: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:22:02.308190 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:22:02.308095: Step 1590: Train accuracy = 100.0%\n",
            "I1227 02:22:02.309687 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:22:02.309661: Step 1590: Cross entropy = 0.022037\n",
            "I1227 02:22:02.641534 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:22:02.641431: Step 1590: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:22:05.898576 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:22:05.898474: Step 1600: Train accuracy = 100.0%\n",
            "I1227 02:22:05.899685 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:22:05.899664: Step 1600: Cross entropy = 0.015720\n",
            "I1227 02:22:06.214691 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:22:06.214597: Step 1600: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:22:09.504615 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:22:09.504518: Step 1610: Train accuracy = 100.0%\n",
            "I1227 02:22:09.505649 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:22:09.505630: Step 1610: Cross entropy = 0.024032\n",
            "I1227 02:22:09.819287 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:22:09.819161: Step 1610: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:22:13.046754 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:22:13.046667: Step 1620: Train accuracy = 100.0%\n",
            "I1227 02:22:13.048049 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:22:13.048022: Step 1620: Cross entropy = 0.019407\n",
            "I1227 02:22:13.355031 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:22:13.354918: Step 1620: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:22:16.709541 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:22:16.709439: Step 1630: Train accuracy = 100.0%\n",
            "I1227 02:22:16.710855 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:22:16.710832: Step 1630: Cross entropy = 0.023676\n",
            "I1227 02:22:17.029664 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:22:17.029582: Step 1630: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:22:20.327302 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:22:20.327195: Step 1640: Train accuracy = 100.0%\n",
            "I1227 02:22:20.328932 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:22:20.328906: Step 1640: Cross entropy = 0.009324\n",
            "I1227 02:22:20.642038 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:22:20.641927: Step 1640: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:22:23.807352 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:22:23.807208: Step 1650: Train accuracy = 100.0%\n",
            "I1227 02:22:23.812078 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:22:23.812032: Step 1650: Cross entropy = 0.010086\n",
            "I1227 02:22:24.170352 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:22:24.170272: Step 1650: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:22:27.530262 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:22:27.530160: Step 1660: Train accuracy = 100.0%\n",
            "I1227 02:22:27.531645 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:22:27.531619: Step 1660: Cross entropy = 0.013133\n",
            "I1227 02:22:27.857058 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:22:27.856914: Step 1660: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:22:31.220980 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:22:31.220855: Step 1670: Train accuracy = 100.0%\n",
            "I1227 02:22:31.222359 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:22:31.222331: Step 1670: Cross entropy = 0.014411\n",
            "I1227 02:22:31.562476 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:22:31.562338: Step 1670: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:22:35.437790 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:22:35.437672: Step 1680: Train accuracy = 100.0%\n",
            "I1227 02:22:35.438917 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:22:35.438892: Step 1680: Cross entropy = 0.012949\n",
            "I1227 02:22:35.842339 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:22:35.842242: Step 1680: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:22:39.270153 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:22:39.270067: Step 1690: Train accuracy = 100.0%\n",
            "I1227 02:22:39.271404 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:22:39.271383: Step 1690: Cross entropy = 0.022881\n",
            "I1227 02:22:39.584217 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:22:39.584127: Step 1690: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:22:43.099924 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:22:43.099814: Step 1700: Train accuracy = 100.0%\n",
            "I1227 02:22:43.103837 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:22:43.103809: Step 1700: Cross entropy = 0.010687\n",
            "I1227 02:22:43.468733 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:22:43.468653: Step 1700: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:22:47.494897 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:22:47.494805: Step 1710: Train accuracy = 100.0%\n",
            "I1227 02:22:47.495857 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:22:47.495832: Step 1710: Cross entropy = 0.016324\n",
            "I1227 02:22:47.873342 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:22:47.873237: Step 1710: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:22:51.884251 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:22:51.884134: Step 1720: Train accuracy = 100.0%\n",
            "I1227 02:22:51.885421 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:22:51.885398: Step 1720: Cross entropy = 0.015382\n",
            "I1227 02:22:52.297096 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:22:52.296984: Step 1720: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:22:55.564162 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:22:55.564062: Step 1730: Train accuracy = 100.0%\n",
            "I1227 02:22:55.565236 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:22:55.565210: Step 1730: Cross entropy = 0.022922\n",
            "I1227 02:22:55.869879 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:22:55.869787: Step 1730: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:22:59.201291 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:22:59.201206: Step 1740: Train accuracy = 100.0%\n",
            "I1227 02:22:59.202360 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:22:59.202321: Step 1740: Cross entropy = 0.015573\n",
            "I1227 02:22:59.535064 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:22:59.534897: Step 1740: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:23:02.785396 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:23:02.785289: Step 1750: Train accuracy = 100.0%\n",
            "I1227 02:23:02.786799 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:23:02.786745: Step 1750: Cross entropy = 0.016010\n",
            "I1227 02:23:03.104265 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:23:03.104174: Step 1750: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:23:06.429427 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:23:06.429311: Step 1760: Train accuracy = 100.0%\n",
            "I1227 02:23:06.433126 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:23:06.433099: Step 1760: Cross entropy = 0.018740\n",
            "I1227 02:23:06.744540 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:23:06.744438: Step 1760: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:23:10.134333 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:23:10.134203: Step 1770: Train accuracy = 100.0%\n",
            "I1227 02:23:10.138633 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:23:10.138575: Step 1770: Cross entropy = 0.018896\n",
            "I1227 02:23:10.451843 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:23:10.451756: Step 1770: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:23:13.777704 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:23:13.777621: Step 1780: Train accuracy = 100.0%\n",
            "I1227 02:23:13.782146 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:23:13.782115: Step 1780: Cross entropy = 0.015843\n",
            "I1227 02:23:14.094568 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:23:14.094473: Step 1780: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:23:17.499460 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:23:17.499344: Step 1790: Train accuracy = 100.0%\n",
            "I1227 02:23:17.500492 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:23:17.500467: Step 1790: Cross entropy = 0.011979\n",
            "I1227 02:23:17.825367 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:23:17.825280: Step 1790: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:23:21.120366 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:23:21.120218: Step 1800: Train accuracy = 100.0%\n",
            "I1227 02:23:21.121685 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:23:21.121665: Step 1800: Cross entropy = 0.018094\n",
            "I1227 02:23:21.446617 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:23:21.446514: Step 1800: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:23:24.800423 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:23:24.800327: Step 1810: Train accuracy = 100.0%\n",
            "I1227 02:23:24.801606 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:23:24.801584: Step 1810: Cross entropy = 0.016866\n",
            "I1227 02:23:25.104688 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:23:25.104572: Step 1810: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:23:28.346559 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:23:28.346463: Step 1820: Train accuracy = 100.0%\n",
            "I1227 02:23:28.350653 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:23:28.350420: Step 1820: Cross entropy = 0.008800\n",
            "I1227 02:23:28.668288 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:23:28.668183: Step 1820: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:23:31.972523 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:23:31.972425: Step 1830: Train accuracy = 100.0%\n",
            "I1227 02:23:31.973927 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:23:31.973886: Step 1830: Cross entropy = 0.016878\n",
            "I1227 02:23:32.283721 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:23:32.283595: Step 1830: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:23:35.631487 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:23:35.631403: Step 1840: Train accuracy = 100.0%\n",
            "I1227 02:23:35.632504 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:23:35.632479: Step 1840: Cross entropy = 0.011807\n",
            "I1227 02:23:35.938285 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:23:35.938192: Step 1840: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:23:39.168284 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:23:39.168188: Step 1850: Train accuracy = 100.0%\n",
            "I1227 02:23:39.169818 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:23:39.169775: Step 1850: Cross entropy = 0.016319\n",
            "I1227 02:23:39.487326 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:23:39.487173: Step 1850: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:23:42.697546 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:23:42.697449: Step 1860: Train accuracy = 100.0%\n",
            "I1227 02:23:42.698712 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:23:42.698687: Step 1860: Cross entropy = 0.011293\n",
            "I1227 02:23:43.028437 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:23:43.028312: Step 1860: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:23:46.473591 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:23:46.473489: Step 1870: Train accuracy = 100.0%\n",
            "I1227 02:23:46.474865 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:23:46.474840: Step 1870: Cross entropy = 0.018323\n",
            "I1227 02:23:46.841663 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:23:46.841569: Step 1870: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:23:50.120109 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:23:50.120026: Step 1880: Train accuracy = 100.0%\n",
            "I1227 02:23:50.121418 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:23:50.121398: Step 1880: Cross entropy = 0.013712\n",
            "I1227 02:23:50.436125 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:23:50.436026: Step 1880: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:23:53.671686 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:23:53.671554: Step 1890: Train accuracy = 100.0%\n",
            "I1227 02:23:53.676812 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:23:53.676782: Step 1890: Cross entropy = 0.013570\n",
            "I1227 02:23:54.006906 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:23:54.006795: Step 1890: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:23:57.345162 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:23:57.345036: Step 1900: Train accuracy = 100.0%\n",
            "I1227 02:23:57.346558 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:23:57.346535: Step 1900: Cross entropy = 0.013261\n",
            "I1227 02:23:57.672413 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:23:57.672312: Step 1900: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:24:01.039751 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:24:01.039618: Step 1910: Train accuracy = 99.0%\n",
            "I1227 02:24:01.041252 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:24:01.041217: Step 1910: Cross entropy = 0.018691\n",
            "I1227 02:24:01.367056 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:24:01.366932: Step 1910: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:24:04.662926 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:24:04.662832: Step 1920: Train accuracy = 100.0%\n",
            "I1227 02:24:04.667661 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:24:04.667638: Step 1920: Cross entropy = 0.018058\n",
            "I1227 02:24:04.966543 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:24:04.966449: Step 1920: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:24:08.264878 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:24:08.264794: Step 1930: Train accuracy = 100.0%\n",
            "I1227 02:24:08.265950 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:24:08.265924: Step 1930: Cross entropy = 0.013059\n",
            "I1227 02:24:08.590282 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:24:08.590158: Step 1930: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:24:11.970553 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:24:11.970435: Step 1940: Train accuracy = 99.0%\n",
            "I1227 02:24:11.971834 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:24:11.971811: Step 1940: Cross entropy = 0.026968\n",
            "I1227 02:24:12.273925 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:24:12.273825: Step 1940: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:24:15.795911 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:24:15.795809: Step 1950: Train accuracy = 100.0%\n",
            "I1227 02:24:15.797360 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:24:15.797335: Step 1950: Cross entropy = 0.012209\n",
            "I1227 02:24:16.121440 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:24:16.121362: Step 1950: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:24:19.490497 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:24:19.490383: Step 1960: Train accuracy = 100.0%\n",
            "I1227 02:24:19.492164 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:24:19.492129: Step 1960: Cross entropy = 0.012612\n",
            "I1227 02:24:19.802652 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:24:19.802563: Step 1960: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:24:23.162686 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:24:23.162600: Step 1970: Train accuracy = 100.0%\n",
            "I1227 02:24:23.164091 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:24:23.164069: Step 1970: Cross entropy = 0.013455\n",
            "I1227 02:24:23.512437 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:24:23.512349: Step 1970: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:24:26.875269 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:24:26.875181: Step 1980: Train accuracy = 100.0%\n",
            "I1227 02:24:26.876775 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:24:26.876747: Step 1980: Cross entropy = 0.012394\n",
            "I1227 02:24:27.224745 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:24:27.224652: Step 1980: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:24:30.618674 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:24:30.618591: Step 1990: Train accuracy = 100.0%\n",
            "I1227 02:24:30.620186 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:24:30.620164: Step 1990: Cross entropy = 0.015409\n",
            "I1227 02:24:30.946872 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:24:30.946779: Step 1990: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:24:34.455315 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:24:34.455224: Step 2000: Train accuracy = 100.0%\n",
            "I1227 02:24:34.456553 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:24:34.456530: Step 2000: Cross entropy = 0.014909\n",
            "I1227 02:24:34.790179 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:24:34.790102: Step 2000: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:24:38.203648 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:24:38.203562: Step 2010: Train accuracy = 100.0%\n",
            "I1227 02:24:38.206345 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:24:38.206321: Step 2010: Cross entropy = 0.017488\n",
            "I1227 02:24:38.564013 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:24:38.563900: Step 2010: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:24:41.807328 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:24:41.807229: Step 2020: Train accuracy = 100.0%\n",
            "I1227 02:24:41.808771 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:24:41.808751: Step 2020: Cross entropy = 0.012658\n",
            "I1227 02:24:42.160266 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:24:42.160180: Step 2020: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:24:45.511866 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:24:45.511761: Step 2030: Train accuracy = 100.0%\n",
            "I1227 02:24:45.513009 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:24:45.512981: Step 2030: Cross entropy = 0.011243\n",
            "I1227 02:24:45.847500 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:24:45.847403: Step 2030: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:24:49.196075 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:24:49.195982: Step 2040: Train accuracy = 100.0%\n",
            "I1227 02:24:49.197532 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:24:49.197508: Step 2040: Cross entropy = 0.014038\n",
            "I1227 02:24:49.566317 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:24:49.566096: Step 2040: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:24:53.027991 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:24:53.027854: Step 2050: Train accuracy = 100.0%\n",
            "I1227 02:24:53.029271 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:24:53.029250: Step 2050: Cross entropy = 0.011377\n",
            "I1227 02:24:53.394395 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:24:53.394313: Step 2050: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:24:56.867200 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:24:56.867118: Step 2060: Train accuracy = 100.0%\n",
            "I1227 02:24:56.868678 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:24:56.868657: Step 2060: Cross entropy = 0.010614\n",
            "I1227 02:24:57.172106 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:24:57.172028: Step 2060: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:25:00.463255 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:25:00.463158: Step 2070: Train accuracy = 100.0%\n",
            "I1227 02:25:00.465298 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:25:00.465276: Step 2070: Cross entropy = 0.013978\n",
            "I1227 02:25:00.818150 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:25:00.818041: Step 2070: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:25:04.329399 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:25:04.329253: Step 2080: Train accuracy = 100.0%\n",
            "I1227 02:25:04.330700 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:25:04.330667: Step 2080: Cross entropy = 0.013734\n",
            "I1227 02:25:04.642140 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:25:04.642055: Step 2080: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:25:07.845559 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:25:07.845468: Step 2090: Train accuracy = 100.0%\n",
            "I1227 02:25:07.846808 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:25:07.846781: Step 2090: Cross entropy = 0.017927\n",
            "I1227 02:25:08.158015 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:25:08.157917: Step 2090: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:25:11.460302 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:25:11.460206: Step 2100: Train accuracy = 100.0%\n",
            "I1227 02:25:11.461586 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:25:11.461561: Step 2100: Cross entropy = 0.012203\n",
            "I1227 02:25:11.829219 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:25:11.829122: Step 2100: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:25:15.319953 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:25:15.319858: Step 2110: Train accuracy = 100.0%\n",
            "I1227 02:25:15.321330 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:25:15.321309: Step 2110: Cross entropy = 0.012796\n",
            "I1227 02:25:15.682791 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:25:15.682672: Step 2110: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:25:18.964154 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:25:18.964057: Step 2120: Train accuracy = 100.0%\n",
            "I1227 02:25:18.968998 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:25:18.968934: Step 2120: Cross entropy = 0.015693\n",
            "I1227 02:25:19.310752 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:25:19.310666: Step 2120: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:25:22.824202 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:25:22.824088: Step 2130: Train accuracy = 100.0%\n",
            "I1227 02:25:22.827219 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:25:22.827198: Step 2130: Cross entropy = 0.012104\n",
            "I1227 02:25:23.141866 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:25:23.141769: Step 2130: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:25:26.571556 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:25:26.571460: Step 2140: Train accuracy = 100.0%\n",
            "I1227 02:25:26.573070 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:25:26.573047: Step 2140: Cross entropy = 0.024450\n",
            "I1227 02:25:26.935091 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:25:26.934906: Step 2140: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:25:30.442132 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:25:30.442018: Step 2150: Train accuracy = 100.0%\n",
            "I1227 02:25:30.443381 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:25:30.443345: Step 2150: Cross entropy = 0.033799\n",
            "I1227 02:25:30.803831 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:25:30.803751: Step 2150: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:25:34.262526 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:25:34.262425: Step 2160: Train accuracy = 100.0%\n",
            "I1227 02:25:34.263853 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:25:34.263830: Step 2160: Cross entropy = 0.014109\n",
            "I1227 02:25:34.618058 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:25:34.617971: Step 2160: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:25:38.055544 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:25:38.055456: Step 2170: Train accuracy = 100.0%\n",
            "I1227 02:25:38.056680 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:25:38.056654: Step 2170: Cross entropy = 0.022471\n",
            "I1227 02:25:38.371455 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:25:38.371321: Step 2170: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:25:41.694793 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:25:41.694705: Step 2180: Train accuracy = 100.0%\n",
            "I1227 02:25:41.695833 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:25:41.695813: Step 2180: Cross entropy = 0.009069\n",
            "I1227 02:25:42.011198 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:25:42.011107: Step 2180: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:25:45.288856 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:25:45.288761: Step 2190: Train accuracy = 100.0%\n",
            "I1227 02:25:45.290003 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:25:45.289975: Step 2190: Cross entropy = 0.008546\n",
            "I1227 02:25:45.625336 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:25:45.625218: Step 2190: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:25:48.904892 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:25:48.904808: Step 2200: Train accuracy = 100.0%\n",
            "I1227 02:25:48.906142 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:25:48.906115: Step 2200: Cross entropy = 0.011566\n",
            "I1227 02:25:49.202460 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:25:49.202368: Step 2200: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:25:52.523947 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:25:52.523833: Step 2210: Train accuracy = 100.0%\n",
            "I1227 02:25:52.526137 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:25:52.526110: Step 2210: Cross entropy = 0.012232\n",
            "I1227 02:25:52.834415 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:25:52.834317: Step 2210: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:25:56.304611 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:25:56.304519: Step 2220: Train accuracy = 99.0%\n",
            "I1227 02:25:56.306082 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:25:56.306058: Step 2220: Cross entropy = 0.021967\n",
            "I1227 02:25:56.661794 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:25:56.661658: Step 2220: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:25:59.971924 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:25:59.971788: Step 2230: Train accuracy = 100.0%\n",
            "I1227 02:25:59.973281 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:25:59.973260: Step 2230: Cross entropy = 0.008451\n",
            "I1227 02:26:00.322738 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:26:00.322642: Step 2230: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:26:03.657576 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:26:03.657485: Step 2240: Train accuracy = 100.0%\n",
            "I1227 02:26:03.658794 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:26:03.658769: Step 2240: Cross entropy = 0.006790\n",
            "I1227 02:26:03.969926 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:26:03.969835: Step 2240: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:26:07.318898 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:26:07.318806: Step 2250: Train accuracy = 100.0%\n",
            "I1227 02:26:07.319925 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:26:07.319906: Step 2250: Cross entropy = 0.011994\n",
            "I1227 02:26:07.618898 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:26:07.618813: Step 2250: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:26:10.909934 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:26:10.909838: Step 2260: Train accuracy = 100.0%\n",
            "I1227 02:26:10.911494 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:26:10.911474: Step 2260: Cross entropy = 0.011894\n",
            "I1227 02:26:11.250488 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:26:11.250383: Step 2260: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:26:14.650172 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:26:14.649998: Step 2270: Train accuracy = 100.0%\n",
            "I1227 02:26:14.651458 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:26:14.651431: Step 2270: Cross entropy = 0.016517\n",
            "I1227 02:26:14.965799 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:26:14.965704: Step 2270: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:26:18.193296 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:26:18.193174: Step 2280: Train accuracy = 100.0%\n",
            "I1227 02:26:18.194431 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:26:18.194405: Step 2280: Cross entropy = 0.012243\n",
            "I1227 02:26:18.497661 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:26:18.497569: Step 2280: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:26:21.816366 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:26:21.816267: Step 2290: Train accuracy = 100.0%\n",
            "I1227 02:26:21.817677 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:26:21.817656: Step 2290: Cross entropy = 0.011115\n",
            "I1227 02:26:22.167997 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:26:22.167881: Step 2290: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:26:25.541115 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:26:25.541024: Step 2300: Train accuracy = 100.0%\n",
            "I1227 02:26:25.542347 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:26:25.542319: Step 2300: Cross entropy = 0.015145\n",
            "I1227 02:26:25.872246 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:26:25.872151: Step 2300: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:26:29.306258 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:26:29.306170: Step 2310: Train accuracy = 100.0%\n",
            "I1227 02:26:29.307552 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:26:29.307528: Step 2310: Cross entropy = 0.012172\n",
            "I1227 02:26:29.632050 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:26:29.631943: Step 2310: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:26:33.039879 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:26:33.039787: Step 2320: Train accuracy = 100.0%\n",
            "I1227 02:26:33.041145 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:26:33.041121: Step 2320: Cross entropy = 0.013963\n",
            "I1227 02:26:33.350196 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:26:33.350014: Step 2320: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:26:36.646656 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:26:36.646569: Step 2330: Train accuracy = 100.0%\n",
            "I1227 02:26:36.647979 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:26:36.647931: Step 2330: Cross entropy = 0.011173\n",
            "I1227 02:26:37.003988 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:26:37.003879: Step 2330: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:26:40.409404 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:26:40.409309: Step 2340: Train accuracy = 100.0%\n",
            "I1227 02:26:40.410766 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:26:40.410744: Step 2340: Cross entropy = 0.009783\n",
            "I1227 02:26:40.781686 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:26:40.781594: Step 2340: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:26:44.228235 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:26:44.228124: Step 2350: Train accuracy = 100.0%\n",
            "I1227 02:26:44.229322 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:26:44.229300: Step 2350: Cross entropy = 0.012172\n",
            "I1227 02:26:44.574435 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:26:44.574347: Step 2350: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:26:48.022415 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:26:48.022316: Step 2360: Train accuracy = 100.0%\n",
            "I1227 02:26:48.023932 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:26:48.023906: Step 2360: Cross entropy = 0.017062\n",
            "I1227 02:26:48.388744 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:26:48.388651: Step 2360: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:26:51.729706 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:26:51.729609: Step 2370: Train accuracy = 100.0%\n",
            "I1227 02:26:51.730924 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:26:51.730898: Step 2370: Cross entropy = 0.013679\n",
            "I1227 02:26:52.056539 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:26:52.056453: Step 2370: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:26:55.416073 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:26:55.415988: Step 2380: Train accuracy = 100.0%\n",
            "I1227 02:26:55.417225 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:26:55.417204: Step 2380: Cross entropy = 0.010708\n",
            "I1227 02:26:55.725744 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:26:55.725660: Step 2380: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:26:59.128954 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:26:59.128851: Step 2390: Train accuracy = 100.0%\n",
            "I1227 02:26:59.130176 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:26:59.130149: Step 2390: Cross entropy = 0.007821\n",
            "I1227 02:26:59.467369 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:26:59.467246: Step 2390: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:27:02.740591 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:27:02.740492: Step 2400: Train accuracy = 100.0%\n",
            "I1227 02:27:02.744835 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:27:02.744805: Step 2400: Cross entropy = 0.011633\n",
            "I1227 02:27:03.093157 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:27:03.093031: Step 2400: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:27:06.503073 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:27:06.502984: Step 2410: Train accuracy = 100.0%\n",
            "I1227 02:27:06.504517 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:27:06.504490: Step 2410: Cross entropy = 0.011610\n",
            "I1227 02:27:06.828864 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:27:06.828765: Step 2410: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:27:10.245002 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:27:10.244878: Step 2420: Train accuracy = 100.0%\n",
            "I1227 02:27:10.247335 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:27:10.247310: Step 2420: Cross entropy = 0.012067\n",
            "I1227 02:27:10.620762 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:27:10.620676: Step 2420: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:27:13.978710 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:27:13.978537: Step 2430: Train accuracy = 100.0%\n",
            "I1227 02:27:13.980184 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:27:13.980159: Step 2430: Cross entropy = 0.024761\n",
            "I1227 02:27:14.315143 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:27:14.315051: Step 2430: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:27:17.636536 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:27:17.636395: Step 2440: Train accuracy = 100.0%\n",
            "I1227 02:27:17.637904 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:27:17.637879: Step 2440: Cross entropy = 0.017696\n",
            "I1227 02:27:17.971311 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:27:17.971216: Step 2440: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:27:21.270508 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:27:21.270423: Step 2450: Train accuracy = 100.0%\n",
            "I1227 02:27:21.272032 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:27:21.271996: Step 2450: Cross entropy = 0.009658\n",
            "I1227 02:27:21.599052 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:27:21.598970: Step 2450: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:27:24.966637 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:27:24.966543: Step 2460: Train accuracy = 100.0%\n",
            "I1227 02:27:24.970196 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:27:24.970172: Step 2460: Cross entropy = 0.024278\n",
            "I1227 02:27:25.283149 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:27:25.283061: Step 2460: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:27:28.709437 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:27:28.709326: Step 2470: Train accuracy = 100.0%\n",
            "I1227 02:27:28.710738 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:27:28.710713: Step 2470: Cross entropy = 0.012454\n",
            "I1227 02:27:29.076811 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:27:29.076714: Step 2470: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:27:32.509818 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:27:32.509733: Step 2480: Train accuracy = 100.0%\n",
            "I1227 02:27:32.510945 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:27:32.510925: Step 2480: Cross entropy = 0.009433\n",
            "I1227 02:27:32.849259 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:27:32.849169: Step 2480: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:27:36.137367 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:27:36.137235: Step 2490: Train accuracy = 100.0%\n",
            "I1227 02:27:36.138761 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:27:36.138739: Step 2490: Cross entropy = 0.007571\n",
            "I1227 02:27:36.466563 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:27:36.466465: Step 2490: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:27:40.424804 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:27:40.424701: Step 2500: Train accuracy = 100.0%\n",
            "I1227 02:27:40.425947 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:27:40.425919: Step 2500: Cross entropy = 0.011929\n",
            "I1227 02:27:40.800028 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:27:40.799860: Step 2500: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:27:44.590272 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:27:44.590150: Step 2510: Train accuracy = 100.0%\n",
            "I1227 02:27:44.591510 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:27:44.591482: Step 2510: Cross entropy = 0.014477\n",
            "I1227 02:27:44.898004 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:27:44.897890: Step 2510: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:27:48.304411 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:27:48.304330: Step 2520: Train accuracy = 100.0%\n",
            "I1227 02:27:48.305618 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:27:48.305588: Step 2520: Cross entropy = 0.008123\n",
            "I1227 02:27:48.620471 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:27:48.620383: Step 2520: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:27:52.079938 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:27:52.079829: Step 2530: Train accuracy = 100.0%\n",
            "I1227 02:27:52.081561 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:27:52.081536: Step 2530: Cross entropy = 0.009903\n",
            "I1227 02:27:52.441239 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:27:52.441159: Step 2530: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:27:56.614190 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:27:56.614095: Step 2540: Train accuracy = 100.0%\n",
            "I1227 02:27:56.615566 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:27:56.615540: Step 2540: Cross entropy = 0.007960\n",
            "I1227 02:27:57.031319 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:27:57.031176: Step 2540: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:28:01.145869 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:28:01.145761: Step 2550: Train accuracy = 100.0%\n",
            "I1227 02:28:01.147001 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:28:01.146977: Step 2550: Cross entropy = 0.010428\n",
            "I1227 02:28:01.584851 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:28:01.584747: Step 2550: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:28:05.235826 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:28:05.235722: Step 2560: Train accuracy = 100.0%\n",
            "I1227 02:28:05.237325 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:28:05.237290: Step 2560: Cross entropy = 0.011058\n",
            "I1227 02:28:05.586724 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:28:05.586622: Step 2560: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:28:09.030136 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:28:09.029919: Step 2570: Train accuracy = 100.0%\n",
            "I1227 02:28:09.031646 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:28:09.031618: Step 2570: Cross entropy = 0.010266\n",
            "I1227 02:28:09.396122 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:28:09.396000: Step 2570: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:28:12.796247 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:28:12.796151: Step 2580: Train accuracy = 100.0%\n",
            "I1227 02:28:12.797325 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:28:12.797283: Step 2580: Cross entropy = 0.009920\n",
            "I1227 02:28:13.153918 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:28:13.153808: Step 2580: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:28:16.520197 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:28:16.520079: Step 2590: Train accuracy = 100.0%\n",
            "I1227 02:28:16.521373 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:28:16.521348: Step 2590: Cross entropy = 0.016901\n",
            "I1227 02:28:16.860054 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:28:16.859933: Step 2590: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:28:20.141229 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:28:20.141089: Step 2600: Train accuracy = 100.0%\n",
            "I1227 02:28:20.142553 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:28:20.142518: Step 2600: Cross entropy = 0.016119\n",
            "I1227 02:28:20.462111 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:28:20.462000: Step 2600: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:28:23.999251 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:28:23.999161: Step 2610: Train accuracy = 100.0%\n",
            "I1227 02:28:24.000652 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:28:24.000627: Step 2610: Cross entropy = 0.007854\n",
            "I1227 02:28:24.324573 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:28:24.324464: Step 2610: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:28:27.777060 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:28:27.776911: Step 2620: Train accuracy = 100.0%\n",
            "I1227 02:28:27.778708 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:28:27.778670: Step 2620: Cross entropy = 0.008754\n",
            "I1227 02:28:28.118791 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:28:28.118660: Step 2620: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:28:31.687127 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:28:31.687038: Step 2630: Train accuracy = 100.0%\n",
            "I1227 02:28:31.688566 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:28:31.688523: Step 2630: Cross entropy = 0.012610\n",
            "I1227 02:28:32.045848 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:28:32.045724: Step 2630: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:28:35.359162 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:28:35.359068: Step 2640: Train accuracy = 100.0%\n",
            "I1227 02:28:35.362756 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:28:35.362726: Step 2640: Cross entropy = 0.009173\n",
            "I1227 02:28:35.673743 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:28:35.673606: Step 2640: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:28:39.096105 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:28:39.095995: Step 2650: Train accuracy = 100.0%\n",
            "I1227 02:28:39.097327 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:28:39.097305: Step 2650: Cross entropy = 0.008938\n",
            "I1227 02:28:39.422793 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:28:39.422700: Step 2650: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:28:42.793414 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:28:42.793315: Step 2660: Train accuracy = 100.0%\n",
            "I1227 02:28:42.794627 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:28:42.794608: Step 2660: Cross entropy = 0.021936\n",
            "I1227 02:28:43.123399 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:28:43.123297: Step 2660: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:28:46.554502 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:28:46.554358: Step 2670: Train accuracy = 100.0%\n",
            "I1227 02:28:46.557033 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:28:46.557006: Step 2670: Cross entropy = 0.009357\n",
            "I1227 02:28:46.869489 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:28:46.869384: Step 2670: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:28:50.259561 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:28:50.259449: Step 2680: Train accuracy = 100.0%\n",
            "I1227 02:28:50.260755 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:28:50.260724: Step 2680: Cross entropy = 0.009166\n",
            "I1227 02:28:50.614382 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:28:50.614300: Step 2680: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:28:53.924893 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:28:53.924808: Step 2690: Train accuracy = 100.0%\n",
            "I1227 02:28:53.927734 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:28:53.927704: Step 2690: Cross entropy = 0.009890\n",
            "I1227 02:28:54.252068 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:28:54.251954: Step 2690: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:28:57.617587 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:28:57.617483: Step 2700: Train accuracy = 100.0%\n",
            "I1227 02:28:57.618926 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:28:57.618903: Step 2700: Cross entropy = 0.009479\n",
            "I1227 02:28:57.944902 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:28:57.944821: Step 2700: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:29:01.291494 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:29:01.291394: Step 2710: Train accuracy = 100.0%\n",
            "I1227 02:29:01.292995 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:29:01.292950: Step 2710: Cross entropy = 0.011126\n",
            "I1227 02:29:01.629424 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:29:01.629330: Step 2710: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:29:05.028085 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:29:05.027986: Step 2720: Train accuracy = 100.0%\n",
            "I1227 02:29:05.029342 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:29:05.029317: Step 2720: Cross entropy = 0.013538\n",
            "I1227 02:29:05.367406 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:29:05.367321: Step 2720: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:29:08.875662 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:29:08.875571: Step 2730: Train accuracy = 100.0%\n",
            "I1227 02:29:08.877027 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:29:08.877004: Step 2730: Cross entropy = 0.011229\n",
            "I1227 02:29:09.211652 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:29:09.211571: Step 2730: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:29:12.565036 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:29:12.564910: Step 2740: Train accuracy = 100.0%\n",
            "I1227 02:29:12.566341 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:29:12.566318: Step 2740: Cross entropy = 0.018064\n",
            "I1227 02:29:12.883576 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:29:12.883493: Step 2740: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:29:16.306532 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:29:16.306398: Step 2750: Train accuracy = 100.0%\n",
            "I1227 02:29:16.307717 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:29:16.307687: Step 2750: Cross entropy = 0.010224\n",
            "I1227 02:29:16.647211 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:29:16.647117: Step 2750: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:29:20.207005 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:29:20.206883: Step 2760: Train accuracy = 100.0%\n",
            "I1227 02:29:20.208557 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:29:20.208531: Step 2760: Cross entropy = 0.010835\n",
            "I1227 02:29:20.530230 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:29:20.530135: Step 2760: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:29:23.967579 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:29:23.967471: Step 2770: Train accuracy = 100.0%\n",
            "I1227 02:29:23.968907 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:29:23.968886: Step 2770: Cross entropy = 0.006821\n",
            "I1227 02:29:24.348001 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:29:24.347886: Step 2770: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:29:27.807056 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:29:27.806903: Step 2780: Train accuracy = 100.0%\n",
            "I1227 02:29:27.809366 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:29:27.809322: Step 2780: Cross entropy = 0.009201\n",
            "I1227 02:29:28.139636 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:29:28.139554: Step 2780: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:29:31.608605 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:29:31.608522: Step 2790: Train accuracy = 100.0%\n",
            "I1227 02:29:31.609649 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:29:31.609624: Step 2790: Cross entropy = 0.017962\n",
            "I1227 02:29:31.910997 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:29:31.910855: Step 2790: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:29:35.433130 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:29:35.433046: Step 2800: Train accuracy = 100.0%\n",
            "I1227 02:29:35.435081 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:29:35.435053: Step 2800: Cross entropy = 0.009548\n",
            "I1227 02:29:35.758385 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:29:35.758288: Step 2800: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:29:39.026141 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:29:39.026041: Step 2810: Train accuracy = 100.0%\n",
            "I1227 02:29:39.027224 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:29:39.027200: Step 2810: Cross entropy = 0.009579\n",
            "I1227 02:29:39.359749 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:29:39.359659: Step 2810: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:29:42.802090 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:29:42.801999: Step 2820: Train accuracy = 100.0%\n",
            "I1227 02:29:42.803280 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:29:42.803251: Step 2820: Cross entropy = 0.009407\n",
            "I1227 02:29:43.140864 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:29:43.140778: Step 2820: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:29:46.476562 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:29:46.476449: Step 2830: Train accuracy = 100.0%\n",
            "I1227 02:29:46.477834 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:29:46.477808: Step 2830: Cross entropy = 0.004405\n",
            "I1227 02:29:46.793537 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:29:46.793446: Step 2830: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:29:50.336362 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:29:50.336229: Step 2840: Train accuracy = 100.0%\n",
            "I1227 02:29:50.337429 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:29:50.337408: Step 2840: Cross entropy = 0.008528\n",
            "I1227 02:29:50.660246 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:29:50.660106: Step 2840: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:29:53.946186 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:29:53.946085: Step 2850: Train accuracy = 100.0%\n",
            "I1227 02:29:53.947343 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:29:53.947315: Step 2850: Cross entropy = 0.009019\n",
            "I1227 02:29:54.277604 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:29:54.277512: Step 2850: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:29:57.599739 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:29:57.599618: Step 2860: Train accuracy = 100.0%\n",
            "I1227 02:29:57.600944 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:29:57.600897: Step 2860: Cross entropy = 0.009565\n",
            "I1227 02:29:57.950897 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:29:57.950805: Step 2860: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:30:01.424818 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:30:01.424728: Step 2870: Train accuracy = 100.0%\n",
            "I1227 02:30:01.425928 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:30:01.425890: Step 2870: Cross entropy = 0.011468\n",
            "I1227 02:30:01.749692 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:30:01.749595: Step 2870: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:30:05.185735 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:30:05.185621: Step 2880: Train accuracy = 100.0%\n",
            "I1227 02:30:05.187072 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:30:05.187041: Step 2880: Cross entropy = 0.010376\n",
            "I1227 02:30:05.555633 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:30:05.555536: Step 2880: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:30:09.004504 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:30:09.004403: Step 2890: Train accuracy = 100.0%\n",
            "I1227 02:30:09.005819 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:30:09.005792: Step 2890: Cross entropy = 0.008410\n",
            "I1227 02:30:09.320441 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:30:09.320347: Step 2890: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:30:12.722886 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:30:12.722798: Step 2900: Train accuracy = 100.0%\n",
            "I1227 02:30:12.724354 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:30:12.724317: Step 2900: Cross entropy = 0.015837\n",
            "I1227 02:30:13.042623 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:30:13.042529: Step 2900: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:30:16.447856 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:30:16.447749: Step 2910: Train accuracy = 100.0%\n",
            "I1227 02:30:16.452920 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:30:16.452881: Step 2910: Cross entropy = 0.009256\n",
            "I1227 02:30:16.795134 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:30:16.795018: Step 2910: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:30:20.090153 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:30:20.090047: Step 2920: Train accuracy = 100.0%\n",
            "I1227 02:30:20.091425 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:30:20.091399: Step 2920: Cross entropy = 0.010867\n",
            "I1227 02:30:20.450467 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:30:20.450380: Step 2920: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:30:23.828459 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:30:23.828332: Step 2930: Train accuracy = 100.0%\n",
            "I1227 02:30:23.829619 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:30:23.829593: Step 2930: Cross entropy = 0.012746\n",
            "I1227 02:30:24.176699 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:30:24.176614: Step 2930: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:30:27.582143 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:30:27.582043: Step 2940: Train accuracy = 100.0%\n",
            "I1227 02:30:27.583413 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:30:27.583387: Step 2940: Cross entropy = 0.006896\n",
            "I1227 02:30:27.917900 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:30:27.917794: Step 2940: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:30:31.257753 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:30:31.257650: Step 2950: Train accuracy = 100.0%\n",
            "I1227 02:30:31.259190 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:30:31.259139: Step 2950: Cross entropy = 0.007289\n",
            "I1227 02:30:31.593007 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:30:31.592899: Step 2950: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:30:35.136576 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:30:35.136478: Step 2960: Train accuracy = 100.0%\n",
            "I1227 02:30:35.138214 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:30:35.138192: Step 2960: Cross entropy = 0.008918\n",
            "I1227 02:30:35.486881 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:30:35.486786: Step 2960: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:30:38.961211 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:30:38.961063: Step 2970: Train accuracy = 100.0%\n",
            "I1227 02:30:38.962466 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:30:38.962440: Step 2970: Cross entropy = 0.011940\n",
            "I1227 02:30:39.346630 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:30:39.346544: Step 2970: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:30:42.904859 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:30:42.904760: Step 2980: Train accuracy = 100.0%\n",
            "I1227 02:30:42.906212 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:30:42.906189: Step 2980: Cross entropy = 0.009606\n",
            "I1227 02:30:43.285644 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:30:43.285560: Step 2980: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:30:46.757373 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:30:46.757257: Step 2990: Train accuracy = 100.0%\n",
            "I1227 02:30:46.758587 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:30:46.758565: Step 2990: Cross entropy = 0.009171\n",
            "I1227 02:30:47.090135 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:30:47.090040: Step 2990: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:30:50.554259 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:30:50.554077: Step 3000: Train accuracy = 100.0%\n",
            "I1227 02:30:50.555494 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:30:50.555466: Step 3000: Cross entropy = 0.013035\n",
            "I1227 02:30:50.920714 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:30:50.920620: Step 3000: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:30:54.480160 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:30:54.480071: Step 3010: Train accuracy = 100.0%\n",
            "I1227 02:30:54.481531 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:30:54.481494: Step 3010: Cross entropy = 0.008370\n",
            "I1227 02:30:54.841452 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:30:54.841367: Step 3010: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:30:58.364375 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:30:58.364240: Step 3020: Train accuracy = 100.0%\n",
            "I1227 02:30:58.365703 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:30:58.365678: Step 3020: Cross entropy = 0.007005\n",
            "I1227 02:30:58.746396 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:30:58.746290: Step 3020: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:31:02.165627 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:31:02.165531: Step 3030: Train accuracy = 100.0%\n",
            "I1227 02:31:02.166793 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:31:02.166766: Step 3030: Cross entropy = 0.013142\n",
            "I1227 02:31:02.505276 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:31:02.505155: Step 3030: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:31:05.961241 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:31:05.961107: Step 3040: Train accuracy = 100.0%\n",
            "I1227 02:31:05.962566 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:31:05.962528: Step 3040: Cross entropy = 0.007994\n",
            "I1227 02:31:06.296819 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:31:06.296707: Step 3040: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:31:09.743146 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:31:09.743049: Step 3050: Train accuracy = 100.0%\n",
            "I1227 02:31:09.744530 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:31:09.744509: Step 3050: Cross entropy = 0.007672\n",
            "I1227 02:31:10.058097 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:31:10.057999: Step 3050: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:31:13.375067 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:31:13.374977: Step 3060: Train accuracy = 100.0%\n",
            "I1227 02:31:13.376249 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:31:13.376224: Step 3060: Cross entropy = 0.009293\n",
            "I1227 02:31:13.695633 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:31:13.695553: Step 3060: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:31:17.040927 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:31:17.040838: Step 3070: Train accuracy = 100.0%\n",
            "I1227 02:31:17.043289 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:31:17.043259: Step 3070: Cross entropy = 0.011195\n",
            "I1227 02:31:17.407632 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:31:17.407539: Step 3070: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:31:20.932672 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:31:20.932541: Step 3080: Train accuracy = 100.0%\n",
            "I1227 02:31:20.934056 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:31:20.934032: Step 3080: Cross entropy = 0.005989\n",
            "I1227 02:31:21.288734 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:31:21.288649: Step 3080: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:31:24.653522 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:31:24.653397: Step 3090: Train accuracy = 100.0%\n",
            "I1227 02:31:24.654896 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:31:24.654825: Step 3090: Cross entropy = 0.009172\n",
            "I1227 02:31:24.996026 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:31:24.995921: Step 3090: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:31:28.503738 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:31:28.503638: Step 3100: Train accuracy = 100.0%\n",
            "I1227 02:31:28.504874 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:31:28.504847: Step 3100: Cross entropy = 0.008754\n",
            "I1227 02:31:28.833099 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:31:28.833010: Step 3100: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:31:32.293625 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:31:32.293536: Step 3110: Train accuracy = 100.0%\n",
            "I1227 02:31:32.294914 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:31:32.294885: Step 3110: Cross entropy = 0.010665\n",
            "I1227 02:31:32.658608 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:31:32.658512: Step 3110: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:31:36.267709 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:31:36.267617: Step 3120: Train accuracy = 100.0%\n",
            "I1227 02:31:36.269244 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:31:36.269223: Step 3120: Cross entropy = 0.008540\n",
            "I1227 02:31:36.585917 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:31:36.585815: Step 3120: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:31:40.019457 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:31:40.019346: Step 3130: Train accuracy = 100.0%\n",
            "I1227 02:31:40.020860 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:31:40.020836: Step 3130: Cross entropy = 0.008843\n",
            "I1227 02:31:40.360320 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:31:40.360228: Step 3130: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:31:43.691518 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:31:43.691397: Step 3140: Train accuracy = 100.0%\n",
            "I1227 02:31:43.692901 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:31:43.692880: Step 3140: Cross entropy = 0.008838\n",
            "I1227 02:31:44.030266 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:31:44.030183: Step 3140: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:31:47.572779 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:31:47.572658: Step 3150: Train accuracy = 100.0%\n",
            "I1227 02:31:47.574179 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:31:47.574143: Step 3150: Cross entropy = 0.017083\n",
            "I1227 02:31:47.911016 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:31:47.910905: Step 3150: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:31:51.282241 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:31:51.282158: Step 3160: Train accuracy = 100.0%\n",
            "I1227 02:31:51.287032 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:31:51.286954: Step 3160: Cross entropy = 0.008674\n",
            "I1227 02:31:51.605519 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:31:51.605418: Step 3160: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:31:54.852091 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:31:54.851937: Step 3170: Train accuracy = 100.0%\n",
            "I1227 02:31:54.856596 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:31:54.856567: Step 3170: Cross entropy = 0.010010\n",
            "I1227 02:31:55.198767 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:31:55.198672: Step 3170: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:31:58.697120 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:31:58.697004: Step 3180: Train accuracy = 100.0%\n",
            "I1227 02:31:58.702127 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:31:58.702095: Step 3180: Cross entropy = 0.010241\n",
            "I1227 02:31:59.039150 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:31:59.039057: Step 3180: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:32:02.375182 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:32:02.375075: Step 3190: Train accuracy = 100.0%\n",
            "I1227 02:32:02.376402 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:32:02.376374: Step 3190: Cross entropy = 0.009780\n",
            "I1227 02:32:02.720822 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:32:02.720735: Step 3190: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:32:06.108873 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:32:06.108756: Step 3200: Train accuracy = 100.0%\n",
            "I1227 02:32:06.110081 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:32:06.110046: Step 3200: Cross entropy = 0.013877\n",
            "I1227 02:32:06.453402 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:32:06.453311: Step 3200: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:32:09.853022 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:32:09.852900: Step 3210: Train accuracy = 100.0%\n",
            "I1227 02:32:09.854209 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:32:09.854180: Step 3210: Cross entropy = 0.007437\n",
            "I1227 02:32:10.186820 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:32:10.186721: Step 3210: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:32:13.570381 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:32:13.570296: Step 3220: Train accuracy = 100.0%\n",
            "I1227 02:32:13.571493 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:32:13.571471: Step 3220: Cross entropy = 0.006344\n",
            "I1227 02:32:13.902631 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:32:13.902522: Step 3220: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:32:17.325079 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:32:17.324996: Step 3230: Train accuracy = 100.0%\n",
            "I1227 02:32:17.329950 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:32:17.329930: Step 3230: Cross entropy = 0.012380\n",
            "I1227 02:32:17.665902 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:32:17.665823: Step 3230: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:32:20.951918 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:32:20.951831: Step 3240: Train accuracy = 100.0%\n",
            "I1227 02:32:20.953194 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:32:20.953172: Step 3240: Cross entropy = 0.007519\n",
            "I1227 02:32:21.263770 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:32:21.263689: Step 3240: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:32:24.736209 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:32:24.736088: Step 3250: Train accuracy = 100.0%\n",
            "I1227 02:32:24.737246 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:32:24.737227: Step 3250: Cross entropy = 0.008886\n",
            "I1227 02:32:25.047009 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:32:25.046908: Step 3250: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:32:28.542103 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:32:28.542015: Step 3260: Train accuracy = 100.0%\n",
            "I1227 02:32:28.543312 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:32:28.543285: Step 3260: Cross entropy = 0.011234\n",
            "I1227 02:32:28.909932 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:32:28.909836: Step 3260: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:32:32.277703 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:32:32.277605: Step 3270: Train accuracy = 100.0%\n",
            "I1227 02:32:32.278851 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:32:32.278828: Step 3270: Cross entropy = 0.007595\n",
            "I1227 02:32:32.631498 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:32:32.631403: Step 3270: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:32:36.090426 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:32:36.090298: Step 3280: Train accuracy = 100.0%\n",
            "I1227 02:32:36.091937 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:32:36.091915: Step 3280: Cross entropy = 0.008285\n",
            "I1227 02:32:36.398015 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:32:36.397881: Step 3280: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:32:39.716719 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:32:39.716621: Step 3290: Train accuracy = 100.0%\n",
            "I1227 02:32:39.721976 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:32:39.721932: Step 3290: Cross entropy = 0.008839\n",
            "I1227 02:32:40.053857 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:32:40.053730: Step 3290: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:32:43.465039 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:32:43.464919: Step 3300: Train accuracy = 100.0%\n",
            "I1227 02:32:43.466342 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:32:43.466314: Step 3300: Cross entropy = 0.008800\n",
            "I1227 02:32:43.882071 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:32:43.881858: Step 3300: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:32:48.132526 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:32:48.132417: Step 3310: Train accuracy = 100.0%\n",
            "I1227 02:32:48.134903 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:32:48.134873: Step 3310: Cross entropy = 0.010199\n",
            "I1227 02:32:48.484312 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:32:48.484207: Step 3310: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:32:51.847598 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:32:51.847495: Step 3320: Train accuracy = 100.0%\n",
            "I1227 02:32:51.848899 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:32:51.848874: Step 3320: Cross entropy = 0.015630\n",
            "I1227 02:32:52.177810 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:32:52.177723: Step 3320: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:32:55.442342 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:32:55.442210: Step 3330: Train accuracy = 100.0%\n",
            "I1227 02:32:55.443892 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:32:55.443863: Step 3330: Cross entropy = 0.015360\n",
            "I1227 02:32:55.797013 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:32:55.796875: Step 3330: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:32:59.126820 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:32:59.126712: Step 3340: Train accuracy = 100.0%\n",
            "I1227 02:32:59.128111 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:32:59.128077: Step 3340: Cross entropy = 0.005513\n",
            "I1227 02:32:59.462265 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:32:59.462154: Step 3340: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:33:02.819527 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:33:02.819443: Step 3350: Train accuracy = 100.0%\n",
            "I1227 02:33:02.824106 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:33:02.824060: Step 3350: Cross entropy = 0.007423\n",
            "I1227 02:33:03.151714 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:33:03.151613: Step 3350: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:33:07.088798 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:33:07.088698: Step 3360: Train accuracy = 99.0%\n",
            "I1227 02:33:07.090018 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:33:07.089991: Step 3360: Cross entropy = 0.019175\n",
            "I1227 02:33:07.429742 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:33:07.429663: Step 3360: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:33:11.503204 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:33:11.503113: Step 3370: Train accuracy = 100.0%\n",
            "I1227 02:33:11.504577 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:33:11.504550: Step 3370: Cross entropy = 0.008908\n",
            "I1227 02:33:11.904243 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:33:11.904110: Step 3370: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:33:15.418788 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:33:15.418694: Step 3380: Train accuracy = 100.0%\n",
            "I1227 02:33:15.420092 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:33:15.420068: Step 3380: Cross entropy = 0.008200\n",
            "I1227 02:33:15.732430 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:33:15.732331: Step 3380: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:33:19.219103 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:33:19.218926: Step 3390: Train accuracy = 100.0%\n",
            "I1227 02:33:19.220379 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:33:19.220353: Step 3390: Cross entropy = 0.011793\n",
            "I1227 02:33:19.545459 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:33:19.545353: Step 3390: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:33:22.722650 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:33:22.722554: Step 3400: Train accuracy = 100.0%\n",
            "I1227 02:33:22.724407 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:33:22.724381: Step 3400: Cross entropy = 0.007817\n",
            "I1227 02:33:23.039051 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:33:23.038930: Step 3400: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:33:26.268810 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:33:26.268687: Step 3410: Train accuracy = 100.0%\n",
            "I1227 02:33:26.272701 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:33:26.272671: Step 3410: Cross entropy = 0.009212\n",
            "I1227 02:33:26.615710 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:33:26.615624: Step 3410: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:33:29.903449 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:33:29.903352: Step 3420: Train accuracy = 100.0%\n",
            "I1227 02:33:29.904707 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:33:29.904682: Step 3420: Cross entropy = 0.004082\n",
            "I1227 02:33:30.230162 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:33:30.230060: Step 3420: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:33:33.480056 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:33:33.479927: Step 3430: Train accuracy = 100.0%\n",
            "I1227 02:33:33.481439 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:33:33.481415: Step 3430: Cross entropy = 0.006688\n",
            "I1227 02:33:33.801347 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:33:33.801265: Step 3430: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:33:37.189580 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:33:37.189473: Step 3440: Train accuracy = 100.0%\n",
            "I1227 02:33:37.194425 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:33:37.194394: Step 3440: Cross entropy = 0.005465\n",
            "I1227 02:33:37.526005 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:33:37.525888: Step 3440: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:33:40.827587 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:33:40.827479: Step 3450: Train accuracy = 100.0%\n",
            "I1227 02:33:40.828949 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:33:40.828929: Step 3450: Cross entropy = 0.010648\n",
            "I1227 02:33:41.145414 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:33:41.145334: Step 3450: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:33:44.441654 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:33:44.441560: Step 3460: Train accuracy = 100.0%\n",
            "I1227 02:33:44.446536 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:33:44.446490: Step 3460: Cross entropy = 0.011582\n",
            "I1227 02:33:44.777223 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:33:44.777121: Step 3460: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:33:48.084637 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:33:48.084535: Step 3470: Train accuracy = 100.0%\n",
            "I1227 02:33:48.085905 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:33:48.085883: Step 3470: Cross entropy = 0.008185\n",
            "I1227 02:33:48.425451 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:33:48.425367: Step 3470: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:33:51.808190 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:33:51.808104: Step 3480: Train accuracy = 100.0%\n",
            "I1227 02:33:51.812667 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:33:51.812636: Step 3480: Cross entropy = 0.009216\n",
            "I1227 02:33:52.181847 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:33:52.181761: Step 3480: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:33:55.618283 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:33:55.618137: Step 3490: Train accuracy = 100.0%\n",
            "I1227 02:33:55.619344 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:33:55.619319: Step 3490: Cross entropy = 0.009307\n",
            "I1227 02:33:55.925523 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:33:55.925436: Step 3490: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:33:59.174911 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:33:59.174803: Step 3500: Train accuracy = 100.0%\n",
            "I1227 02:33:59.176078 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:33:59.176056: Step 3500: Cross entropy = 0.007935\n",
            "I1227 02:33:59.494663 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:33:59.494572: Step 3500: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:34:02.844409 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:34:02.844306: Step 3510: Train accuracy = 100.0%\n",
            "I1227 02:34:02.849558 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:34:02.849532: Step 3510: Cross entropy = 0.008011\n",
            "I1227 02:34:03.177330 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:34:03.177215: Step 3510: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:34:06.528900 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:34:06.528799: Step 3520: Train accuracy = 100.0%\n",
            "I1227 02:34:06.533905 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:34:06.533878: Step 3520: Cross entropy = 0.011615\n",
            "I1227 02:34:06.848793 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:34:06.848691: Step 3520: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:34:10.207621 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:34:10.207513: Step 3530: Train accuracy = 100.0%\n",
            "I1227 02:34:10.209722 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:34:10.209698: Step 3530: Cross entropy = 0.005851\n",
            "I1227 02:34:10.528449 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:34:10.528359: Step 3530: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:34:13.908982 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:34:13.908850: Step 3540: Train accuracy = 100.0%\n",
            "I1227 02:34:13.910433 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:34:13.910398: Step 3540: Cross entropy = 0.004053\n",
            "I1227 02:34:14.234472 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:34:14.234378: Step 3540: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:34:17.617536 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:34:17.617454: Step 3550: Train accuracy = 100.0%\n",
            "I1227 02:34:17.618912 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:34:17.618893: Step 3550: Cross entropy = 0.006586\n",
            "I1227 02:34:17.947578 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:34:17.947472: Step 3550: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:34:21.271387 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:34:21.271304: Step 3560: Train accuracy = 100.0%\n",
            "I1227 02:34:21.272587 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:34:21.272563: Step 3560: Cross entropy = 0.008769\n",
            "I1227 02:34:21.575561 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:34:21.575473: Step 3560: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:34:24.915011 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:34:24.914908: Step 3570: Train accuracy = 100.0%\n",
            "I1227 02:34:24.916254 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:34:24.916230: Step 3570: Cross entropy = 0.005720\n",
            "I1227 02:34:25.219418 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:34:25.219337: Step 3570: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:34:28.574593 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:34:28.574426: Step 3580: Train accuracy = 100.0%\n",
            "I1227 02:34:28.575942 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:34:28.575917: Step 3580: Cross entropy = 0.008175\n",
            "I1227 02:34:28.927314 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:34:28.927223: Step 3580: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:34:32.226939 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:34:32.226838: Step 3590: Train accuracy = 100.0%\n",
            "I1227 02:34:32.228221 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:34:32.228201: Step 3590: Cross entropy = 0.015037\n",
            "I1227 02:34:32.561051 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:34:32.560948: Step 3590: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:34:35.793522 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:34:35.793399: Step 3600: Train accuracy = 100.0%\n",
            "I1227 02:34:35.795373 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:34:35.795349: Step 3600: Cross entropy = 0.010009\n",
            "I1227 02:34:36.124135 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:34:36.124026: Step 3600: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:34:39.382642 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:34:39.382547: Step 3610: Train accuracy = 100.0%\n",
            "I1227 02:34:39.384164 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:34:39.384123: Step 3610: Cross entropy = 0.008101\n",
            "I1227 02:34:39.703223 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:34:39.703128: Step 3610: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:34:42.932147 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:34:42.932068: Step 3620: Train accuracy = 100.0%\n",
            "I1227 02:34:42.933276 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:34:42.933252: Step 3620: Cross entropy = 0.008148\n",
            "I1227 02:34:43.304803 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:34:43.304719: Step 3620: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:34:46.745910 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:34:46.745813: Step 3630: Train accuracy = 100.0%\n",
            "I1227 02:34:46.747042 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:34:46.747007: Step 3630: Cross entropy = 0.010082\n",
            "I1227 02:34:47.090119 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:34:47.090026: Step 3630: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:34:50.427249 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:34:50.427130: Step 3640: Train accuracy = 100.0%\n",
            "I1227 02:34:50.431102 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:34:50.431078: Step 3640: Cross entropy = 0.008565\n",
            "I1227 02:34:50.760363 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:34:50.760274: Step 3640: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:34:54.151766 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:34:54.151686: Step 3650: Train accuracy = 100.0%\n",
            "I1227 02:34:54.152832 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:34:54.152809: Step 3650: Cross entropy = 0.006894\n",
            "I1227 02:34:54.465522 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:34:54.465400: Step 3650: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:34:57.713860 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:34:57.713698: Step 3660: Train accuracy = 100.0%\n",
            "I1227 02:34:57.715480 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:34:57.715458: Step 3660: Cross entropy = 0.006465\n",
            "I1227 02:34:58.040732 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:34:58.040612: Step 3660: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:35:01.454924 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:35:01.454780: Step 3670: Train accuracy = 100.0%\n",
            "I1227 02:35:01.456296 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:35:01.456272: Step 3670: Cross entropy = 0.011687\n",
            "I1227 02:35:01.792631 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:35:01.792567: Step 3670: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:35:05.249774 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:35:05.249643: Step 3680: Train accuracy = 100.0%\n",
            "I1227 02:35:05.251209 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:35:05.251170: Step 3680: Cross entropy = 0.013640\n",
            "I1227 02:35:05.604847 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:35:05.604780: Step 3680: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:35:08.948390 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:35:08.948309: Step 3690: Train accuracy = 100.0%\n",
            "I1227 02:35:08.950464 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:35:08.950439: Step 3690: Cross entropy = 0.007556\n",
            "I1227 02:35:09.247866 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:35:09.247798: Step 3690: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:35:12.472866 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:35:12.472781: Step 3700: Train accuracy = 100.0%\n",
            "I1227 02:35:12.474137 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:35:12.474115: Step 3700: Cross entropy = 0.008907\n",
            "I1227 02:35:12.781891 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:35:12.781820: Step 3700: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:35:16.184180 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:35:16.184099: Step 3710: Train accuracy = 100.0%\n",
            "I1227 02:35:16.185225 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:35:16.185200: Step 3710: Cross entropy = 0.008728\n",
            "I1227 02:35:16.521061 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:35:16.520976: Step 3710: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:35:19.887766 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:35:19.887656: Step 3720: Train accuracy = 100.0%\n",
            "I1227 02:35:19.889346 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:35:19.889324: Step 3720: Cross entropy = 0.009189\n",
            "I1227 02:35:20.243999 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:35:20.243873: Step 3720: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:35:23.726257 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:35:23.726177: Step 3730: Train accuracy = 100.0%\n",
            "I1227 02:35:23.727695 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:35:23.727676: Step 3730: Cross entropy = 0.010184\n",
            "I1227 02:35:24.045455 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:35:24.045336: Step 3730: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:35:27.487565 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:35:27.487450: Step 3740: Train accuracy = 100.0%\n",
            "I1227 02:35:27.489000 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:35:27.488955: Step 3740: Cross entropy = 0.011486\n",
            "I1227 02:35:27.798302 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:35:27.798223: Step 3740: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:35:31.018822 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:35:31.018697: Step 3750: Train accuracy = 100.0%\n",
            "I1227 02:35:31.022245 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:35:31.022221: Step 3750: Cross entropy = 0.006362\n",
            "I1227 02:35:31.371806 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:35:31.371734: Step 3750: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:35:34.833696 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:35:34.833575: Step 3760: Train accuracy = 100.0%\n",
            "I1227 02:35:34.838017 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:35:34.837890: Step 3760: Cross entropy = 0.005877\n",
            "I1227 02:35:35.158758 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:35:35.158665: Step 3760: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:35:38.555739 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:35:38.555636: Step 3770: Train accuracy = 100.0%\n",
            "I1227 02:35:38.557342 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:35:38.557319: Step 3770: Cross entropy = 0.009226\n",
            "I1227 02:35:38.888291 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:35:38.888200: Step 3770: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:35:42.261679 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:35:42.261594: Step 3780: Train accuracy = 100.0%\n",
            "I1227 02:35:42.263295 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:35:42.263269: Step 3780: Cross entropy = 0.008228\n",
            "I1227 02:35:42.621839 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:35:42.621746: Step 3780: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:35:46.017647 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:35:46.017564: Step 3790: Train accuracy = 100.0%\n",
            "I1227 02:35:46.018762 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:35:46.018738: Step 3790: Cross entropy = 0.005335\n",
            "I1227 02:35:46.321022 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:35:46.320918: Step 3790: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:35:49.786826 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:35:49.786746: Step 3800: Train accuracy = 100.0%\n",
            "I1227 02:35:49.787928 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:35:49.787892: Step 3800: Cross entropy = 0.006094\n",
            "I1227 02:35:50.107447 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:35:50.107338: Step 3800: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:35:53.344549 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:35:53.344456: Step 3810: Train accuracy = 100.0%\n",
            "I1227 02:35:53.345647 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:35:53.345624: Step 3810: Cross entropy = 0.010895\n",
            "I1227 02:35:53.663819 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:35:53.663681: Step 3810: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:35:56.955888 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:35:56.955803: Step 3820: Train accuracy = 100.0%\n",
            "I1227 02:35:56.957332 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:35:56.957276: Step 3820: Cross entropy = 0.008065\n",
            "I1227 02:35:57.299942 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:35:57.299869: Step 3820: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:36:00.722187 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:36:00.722101: Step 3830: Train accuracy = 100.0%\n",
            "I1227 02:36:00.723248 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:36:00.723214: Step 3830: Cross entropy = 0.005316\n",
            "I1227 02:36:01.055594 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:36:01.055511: Step 3830: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:36:04.412231 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:36:04.412141: Step 3840: Train accuracy = 100.0%\n",
            "I1227 02:36:04.416122 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:36:04.416093: Step 3840: Cross entropy = 0.007834\n",
            "I1227 02:36:04.746148 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:36:04.746017: Step 3840: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:36:08.376070 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:36:08.375951: Step 3850: Train accuracy = 100.0%\n",
            "I1227 02:36:08.378096 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:36:08.378065: Step 3850: Cross entropy = 0.007752\n",
            "I1227 02:36:08.724530 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:36:08.724433: Step 3850: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:36:12.277795 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:36:12.277683: Step 3860: Train accuracy = 100.0%\n",
            "I1227 02:36:12.279054 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:36:12.279022: Step 3860: Cross entropy = 0.008267\n",
            "I1227 02:36:12.631359 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:36:12.631264: Step 3860: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:36:16.062799 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:36:16.062717: Step 3870: Train accuracy = 100.0%\n",
            "I1227 02:36:16.064400 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:36:16.064381: Step 3870: Cross entropy = 0.009212\n",
            "I1227 02:36:16.435816 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:36:16.435722: Step 3870: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:36:19.830041 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:36:19.829923: Step 3880: Train accuracy = 100.0%\n",
            "I1227 02:36:19.831075 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:36:19.831050: Step 3880: Cross entropy = 0.005886\n",
            "I1227 02:36:20.168677 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:36:20.168582: Step 3880: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:36:23.614236 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:36:23.614076: Step 3890: Train accuracy = 100.0%\n",
            "I1227 02:36:23.615353 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:36:23.615322: Step 3890: Cross entropy = 0.006838\n",
            "I1227 02:36:23.963872 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:36:23.963788: Step 3890: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:36:27.487515 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:36:27.487426: Step 3900: Train accuracy = 100.0%\n",
            "I1227 02:36:27.488765 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:36:27.488734: Step 3900: Cross entropy = 0.007290\n",
            "I1227 02:36:27.817303 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:36:27.817208: Step 3900: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:36:31.473356 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:36:31.473268: Step 3910: Train accuracy = 100.0%\n",
            "I1227 02:36:31.474492 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:36:31.474469: Step 3910: Cross entropy = 0.007244\n",
            "I1227 02:36:31.823582 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:36:31.823503: Step 3910: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:36:35.286268 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:36:35.286187: Step 3920: Train accuracy = 100.0%\n",
            "I1227 02:36:35.291392 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:36:35.291363: Step 3920: Cross entropy = 0.006080\n",
            "I1227 02:36:35.620759 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:36:35.620671: Step 3920: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:36:39.144219 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:36:39.144133: Step 3930: Train accuracy = 100.0%\n",
            "I1227 02:36:39.145397 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:36:39.145375: Step 3930: Cross entropy = 0.009907\n",
            "I1227 02:36:39.520951 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:36:39.520862: Step 3930: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:36:42.968004 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:36:42.967891: Step 3940: Train accuracy = 100.0%\n",
            "I1227 02:36:42.969515 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:36:42.969483: Step 3940: Cross entropy = 0.006666\n",
            "I1227 02:36:43.343728 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:36:43.343640: Step 3940: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:36:46.796597 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:36:46.796514: Step 3950: Train accuracy = 100.0%\n",
            "I1227 02:36:46.797751 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:36:46.797726: Step 3950: Cross entropy = 0.005709\n",
            "I1227 02:36:47.122250 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:36:47.122161: Step 3950: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:36:50.566195 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:36:50.566108: Step 3960: Train accuracy = 100.0%\n",
            "I1227 02:36:50.567587 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:36:50.567549: Step 3960: Cross entropy = 0.007590\n",
            "I1227 02:36:50.939756 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:36:50.939648: Step 3960: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:36:54.526046 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:36:54.525928: Step 3970: Train accuracy = 100.0%\n",
            "I1227 02:36:54.527218 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:36:54.527198: Step 3970: Cross entropy = 0.007506\n",
            "I1227 02:36:54.874748 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:36:54.874650: Step 3970: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:36:58.445827 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:36:58.445730: Step 3980: Train accuracy = 100.0%\n",
            "I1227 02:36:58.447237 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:36:58.447181: Step 3980: Cross entropy = 0.010127\n",
            "I1227 02:36:58.835381 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:36:58.835277: Step 3980: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:37:02.306065 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:37:02.305944: Step 3990: Train accuracy = 100.0%\n",
            "I1227 02:37:02.307185 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:37:02.307160: Step 3990: Cross entropy = 0.007552\n",
            "I1227 02:37:02.665190 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:37:02.665064: Step 3990: Validation accuracy = 100.0% (N=100)\n",
            "I1227 02:37:05.730557 140210095409024 <ipython-input-14-861d96b77d96>:116] 2019-12-27 02:37:05.730452: Step 3999: Train accuracy = 100.0%\n",
            "I1227 02:37:05.731945 140210095409024 <ipython-input-14-861d96b77d96>:118] 2019-12-27 02:37:05.731906: Step 3999: Cross entropy = 0.003630\n",
            "I1227 02:37:06.060619 140210095409024 <ipython-input-14-861d96b77d96>:137] 2019-12-27 02:37:06.060530: Step 3999: Validation accuracy = 100.0% (N=100)\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Saver not created because there are no variables in the graph to restore\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "I1227 02:37:15.723229 140210095409024 saver.py:1503] Saver not created because there are no variables in the graph to restore\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "Device mapping:\n",
            "/job:localhost/replica:0/task:0/device:XLA_CPU:0 -> device: XLA_CPU device\n",
            "/job:localhost/replica:0/task:0/device:XLA_GPU:0 -> device: XLA_GPU device\n",
            "/job:localhost/replica:0/task:0/device:GPU:0 -> device: 0, name: Tesla P100-PCIE-16GB, pci bus id: 0000:00:04.0, compute capability: 6.0\n",
            "\n",
            "INFO:tensorflow:Restoring parameters from /content/drive/My Drive/TensorFlow_model/tmp/retrain_tmp/_retrain_checkpoint\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "I1227 02:37:16.618149 140210095409024 saver.py:1284] Restoring parameters from /content/drive/My Drive/TensorFlow_model/tmp/retrain_tmp/_retrain_checkpoint\n",
            "I1227 02:37:20.884800 140210095409024 <ipython-input-13-b93e9db069e1>:416] Final test accuracy = 100.0% (N=1280)\n",
            "I1227 02:37:20.970943 140210095409024 <ipython-input-14-861d96b77d96>:165] Save final result to : /content/drive/My Drive/TensorFlow_model/tmp/retrain_tmp/output_graph.pb\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Saver not created because there are no variables in the graph to restore\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "I1227 02:37:24.889674 140210095409024 saver.py:1503] Saver not created because there are no variables in the graph to restore\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "Device mapping:\n",
            "/job:localhost/replica:0/task:0/device:XLA_CPU:0 -> device: XLA_CPU device\n",
            "/job:localhost/replica:0/task:0/device:XLA_GPU:0 -> device: XLA_GPU device\n",
            "/job:localhost/replica:0/task:0/device:GPU:0 -> device: 0, name: Tesla P100-PCIE-16GB, pci bus id: 0000:00:04.0, compute capability: 6.0\n",
            "\n",
            "INFO:tensorflow:Restoring parameters from /content/drive/My Drive/TensorFlow_model/tmp/retrain_tmp/_retrain_checkpoint\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "I1227 02:37:25.846151 140210095409024 saver.py:1284] Restoring parameters from /content/drive/My Drive/TensorFlow_model/tmp/retrain_tmp/_retrain_checkpoint\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "WARNING:tensorflow:From <ipython-input-13-b93e9db069e1>:456: convert_variables_to_constants (from tensorflow.python.framework.graph_util_impl) is deprecated and will be removed in a future version.\n",
            "Instructions for updating:\n",
            "Use `tf.compat.v1.graph_util.convert_variables_to_constants`\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "W1227 02:37:27.976955 140210095409024 deprecation.py:323] From <ipython-input-13-b93e9db069e1>:456: convert_variables_to_constants (from tensorflow.python.framework.graph_util_impl) is deprecated and will be removed in a future version.\n",
            "Instructions for updating:\n",
            "Use `tf.compat.v1.graph_util.convert_variables_to_constants`\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/tensorflow_core/python/framework/graph_util_impl.py:277: extract_sub_graph (from tensorflow.python.framework.graph_util_impl) is deprecated and will be removed in a future version.\n",
            "Instructions for updating:\n",
            "Use `tf.compat.v1.graph_util.extract_sub_graph`\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "W1227 02:37:27.981713 140210095409024 deprecation.py:323] From /usr/local/lib/python3.6/dist-packages/tensorflow_core/python/framework/graph_util_impl.py:277: extract_sub_graph (from tensorflow.python.framework.graph_util_impl) is deprecated and will be removed in a future version.\n",
            "Instructions for updating:\n",
            "Use `tf.compat.v1.graph_util.extract_sub_graph`\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Froze 378 variables.\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "I1227 02:37:29.823518 140210095409024 graph_util_impl.py:334] Froze 378 variables.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Converted 378 variables to const ops.\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "I1227 02:37:29.983168 140210095409024 graph_util_impl.py:394] Converted 378 variables to const ops.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "error",
          "ename": "SystemExit",
          "evalue": "ignored",
          "traceback": [
            "An exception has occurred, use %tb to see the full traceback.\n",
            "\u001b[0;31mSystemExit\u001b[0m\n"
          ]
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/IPython/core/interactiveshell.py:2890: UserWarning: To exit: use 'exit', 'quit', or Ctrl-D.\n",
            "  warn(\"To exit: use 'exit', 'quit', or Ctrl-D.\", stacklevel=1)\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cNZbK4qJN85a",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    }
  ]
}