ch14/ch14-notebook.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Python Machine Learning 3rd Edition* by [Sebastian Raschka](https://sebastianraschka.com) & [Vahid Mirjalili](http://vahidmirjalili.com), Packt Publishing Ltd. 2019\n",
    "\n",
    "Code Repository: https://github.com/rasbt/python-machine-learning-book-3rd-edition\n",
    "\n",
    "Code License: [MIT License](https://github.com/rasbt/python-machine-learning-book-3rd-edition/blob/master/LICENSE.txt)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Chapter 14: Going Deeper -- the Mechanics of TensorFlow\n",
    "===="
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The key features of TensorFlow\n",
    "\n",
    "### TensorFlow's computation graphs: migrating to TensorFlow v2\n",
    "\n",
    "### Understanding computation graphs\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Creating a graph in TensorFlow v1.x\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Result:  z= 1\n",
      "Result:  z= 1\n"
     ]
    }
   ],
   "source": [
    "## TF-v1.x style\n",
    "g = tf.Graph()\n",
    "with g.as_default():\n",
    "    a = tf.constant(1, name='a')\n",
    "    b = tf.constant(2, name='b')\n",
    "    c = tf.constant(3, name='c')\n",
    "    z = 2*(a-b) + c\n",
    "    \n",
    "with tf.compat.v1.Session(graph=g) as sess:\n",
    "    print('Result:  z=', sess.run(z))\n",
    "    print('Result:  z=', z.eval())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Migrating a graph to TensorFlow v2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Result:  z= 1\n"
     ]
    }
   ],
   "source": [
    "## TF v2 style\n",
    "a = tf.constant(1, name='a')\n",
    "b = tf.constant(2, name='b')\n",
    "c = tf.constant(3, name='c')\n",
    "\n",
    "z = 2*(a - b) + c\n",
    "tf.print('Result:  z=', z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Loading input data into a model: TensorFlow v1.x style"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Result:  z= 1\n"
     ]
    }
   ],
   "source": [
    "## TF-v1.x style\n",
    "g = tf.Graph()\n",
    "with g.as_default():\n",
    "    a = tf.compat.v1.placeholder(shape=None, dtype=tf.int32, name='tf_a')\n",
    "    b = tf.compat.v1.placeholder(shape=None, dtype=tf.int32, name='tf_b')\n",
    "    c = tf.compat.v1.placeholder(shape=None, dtype=tf.int32, name='tf_c')\n",
    "    z = 2*(a-b) + c\n",
    "    \n",
    "with tf.compat.v1.Session(graph=g) as sess:\n",
    "    feed_dict={a:1, b:2, c:3}\n",
    "    print('Result:  z=', sess.run(z, feed_dict=feed_dict))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Loading input data into a model: TensorFlow v2 style"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Scalar Inputs:  1\n",
      "Rank 1 Inputs:  [1]\n",
      "Rank 2 Inputs:  [[1]]\n"
     ]
    }
   ],
   "source": [
    "## TF-v2 style\n",
    "def compute_z(a, b, c):\n",
    "    r1 = tf.subtract(a, b)\n",
    "    r2 = tf.multiply(2, r1)\n",
    "    z = tf.add(r2, c)\n",
    "    return z\n",
    "\n",
    "tf.print('Scalar Inputs: ', compute_z(1, 2, 3))\n",
    "tf.print('Rank 1 Inputs: ', compute_z([1], [2], [3]))\n",
    "tf.print('Rank 2 Inputs: ', compute_z([[1]], [[2]], [[3]]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Improving computational performance with function decorators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Scalar Inputs:  1\n",
      "Rank 1 Inputs:  [1]\n",
      "Rank 2 Inputs:  [[1]]\n"
     ]
    }
   ],
   "source": [
    "@tf.function\n",
    "def compute_z(a, b, c):\n",
    "    r1 = tf.subtract(a, b)\n",
    "    r2 = tf.multiply(2, r1)\n",
    "    z = tf.add(r2, c)\n",
    "    return z\n",
    "\n",
    "tf.print('Scalar Inputs: ', compute_z(1, 2, 3))\n",
    "tf.print('Rank 1 Inputs: ', compute_z([1], [2], [3]))\n",
    "tf.print('Rank 2 Inputs: ', compute_z([[1]], [[2]], [[3]]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Rank 1 Inputs:  [1]\n",
      "Rank 1 Inputs:  [1 2]\n"
     ]
    }
   ],
   "source": [
    "@tf.function(input_signature=(tf.TensorSpec(shape=[None], dtype=tf.int32),\n",
    "                              tf.TensorSpec(shape=[None], dtype=tf.int32),\n",
    "                              tf.TensorSpec(shape=[None], dtype=tf.int32),))\n",
    "def compute_z(a, b, c):\n",
    "    r1 = tf.subtract(a, b)\n",
    "    r2 = tf.multiply(2, r1)\n",
    "    z = tf.add(r2, c)\n",
    "    return z\n",
    "\n",
    "tf.print('Rank 1 Inputs: ', compute_z([1], [2], [3]))\n",
    "tf.print('Rank 1 Inputs: ', compute_z([1, 2], [2, 4], [3, 6]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## we expect this to result in an error\n",
    "tf.print('Rank 2 Inputs: ', compute_z([[1], [2]], [[2], [4]], [[3], [6]]))\n",
    "\n",
    "\n",
    "## >> Error:\n",
    "#ValueError: Python inputs incompatible with input_signature: \n",
    "#inputs (([[1], [2]], [[2], [4]], [[3], [6]])), input_signature \n",
    "#((TensorSpec(shape=(None,), dtype=tf.int32, name=None), \n",
    "#  TensorSpec(shape=(None,), dtype=tf.int32, name=None), \n",
    "#  TensorSpec(shape=(None,), dtype=tf.int32, name=None)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "TensorSpec(shape=(None,), dtype=tf.int32, name=None)"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tf.TensorSpec(shape=[None], dtype=tf.int32)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## TensorFlow Variable objects for storing and updating model parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<tf.Variable 'var_a:0' shape=() dtype=float32, numpy=3.14>\n",
      "<tf.Variable 'var_b:0' shape=(3,) dtype=int32, numpy=array([1, 2, 3], dtype=int32)>\n",
      "<tf.Variable 'Variable:0' shape=(2,) dtype=bool, numpy=array([ True, False])>\n",
      "<tf.Variable 'Variable:0' shape=(1,) dtype=string, numpy=array([b'abc'], dtype=object)>\n"
     ]
    }
   ],
   "source": [
    "a = tf.Variable(initial_value=3.14, name='var_a')\n",
    "b = tf.Variable(initial_value=[1, 2, 3], name='var_b')\n",
    "c = tf.Variable(initial_value=[True, False], dtype=tf.bool)\n",
    "d = tf.Variable(initial_value=[\"abc\"], dtype=tf.string)\n",
    "print(a)\n",
    "print(b)\n",
    "print(c)\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.trainable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "w = tf.Variable([1, 2, 3], trainable=False)\n",
    "\n",
    "print(w.trainable)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<tf.Variable 'UnreadVariable' shape=(3,) dtype=int32, numpy=array([3, 1, 4], dtype=int32)>\n",
      "tf.Tensor([5 0 6], shape=(3,), dtype=int32)\n"
     ]
    }
   ],
   "source": [
    "print(w.assign([3, 1, 4], read_value=True))\n",
    "w.assign_add([2, -1, 2], read_value=False)\n",
    "\n",
    "print(w.value())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-0.722795904 1.01456821 0.251808226]\n"
     ]
    }
   ],
   "source": [
    "tf.random.set_seed(1)\n",
    "init = tf.keras.initializers.GlorotNormal()\n",
    "\n",
    "tf.print(init(shape=(3,)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.28982234 -0.782292783 -0.0453658961]\n",
      " [0.960991383 -0.120003454 0.708528221]]\n"
     ]
    }
   ],
   "source": [
    "v = tf.Variable(init(shape=(2, 3)))\n",
    "tf.print(v)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "All module variables:  [TensorShape([2, 3]), TensorShape([1, 2])]\n",
      "Trainable variable:    [TensorShape([2, 3])]\n"
     ]
    }
   ],
   "source": [
    "class MyModule(tf.Module):\n",
    "    def __init__(self):\n",
    "        init = tf.keras.initializers.GlorotNormal()\n",
    "        self.w1 = tf.Variable(init(shape=(2, 3)), trainable=True)\n",
    "        self.w2 = tf.Variable(init(shape=(1, 2)), trainable=False)\n",
    "                \n",
    "m = MyModule()\n",
    "print('All module variables: ', [v.shape for v in m.variables])\n",
    "print('Trainable variable:   ', [v.shape for v in\n",
    "                                 m.trainable_variables])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Variables with tf.function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## this will produce an error\n",
    "## ==> you cannot create a varibale inside a\n",
    "##     decorated function\n",
    "\n",
    "@tf.function\n",
    "def f(x):\n",
    "    w = tf.Variable([1, 2, 3])\n",
    "\n",
    "f([1])\n",
    "\n",
    "## ==> results in error\n",
    "## ValueError: tf.function-decorated function tried to create variables on non-first call."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[2.62276983]\n",
      " [3.40736914]\n",
      " [3.00806189]]\n"
     ]
    }
   ],
   "source": [
    "import tensorflow as tf\n",
    "\n",
    "#tf.random.set_seed(1)\n",
    "w = tf.Variable(tf.random.uniform((3, 3)))\n",
    "\n",
    "@tf.function\n",
    "def compute_z(x):    \n",
    "    return tf.matmul(w, x)\n",
    "\n",
    "x = tf.constant([[1], [2], [3]], dtype=tf.float32)\n",
    "tf.print(compute_z(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Computing gradients via automatic differentiation and GradientTape\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Computing the gradients of the loss with respect to trainable variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True True\n",
      "dL/dw :  -0.559999764\n"
     ]
    }
   ],
   "source": [
    "import tensorflow as tf\n",
    "\n",
    "w = tf.Variable(1.0)\n",
    "b = tf.Variable(0.5)\n",
    "print(w.trainable, b.trainable)\n",
    "\n",
    "x = tf.convert_to_tensor([1.4])\n",
    "y = tf.convert_to_tensor([2.1])\n",
    "\n",
    "with tf.GradientTape() as tape:\n",
    "    z = tf.add(tf.multiply(w, x), b)\n",
    "    loss = tf.reduce_sum(tf.square(y - z))\n",
    "\n",
    "dloss_dw = tape.gradient(loss, w)\n",
    "\n",
    "tf.print('dL/dw : ', dloss_dw)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-0.559999764]\n"
     ]
    }
   ],
   "source": [
    "# verifying the computed gradient\n",
    "tf.print(2*x*(w*x+b-y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Computing gradients with respect to non-trainable tensors\n",
    "\n",
    " Monitoring the non-trainable tensors via `tape.watch()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dL/dx :  [-0.399999857]\n"
     ]
    }
   ],
   "source": [
    "\n",
    "with tf.GradientTape() as tape:\n",
    "    tape.watch(x)\n",
    "    z = tf.add(tf.multiply(w, x), b)\n",
    "    loss = tf.square(y - z)\n",
    "\n",
    "dloss_dx = tape.gradient(loss, x)\n",
    "\n",
    "tf.print('dL/dx : ', dloss_dx)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-0.399999857]\n"
     ]
    }
   ],
   "source": [
    "# verifying the computed gradient\n",
    "tf.print(2*w*(w*x+b-y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Keeping resources for multiple gradient computations \n",
    "\n",
    "via `persistent=True`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dL/dw :  -0.559999764\n",
      "dL/db :  -0.399999857\n"
     ]
    }
   ],
   "source": [
    "with tf.GradientTape(persistent=True) as tape:\n",
    "    z = tf.add(tf.multiply(w, x), b)\n",
    "    loss = tf.reduce_sum(tf.square(y - z))\n",
    "\n",
    "dloss_dw = tape.gradient(loss, w)\n",
    "dloss_db = tape.gradient(loss, b)\n",
    "\n",
    "tf.print('dL/dw : ', dloss_dw)\n",
    "tf.print('dL/db : ', dloss_db)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Updating variables: `optimizer.apply_gradients()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Updated w:  1.0056\n",
      "Updated bias:  0.504\n"
     ]
    }
   ],
   "source": [
    "optimizer = tf.keras.optimizers.SGD()\n",
    "\n",
    "optimizer.apply_gradients(zip([dloss_dw, dloss_db], [w, b]))\n",
    "\n",
    "tf.print('Updated w: ', w)\n",
    "tf.print('Updated bias: ', b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Simplifying implementations of common architectures via the Keras API\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "dense (Dense)                multiple                  80        \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              multiple                  544       \n",
      "=================================================================\n",
      "Total params: 624\n",
      "Trainable params: 624\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "import tensorflow as tf\n",
    "\n",
    "model = tf.keras.Sequential()\n",
    "model.add(tf.keras.layers.Dense(16, activation='relu'))\n",
    "model.add(tf.keras.layers.Dense(32, activation='relu'))\n",
    "\n",
    "## late variable creation\n",
    "model.build(input_shape=(None, 4))\n",
    "model.summary()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dense/kernel:0       True (4, 16)\n",
      "dense/bias:0         True (16,)\n",
      "dense_1/kernel:0     True (16, 32)\n",
      "dense_1/bias:0       True (32,)\n"
     ]
    }
   ],
   "source": [
    "\n",
    "## printing variables of the model\n",
    "for v in model.variables:\n",
    "    print('{:20s}'.format(v.name), v.trainable, v.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Configuring layers\n",
    "\n",
    " * Keras Initializers `tf.keras.initializers`: https://www.tensorflow.org/versions/r2.0/api_docs/python/tf/keras/initializers  \n",
    " * Keras Regularizers `tf.keras.regularizers`: https://www.tensorflow.org/versions/r2.0/api_docs/python/tf/keras/regularizers  \n",
    " * Activations `tf.keras.activations`: https://www.tensorflow.org/versions/r2.0/api_docs/python/tf/keras/activations  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential_1\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "dense_2 (Dense)              multiple                  80        \n",
      "_________________________________________________________________\n",
      "dense_3 (Dense)              multiple                  544       \n",
      "=================================================================\n",
      "Total params: 624\n",
      "Trainable params: 624\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "model = tf.keras.Sequential()\n",
    "\n",
    "model.add(\n",
    "    tf.keras.layers.Dense(\n",
    "        units=16, \n",
    "        activation=tf.keras.activations.relu,\n",
    "        kernel_initializer=tf.keras.initializers.GlorotNormal(),\n",
    "        bias_initializer=tf.keras.initializers.Constant(2.0)\n",
    "    ))\n",
    "\n",
    "model.add(\n",
    "    tf.keras.layers.Dense(\n",
    "        units=32, \n",
    "        activation=tf.keras.activations.sigmoid,\n",
    "        kernel_regularizer=tf.keras.regularizers.l1\n",
    "    ))\n",
    "\n",
    "model.build(input_shape=(None, 4))\n",
    "model.summary()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Compiling a model\n",
    "\n",
    " * Keras Optimizers `tf.keras.optimizers`:  https://www.tensorflow.org/versions/r2.0/api_docs/python/tf/keras/optimizers\n",
    " * Keras Loss Functins `tf.keras.losses`: https://www.tensorflow.org/versions/r2.0/api_docs/python/tf/keras/losses\n",
    " * Keras Metrics `tf.keras.metrics`: https://www.tensorflow.org/versions/r2.0/api_docs/python/tf/keras/metrics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.compile(\n",
    "    optimizer=tf.keras.optimizers.SGD(learning_rate=0.001),\n",
    "    loss=tf.keras.losses.BinaryCrossentropy(),\n",
    "    metrics=[tf.keras.metrics.Accuracy(), \n",
    "             tf.keras.metrics.Precision(),\n",
    "             tf.keras.metrics.Recall(),])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Solving an XOR classification problem"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import tensorflow as tf\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "tf.random.set_seed(1)\n",
    "np.random.seed(1)\n",
    "\n",
    "x = np.random.uniform(low=-1, high=1, size=(200, 2))\n",
    "y = np.ones(len(x))\n",
    "y[x[:, 0] * x[:, 1]<0] = 0\n",
    "\n",
    "x_train = x[:100, :]\n",
    "y_train = y[:100]\n",
    "x_valid = x[100:, :]\n",
    "y_valid = y[100:]\n",
    "\n",
    "fig = plt.figure(figsize=(6, 6))\n",
    "plt.plot(x[y==0, 0], \n",
    "         x[y==0, 1], 'o', alpha=0.75, markersize=10)\n",
    "plt.plot(x[y==1, 0], \n",
    "         x[y==1, 1], '<', alpha=0.75, markersize=10)\n",
    "plt.xlabel(r'$x_1$', size=15)\n",
    "plt.ylabel(r'$x_2$', size=15)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "dense (Dense)                (None, 1)                 3         \n",
      "=================================================================\n",
      "Total params: 3\n",
      "Trainable params: 3\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "model = tf.keras.Sequential()\n",
    "model.add(tf.keras.layers.Dense(1, input_shape=(2,), \n",
    "                                activation='sigmoid'))\n",
    "\n",
    "model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.compile(optimizer=tf.keras.optimizers.SGD(),\n",
    "              loss=tf.keras.losses.BinaryCrossentropy(),\n",
    "              metrics=[tf.keras.metrics.BinaryAccuracy()])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "hist = model.fit(x_train, y_train, \n",
    "                 validation_data=(x_valid, y_valid), \n",
    "                 epochs=200, batch_size=2, verbose=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x288 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from mlxtend.plotting import plot_decision_regions\n",
    "\n",
    "history = hist.history\n",
    "\n",
    "fig = plt.figure(figsize=(16, 4))\n",
    "ax = fig.add_subplot(1, 3, 1)\n",
    "plt.plot(history['loss'], lw=4)\n",
    "plt.plot(history['val_loss'], lw=4)\n",
    "plt.legend(['Train loss', 'Validation loss'], fontsize=15)\n",
    "ax.set_xlabel('Epochs', size=15)\n",
    "\n",
    "ax = fig.add_subplot(1, 3, 2)\n",
    "plt.plot(history['binary_accuracy'], lw=4)\n",
    "plt.plot(history['val_binary_accuracy'], lw=4)\n",
    "plt.legend(['Train Acc.', 'Validation Acc.'], fontsize=15)\n",
    "ax.set_xlabel('Epochs', size=15)\n",
    "\n",
    "ax = fig.add_subplot(1, 3, 3)\n",
    "plot_decision_regions(X=x_valid, y=y_valid.astype(np.integer),\n",
    "                      clf=model)\n",
    "ax.set_xlabel(r'$x_1$', size=15)\n",
    "ax.xaxis.set_label_coords(1, -0.025)\n",
    "ax.set_ylabel(r'$x_2$', size=15)\n",
    "ax.yaxis.set_label_coords(-0.025, 1)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential_1\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "dense_1 (Dense)              (None, 4)                 12        \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 4)                 20        \n",
      "_________________________________________________________________\n",
      "dense_3 (Dense)              (None, 4)                 20        \n",
      "_________________________________________________________________\n",
      "dense_4 (Dense)              (None, 1)                 5         \n",
      "=================================================================\n",
      "Total params: 57\n",
      "Trainable params: 57\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "tf.random.set_seed(1)\n",
    "\n",
    "model = tf.keras.Sequential()\n",
    "model.add(tf.keras.layers.Dense(4, input_shape=(2,), activation='relu'))\n",
    "model.add(tf.keras.layers.Dense(4, activation='relu'))\n",
    "model.add(tf.keras.layers.Dense(4, activation='relu'))\n",
    "model.add(tf.keras.layers.Dense(1, activation='sigmoid'))\n",
    "\n",
    "model.summary()\n",
    "\n",
    "## compile:\n",
    "model.compile(optimizer=tf.keras.optimizers.SGD(),\n",
    "              loss=tf.keras.losses.BinaryCrossentropy(),\n",
    "              metrics=[tf.keras.metrics.BinaryAccuracy()])\n",
    "\n",
    "## train:\n",
    "hist = model.fit(x_train, y_train, \n",
    "                 validation_data=(x_valid, y_valid), \n",
    "                 epochs=200, batch_size=2, verbose=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x288 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "history = hist.history\n",
    "\n",
    "from mlxtend.plotting import plot_decision_regions\n",
    "\n",
    "fig = plt.figure(figsize=(16, 4))\n",
    "ax = fig.add_subplot(1, 3, 1)\n",
    "plt.plot(history['loss'], lw=4)\n",
    "plt.plot(history['val_loss'], lw=4)\n",
    "plt.legend(['Train loss', 'Validation loss'], fontsize=15)\n",
    "ax.set_xlabel('Epochs', size=15)\n",
    "\n",
    "ax = fig.add_subplot(1, 3, 2)\n",
    "plt.plot(history['binary_accuracy'], lw=4)\n",
    "plt.plot(history['val_binary_accuracy'], lw=4)\n",
    "plt.legend(['Train Acc.', 'Validation Acc.'], fontsize=15)\n",
    "ax.set_xlabel('Epochs', size=15)\n",
    "\n",
    "ax = fig.add_subplot(1, 3, 3)\n",
    "plot_decision_regions(X=x_valid, y=y_valid.astype(np.integer),\n",
    "                      clf=model)\n",
    "ax.set_xlabel(r'$x_1$', size=15)\n",
    "ax.xaxis.set_label_coords(1, -0.025)\n",
    "ax.set_ylabel(r'$x_2$', size=15)\n",
    "ax.yaxis.set_label_coords(-0.025, 1)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Making model building more flexible with Keras' functional API\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"model\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "input_1 (InputLayer)         [(None, 2)]               0         \n",
      "_________________________________________________________________\n",
      "dense_5 (Dense)              (None, 4)                 12        \n",
      "_________________________________________________________________\n",
      "dense_6 (Dense)              (None, 4)                 20        \n",
      "_________________________________________________________________\n",
      "dense_7 (Dense)              (None, 4)                 20        \n",
      "_________________________________________________________________\n",
      "dense_8 (Dense)              (None, 1)                 5         \n",
      "=================================================================\n",
      "Total params: 57\n",
      "Trainable params: 57\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "tf.random.set_seed(1)\n",
    "\n",
    "## input layer:\n",
    "inputs = tf.keras.Input(shape=(2,))\n",
    "\n",
    "## hidden layers\n",
    "h1 = tf.keras.layers.Dense(4, activation='relu')(inputs)\n",
    "h2 = tf.keras.layers.Dense(4, activation='relu')(h1)\n",
    "h3 = tf.keras.layers.Dense(4, activation='relu')(h2)\n",
    "\n",
    "## output:\n",
    "outputs = tf.keras.layers.Dense(1, activation='sigmoid')(h3)\n",
    "\n",
    "## construct a model:\n",
    "model = tf.keras.Model(inputs=inputs, outputs=outputs)\n",
    "\n",
    "model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x288 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "## compile:\n",
    "model.compile(optimizer=tf.keras.optimizers.SGD(),\n",
    "              loss=tf.keras.losses.BinaryCrossentropy(),\n",
    "              metrics=[tf.keras.metrics.BinaryAccuracy()])\n",
    "\n",
    "## train:\n",
    "hist = model.fit(x_train, y_train, \n",
    "                 validation_data=(x_valid, y_valid), \n",
    "                 epochs=200, batch_size=2, verbose=0)\n",
    "\n",
    "## Plotting\n",
    "history = hist.history\n",
    "\n",
    "from mlxtend.plotting import plot_decision_regions\n",
    "\n",
    "fig = plt.figure(figsize=(16, 4))\n",
    "ax = fig.add_subplot(1, 3, 1)\n",
    "plt.plot(history['loss'], lw=4)\n",
    "plt.plot(history['val_loss'], lw=4)\n",
    "plt.legend(['Train loss', 'Validation loss'], fontsize=15)\n",
    "ax.set_xlabel('Epochs', size=15)\n",
    "\n",
    "ax = fig.add_subplot(1, 3, 2)\n",
    "plt.plot(history['binary_accuracy'], lw=4)\n",
    "plt.plot(history['val_binary_accuracy'], lw=4)\n",
    "plt.legend(['Train Acc.', 'Validation Acc.'], fontsize=15)\n",
    "ax.set_xlabel('Epochs', size=15)\n",
    "\n",
    "ax = fig.add_subplot(1, 3, 3)\n",
    "plot_decision_regions(X=x_valid, y=y_valid.astype(np.integer),\n",
    "                      clf=model)\n",
    "ax.set_xlabel(r'$x_1$', size=15)\n",
    "ax.xaxis.set_label_coords(1, -0.025)\n",
    "ax.set_ylabel(r'$x_2$', size=15)\n",
    "ax.yaxis.set_label_coords(-0.025, 1)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Implementing models based on Keras' Model class\n",
    "\n",
    "#### Sub-classing `tf.keras.Model`\n",
    "\n",
    " * define `__init__()`\n",
    " * define `call()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"my_model\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "dense_17 (Dense)             multiple                  12        \n",
      "_________________________________________________________________\n",
      "dense_18 (Dense)             multiple                  20        \n",
      "_________________________________________________________________\n",
      "dense_19 (Dense)             multiple                  20        \n",
      "_________________________________________________________________\n",
      "dense_20 (Dense)             multiple                  5         \n",
      "=================================================================\n",
      "Total params: 57\n",
      "Trainable params: 57\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x288 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "class MyModel(tf.keras.Model):\n",
    "    def __init__(self):\n",
    "        super(MyModel, self).__init__()\n",
    "        self.hidden_1 = tf.keras.layers.Dense(4, activation='relu')\n",
    "        self.hidden_2 = tf.keras.layers.Dense(4, activation='relu')\n",
    "        self.hidden_3 = tf.keras.layers.Dense(4, activation='relu')\n",
    "        self.outputs = tf.keras.layers.Dense(1, activation='sigmoid')\n",
    "        \n",
    "    def call(self, inputs):\n",
    "        h = self.hidden_1(inputs)\n",
    "        h = self.hidden_2(h)\n",
    "        h = self.hidden_3(h)\n",
    "        return self.outputs(h)\n",
    "    \n",
    "tf.random.set_seed(1)\n",
    "\n",
    "## testing:\n",
    "model = MyModel()\n",
    "model.build(input_shape=(None, 2))\n",
    "\n",
    "model.summary()\n",
    "\n",
    "## compile:\n",
    "model.compile(optimizer=tf.keras.optimizers.SGD(),\n",
    "              loss=tf.keras.losses.BinaryCrossentropy(),\n",
    "              metrics=[tf.keras.metrics.BinaryAccuracy()])\n",
    "\n",
    "## train:\n",
    "hist = model.fit(x_train, y_train, \n",
    "                 validation_data=(x_valid, y_valid), \n",
    "                 epochs=200, batch_size=2, verbose=0)\n",
    "\n",
    "## Plotting\n",
    "history = hist.history\n",
    "\n",
    "from mlxtend.plotting import plot_decision_regions\n",
    "\n",
    "fig = plt.figure(figsize=(16, 4))\n",
    "ax = fig.add_subplot(1, 3, 1)\n",
    "plt.plot(history['loss'], lw=4)\n",
    "plt.plot(history['val_loss'], lw=4)\n",
    "plt.legend(['Train loss', 'Validation loss'], fontsize=15)\n",
    "ax.set_xlabel('Epochs', size=15)\n",
    "\n",
    "ax = fig.add_subplot(1, 3, 2)\n",
    "plt.plot(history['binary_accuracy'], lw=4)\n",
    "plt.plot(history['val_binary_accuracy'], lw=4)\n",
    "plt.legend(['Train Acc.', 'Validation Acc.'], fontsize=15)\n",
    "ax.set_xlabel('Epochs', size=15)\n",
    "\n",
    "ax = fig.add_subplot(1, 3, 3)\n",
    "plot_decision_regions(X=x_valid, y=y_valid.astype(np.integer),\n",
    "                      clf=model)\n",
    "ax.set_xlabel(r'$x_1$', size=15)\n",
    "ax.xaxis.set_label_coords(1, -0.025)\n",
    "ax.set_ylabel(r'$x_2$', size=15)\n",
    "ax.yaxis.set_label_coords(-0.025, 1)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.get_config()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Writing custom Keras layers\n",
    "\n",
    "\n",
    "#### Defining a custom layer:\n",
    " * Define `__init__()`\n",
    " * Define `build()` for late-variable creation\n",
    " * Define `call()`\n",
    " * Define `get_config()` for serialization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0 0.00821428 0 0]]\n",
      "[[0 0.0108502861 0 0]]\n"
     ]
    }
   ],
   "source": [
    "import tensorflow as tf\n",
    "\n",
    "class NoisyLinear(tf.keras.layers.Layer):\n",
    "    def __init__(self, output_dim, noise_stddev=0.1, **kwargs):\n",
    "        self.output_dim = output_dim\n",
    "        self.noise_stddev = noise_stddev\n",
    "        super(NoisyLinear, self).__init__(**kwargs)\n",
    "\n",
    "    def build(self, input_shape):\n",
    "        self.w = self.add_weight(name='weights',\n",
    "                                 shape=(input_shape[1], self.output_dim),\n",
    "                                 initializer='random_normal',\n",
    "                                 trainable=True)\n",
    "        \n",
    "        self.b = self.add_weight(shape=(self.output_dim,),\n",
    "                                 initializer='zeros',\n",
    "                                 trainable=True)\n",
    "\n",
    "    def call(self, inputs, training=False):\n",
    "        if training:\n",
    "            batch = tf.shape(inputs)[0]\n",
    "            dim = tf.shape(inputs)[1]\n",
    "            noise = tf.random.normal(shape=(batch, dim),\n",
    "                                     mean=0.0,\n",
    "                                     stddev=self.noise_stddev)\n",
    "\n",
    "            noisy_inputs = tf.add(inputs, noise)\n",
    "        else:\n",
    "            noisy_inputs = inputs\n",
    "        z = tf.matmul(noisy_inputs, self.w) + self.b\n",
    "        return tf.keras.activations.relu(z)\n",
    "    \n",
    "    def get_config(self):\n",
    "        config = super(NoisyLinear, self).get_config()\n",
    "        config.update({'output_dim': self.output_dim,\n",
    "                       'noise_stddev': self.noise_stddev})\n",
    "        return config\n",
    "\n",
    "\n",
    "## testing:\n",
    "\n",
    "tf.random.set_seed(1)\n",
    "\n",
    "noisy_layer = NoisyLinear(4)\n",
    "noisy_layer.build(input_shape=(None, 4))\n",
    "\n",
    "x = tf.zeros(shape=(1, 4))\n",
    "tf.print(noisy_layer(x, training=True))\n",
    "\n",
    "## re-building from config:\n",
    "config = noisy_layer.get_config()\n",
    "new_layer = NoisyLinear.from_config(config)\n",
    "tf.print(new_layer(x, training=True))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential_2\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "noisy_linear_1 (NoisyLinear) multiple                  12        \n",
      "_________________________________________________________________\n",
      "dense_5 (Dense)              multiple                  20        \n",
      "_________________________________________________________________\n",
      "dense_6 (Dense)              multiple                  20        \n",
      "_________________________________________________________________\n",
      "dense_7 (Dense)              multiple                  5         \n",
      "=================================================================\n",
      "Total params: 57\n",
      "Trainable params: 57\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x288 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "tf.random.set_seed(1)\n",
    "\n",
    "model = tf.keras.Sequential([\n",
    "    NoisyLinear(4, noise_stddev=0.1),\n",
    "    tf.keras.layers.Dense(4, activation='relu'),\n",
    "    tf.keras.layers.Dense(4, activation='relu'),\n",
    "    tf.keras.layers.Dense(1, activation='sigmoid')])\n",
    "\n",
    "model.build(input_shape=(None, 2))\n",
    "model.summary()\n",
    "\n",
    "## compile:\n",
    "model.compile(optimizer=tf.keras.optimizers.SGD(),\n",
    "              loss=tf.keras.losses.BinaryCrossentropy(),\n",
    "              metrics=[tf.keras.metrics.BinaryAccuracy()])\n",
    "\n",
    "## train:\n",
    "hist = model.fit(x_train, y_train, \n",
    "                 validation_data=(x_valid, y_valid), \n",
    "                 epochs=200, batch_size=2, \n",
    "                 verbose=0)\n",
    "\n",
    "## Plotting\n",
    "history = hist.history\n",
    "\n",
    "from mlxtend.plotting import plot_decision_regions\n",
    "\n",
    "fig = plt.figure(figsize=(16, 4))\n",
    "ax = fig.add_subplot(1, 3, 1)\n",
    "plt.plot(history['loss'], lw=4)\n",
    "plt.plot(history['val_loss'], lw=4)\n",
    "plt.legend(['Train loss', 'Validation loss'], fontsize=15)\n",
    "ax.set_xlabel('Epochs', size=15)\n",
    "\n",
    "ax = fig.add_subplot(1, 3, 2)\n",
    "plt.plot(history['binary_accuracy'], lw=4)\n",
    "plt.plot(history['val_binary_accuracy'], lw=4)\n",
    "plt.legend(['Train Acc.', 'Validation Acc.'], fontsize=15)\n",
    "ax.set_xlabel('Epochs', size=15)\n",
    "\n",
    "ax = fig.add_subplot(1, 3, 3)\n",
    "plot_decision_regions(X=x_valid, y=y_valid.astype(np.integer),\n",
    "                      clf=model)\n",
    "ax.set_xlabel(r'$x_1$', size=15)\n",
    "ax.xaxis.set_label_coords(1, -0.025)\n",
    "ax.set_ylabel(r'$x_2$', size=15)\n",
    "ax.yaxis.set_label_coords(-0.025, 1)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## TensorFlow Estimators\n",
    "\n",
    "##### Steps for using pre-made estimators\n",
    "\n",
    " * **Step 1:** Define the input function for importing the data   \n",
    " * **Step 2:**  Define the feature columns to bridge between the estimator and the data   \n",
    " * **Step 3:** Instantiate an estimator or convert a Keras model to an estimator   \n",
    " * **Step 4:** Use the estimator: train() evaluate() predict()   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Working with feature columns\n",
    "\n",
    "\n",
    " * See definition: https://developers.google.com/machine-learning/glossary/#feature_columns\n",
    " * Documentation: https://www.tensorflow.org/api_docs/python/tf/feature_column"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "\n",
    "tf.random.set_seed(1)\n",
    "np.random.seed(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>MPG</th>\n",
       "      <th>Cylinders</th>\n",
       "      <th>Displacement</th>\n",
       "      <th>Horsepower</th>\n",
       "      <th>Weight</th>\n",
       "      <th>Acceleration</th>\n",
       "      <th>ModelYear</th>\n",
       "      <th>Origin</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>393</td>\n",
       "      <td>27.0</td>\n",
       "      <td>4</td>\n",
       "      <td>140.0</td>\n",
       "      <td>86.0</td>\n",
       "      <td>2790.0</td>\n",
       "      <td>15.6</td>\n",
       "      <td>82</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>394</td>\n",
       "      <td>44.0</td>\n",
       "      <td>4</td>\n",
       "      <td>97.0</td>\n",
       "      <td>52.0</td>\n",
       "      <td>2130.0</td>\n",
       "      <td>24.6</td>\n",
       "      <td>82</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>395</td>\n",
       "      <td>32.0</td>\n",
       "      <td>4</td>\n",
       "      <td>135.0</td>\n",
       "      <td>84.0</td>\n",
       "      <td>2295.0</td>\n",
       "      <td>11.6</td>\n",
       "      <td>82</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>396</td>\n",
       "      <td>28.0</td>\n",
       "      <td>4</td>\n",
       "      <td>120.0</td>\n",
       "      <td>79.0</td>\n",
       "      <td>2625.0</td>\n",
       "      <td>18.6</td>\n",
       "      <td>82</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>397</td>\n",
       "      <td>31.0</td>\n",
       "      <td>4</td>\n",
       "      <td>119.0</td>\n",
       "      <td>82.0</td>\n",
       "      <td>2720.0</td>\n",
       "      <td>19.4</td>\n",
       "      <td>82</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      MPG  Cylinders  Displacement  Horsepower  Weight  Acceleration  \\\n",
       "393  27.0          4         140.0        86.0  2790.0          15.6   \n",
       "394  44.0          4          97.0        52.0  2130.0          24.6   \n",
       "395  32.0          4         135.0        84.0  2295.0          11.6   \n",
       "396  28.0          4         120.0        79.0  2625.0          18.6   \n",
       "397  31.0          4         119.0        82.0  2720.0          19.4   \n",
       "\n",
       "     ModelYear  Origin  \n",
       "393         82       1  \n",
       "394         82       2  \n",
       "395         82       1  \n",
       "396         82       1  \n",
       "397         82       1  "
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataset_path = tf.keras.utils.get_file(\"auto-mpg.data\", \n",
    "                                       (\"http://archive.ics.uci.edu/ml/machine-learning-databases\"\n",
    "                                        \"/auto-mpg/auto-mpg.data\"))\n",
    "\n",
    "column_names = ['MPG', 'Cylinders', 'Displacement', 'Horsepower',\n",
    "                'Weight', 'Acceleration', 'ModelYear', 'Origin']\n",
    "\n",
    "df = pd.read_csv(dataset_path, names=column_names,\n",
    "                 na_values = \"?\", comment='\\t',\n",
    "                 sep=\" \", skipinitialspace=True)\n",
    "\n",
    "df.tail()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MPG             0\n",
      "Cylinders       0\n",
      "Displacement    0\n",
      "Horsepower      6\n",
      "Weight          0\n",
      "Acceleration    0\n",
      "ModelYear       0\n",
      "Origin          0\n",
      "dtype: int64\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>MPG</th>\n",
       "      <th>Cylinders</th>\n",
       "      <th>Displacement</th>\n",
       "      <th>Horsepower</th>\n",
       "      <th>Weight</th>\n",
       "      <th>Acceleration</th>\n",
       "      <th>ModelYear</th>\n",
       "      <th>Origin</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>387</td>\n",
       "      <td>27.0</td>\n",
       "      <td>4</td>\n",
       "      <td>140.0</td>\n",
       "      <td>86.0</td>\n",
       "      <td>2790.0</td>\n",
       "      <td>15.6</td>\n",
       "      <td>82</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>388</td>\n",
       "      <td>44.0</td>\n",
       "      <td>4</td>\n",
       "      <td>97.0</td>\n",
       "      <td>52.0</td>\n",
       "      <td>2130.0</td>\n",
       "      <td>24.6</td>\n",
       "      <td>82</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>389</td>\n",
       "      <td>32.0</td>\n",
       "      <td>4</td>\n",
       "      <td>135.0</td>\n",
       "      <td>84.0</td>\n",
       "      <td>2295.0</td>\n",
       "      <td>11.6</td>\n",
       "      <td>82</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>390</td>\n",
       "      <td>28.0</td>\n",
       "      <td>4</td>\n",
       "      <td>120.0</td>\n",
       "      <td>79.0</td>\n",
       "      <td>2625.0</td>\n",
       "      <td>18.6</td>\n",
       "      <td>82</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>391</td>\n",
       "      <td>31.0</td>\n",
       "      <td>4</td>\n",
       "      <td>119.0</td>\n",
       "      <td>82.0</td>\n",
       "      <td>2720.0</td>\n",
       "      <td>19.4</td>\n",
       "      <td>82</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      MPG  Cylinders  Displacement  Horsepower  Weight  Acceleration  \\\n",
       "387  27.0          4         140.0        86.0  2790.0          15.6   \n",
       "388  44.0          4          97.0        52.0  2130.0          24.6   \n",
       "389  32.0          4         135.0        84.0  2295.0          11.6   \n",
       "390  28.0          4         120.0        79.0  2625.0          18.6   \n",
       "391  31.0          4         119.0        82.0  2720.0          19.4   \n",
       "\n",
       "     ModelYear  Origin  \n",
       "387         82       1  \n",
       "388         82       2  \n",
       "389         82       1  \n",
       "390         82       1  \n",
       "391         82       1  "
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(df.isna().sum())\n",
    "\n",
    "df = df.dropna()\n",
    "\n",
    "df = df.reset_index(drop=True)\n",
    "\n",
    "df.tail()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>count</th>\n",
       "      <th>mean</th>\n",
       "      <th>std</th>\n",
       "      <th>min</th>\n",
       "      <th>25%</th>\n",
       "      <th>50%</th>\n",
       "      <th>75%</th>\n",
       "      <th>max</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>MPG</td>\n",
       "      <td>313.0</td>\n",
       "      <td>23.404153</td>\n",
       "      <td>7.666909</td>\n",
       "      <td>9.0</td>\n",
       "      <td>17.5</td>\n",
       "      <td>23.0</td>\n",
       "      <td>29.0</td>\n",
       "      <td>46.6</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>Cylinders</td>\n",
       "      <td>313.0</td>\n",
       "      <td>5.402556</td>\n",
       "      <td>1.701506</td>\n",
       "      <td>3.0</td>\n",
       "      <td>4.0</td>\n",
       "      <td>4.0</td>\n",
       "      <td>8.0</td>\n",
       "      <td>8.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>Displacement</td>\n",
       "      <td>313.0</td>\n",
       "      <td>189.512780</td>\n",
       "      <td>102.675646</td>\n",
       "      <td>68.0</td>\n",
       "      <td>104.0</td>\n",
       "      <td>140.0</td>\n",
       "      <td>260.0</td>\n",
       "      <td>455.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>Horsepower</td>\n",
       "      <td>313.0</td>\n",
       "      <td>102.929712</td>\n",
       "      <td>37.919046</td>\n",
       "      <td>46.0</td>\n",
       "      <td>75.0</td>\n",
       "      <td>92.0</td>\n",
       "      <td>120.0</td>\n",
       "      <td>230.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>Weight</td>\n",
       "      <td>313.0</td>\n",
       "      <td>2961.198083</td>\n",
       "      <td>848.602146</td>\n",
       "      <td>1613.0</td>\n",
       "      <td>2219.0</td>\n",
       "      <td>2755.0</td>\n",
       "      <td>3574.0</td>\n",
       "      <td>5140.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>Acceleration</td>\n",
       "      <td>313.0</td>\n",
       "      <td>15.704473</td>\n",
       "      <td>2.725399</td>\n",
       "      <td>8.5</td>\n",
       "      <td>14.0</td>\n",
       "      <td>15.5</td>\n",
       "      <td>17.3</td>\n",
       "      <td>24.8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>ModelYear</td>\n",
       "      <td>313.0</td>\n",
       "      <td>75.929712</td>\n",
       "      <td>3.675305</td>\n",
       "      <td>70.0</td>\n",
       "      <td>73.0</td>\n",
       "      <td>76.0</td>\n",
       "      <td>79.0</td>\n",
       "      <td>82.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>Origin</td>\n",
       "      <td>313.0</td>\n",
       "      <td>1.591054</td>\n",
       "      <td>0.807923</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>3.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "              count         mean         std     min     25%     50%     75%  \\\n",
       "MPG           313.0    23.404153    7.666909     9.0    17.5    23.0    29.0   \n",
       "Cylinders     313.0     5.402556    1.701506     3.0     4.0     4.0     8.0   \n",
       "Displacement  313.0   189.512780  102.675646    68.0   104.0   140.0   260.0   \n",
       "Horsepower    313.0   102.929712   37.919046    46.0    75.0    92.0   120.0   \n",
       "Weight        313.0  2961.198083  848.602146  1613.0  2219.0  2755.0  3574.0   \n",
       "Acceleration  313.0    15.704473    2.725399     8.5    14.0    15.5    17.3   \n",
       "ModelYear     313.0    75.929712    3.675305    70.0    73.0    76.0    79.0   \n",
       "Origin        313.0     1.591054    0.807923     1.0     1.0     1.0     2.0   \n",
       "\n",
       "                 max  \n",
       "MPG             46.6  \n",
       "Cylinders        8.0  \n",
       "Displacement   455.0  \n",
       "Horsepower     230.0  \n",
       "Weight        5140.0  \n",
       "Acceleration    24.8  \n",
       "ModelYear       82.0  \n",
       "Origin           3.0  "
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import sklearn\n",
    "import sklearn.model_selection\n",
    "\n",
    "df_train, df_test = sklearn.model_selection.train_test_split(df, train_size=0.8)\n",
    "\n",
    "\n",
    "train_stats = df_train.describe().transpose()\n",
    "\n",
    "train_stats"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>MPG</th>\n",
       "      <th>Cylinders</th>\n",
       "      <th>Displacement</th>\n",
       "      <th>Horsepower</th>\n",
       "      <th>Weight</th>\n",
       "      <th>Acceleration</th>\n",
       "      <th>ModelYear</th>\n",
       "      <th>Origin</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>203</td>\n",
       "      <td>28.0</td>\n",
       "      <td>-0.824303</td>\n",
       "      <td>-0.901020</td>\n",
       "      <td>-0.736562</td>\n",
       "      <td>-0.950031</td>\n",
       "      <td>0.255202</td>\n",
       "      <td>76</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>255</td>\n",
       "      <td>19.4</td>\n",
       "      <td>0.351127</td>\n",
       "      <td>0.413800</td>\n",
       "      <td>-0.340982</td>\n",
       "      <td>0.293190</td>\n",
       "      <td>0.548737</td>\n",
       "      <td>78</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>72</td>\n",
       "      <td>13.0</td>\n",
       "      <td>1.526556</td>\n",
       "      <td>1.144256</td>\n",
       "      <td>0.713897</td>\n",
       "      <td>1.339617</td>\n",
       "      <td>-0.625403</td>\n",
       "      <td>72</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>235</td>\n",
       "      <td>30.5</td>\n",
       "      <td>-0.824303</td>\n",
       "      <td>-0.891280</td>\n",
       "      <td>-1.053025</td>\n",
       "      <td>-1.072585</td>\n",
       "      <td>0.475353</td>\n",
       "      <td>77</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>37</td>\n",
       "      <td>14.0</td>\n",
       "      <td>1.526556</td>\n",
       "      <td>1.563051</td>\n",
       "      <td>1.636916</td>\n",
       "      <td>1.470420</td>\n",
       "      <td>-1.359240</td>\n",
       "      <td>71</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      MPG  Cylinders  Displacement  Horsepower    Weight  Acceleration  \\\n",
       "203  28.0  -0.824303     -0.901020   -0.736562 -0.950031      0.255202   \n",
       "255  19.4   0.351127      0.413800   -0.340982  0.293190      0.548737   \n",
       "72   13.0   1.526556      1.144256    0.713897  1.339617     -0.625403   \n",
       "235  30.5  -0.824303     -0.891280   -1.053025 -1.072585      0.475353   \n",
       "37   14.0   1.526556      1.563051    1.636916  1.470420     -1.359240   \n",
       "\n",
       "     ModelYear  Origin  \n",
       "203         76       3  \n",
       "255         78       1  \n",
       "72          72       1  \n",
       "235         77       1  \n",
       "37          71       1  "
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numeric_column_names = ['Cylinders', 'Displacement', 'Horsepower', 'Weight', 'Acceleration']\n",
    "\n",
    "df_train_norm, df_test_norm = df_train.copy(), df_test.copy()\n",
    "\n",
    "for col_name in numeric_column_names:\n",
    "    mean = train_stats.loc[col_name, 'mean']\n",
    "    std  = train_stats.loc[col_name, 'std']\n",
    "    df_train_norm.loc[:, col_name] = (df_train_norm.loc[:, col_name] - mean)/std\n",
    "    df_test_norm.loc[:, col_name] = (df_test_norm.loc[:, col_name] - mean)/std\n",
    "    \n",
    "df_train_norm.tail()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Numeric Columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[NumericColumn(key='Cylinders', shape=(1,), default_value=None, dtype=tf.float32, normalizer_fn=None),\n",
       " NumericColumn(key='Displacement', shape=(1,), default_value=None, dtype=tf.float32, normalizer_fn=None),\n",
       " NumericColumn(key='Horsepower', shape=(1,), default_value=None, dtype=tf.float32, normalizer_fn=None),\n",
       " NumericColumn(key='Weight', shape=(1,), default_value=None, dtype=tf.float32, normalizer_fn=None),\n",
       " NumericColumn(key='Acceleration', shape=(1,), default_value=None, dtype=tf.float32, normalizer_fn=None)]"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "numeric_features = []\n",
    "\n",
    "for col_name in numeric_column_names:\n",
    "    numeric_features.append(tf.feature_column.numeric_column(key=col_name))\n",
    "    \n",
    "numeric_features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[BucketizedColumn(source_column=NumericColumn(key='ModelYear', shape=(1,), default_value=None, dtype=tf.float32, normalizer_fn=None), boundaries=(73, 76, 79))]\n"
     ]
    }
   ],
   "source": [
    "feature_year = tf.feature_column.numeric_column(key=\"ModelYear\")\n",
    "\n",
    "bucketized_features = []\n",
    "\n",
    "bucketized_features.append(tf.feature_column.bucketized_column(\n",
    "    source_column=feature_year,\n",
    "    boundaries=[73, 76, 79]))\n",
    "\n",
    "print(bucketized_features)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[IndicatorColumn(categorical_column=VocabularyListCategoricalColumn(key='Origin', vocabulary_list=(1, 2, 3), dtype=tf.int64, default_value=-1, num_oov_buckets=0))]\n"
     ]
    }
   ],
   "source": [
    "\n",
    "feature_origin = tf.feature_column.categorical_column_with_vocabulary_list(\n",
    "    key='Origin',\n",
    "    vocabulary_list=[1, 2, 3])\n",
    "\n",
    "\n",
    "categorical_indicator_features = []\n",
    "categorical_indicator_features.append(tf.feature_column.indicator_column(feature_origin))\n",
    "\n",
    "print(categorical_indicator_features)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Machine learning with pre-made Estimators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Keys ::  dict_keys(['Cylinders', 'Displacement', 'Horsepower', 'Weight', 'Acceleration', 'ModelYear', 'Origin'])\n",
      "Batch Model Years ::  tf.Tensor([82 78 76 72 78 73 70 78], shape=(8,), dtype=int32)\n"
     ]
    }
   ],
   "source": [
    "def train_input_fn(df_train, batch_size=8):\n",
    "    df = df_train.copy()\n",
    "    train_x, train_y = df, df.pop('MPG')\n",
    "    dataset = tf.data.Dataset.from_tensor_slices((dict(train_x), train_y))\n",
    "\n",
    "    # Shuffle, repeat, and batch the examples.\n",
    "    return dataset.shuffle(1000).repeat().batch(batch_size)\n",
    "\n",
    "## inspection:\n",
    "ds = train_input_fn(df_train_norm)\n",
    "batch = next(iter(ds))\n",
    "print('Keys :: ', batch[0].keys())\n",
    "print('Batch Model Years :: ', batch[0]['ModelYear'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[NumericColumn(key='Cylinders', shape=(1,), default_value=None, dtype=tf.float32, normalizer_fn=None), NumericColumn(key='Displacement', shape=(1,), default_value=None, dtype=tf.float32, normalizer_fn=None), NumericColumn(key='Horsepower', shape=(1,), default_value=None, dtype=tf.float32, normalizer_fn=None), NumericColumn(key='Weight', shape=(1,), default_value=None, dtype=tf.float32, normalizer_fn=None), NumericColumn(key='Acceleration', shape=(1,), default_value=None, dtype=tf.float32, normalizer_fn=None), BucketizedColumn(source_column=NumericColumn(key='ModelYear', shape=(1,), default_value=None, dtype=tf.float32, normalizer_fn=None), boundaries=(73, 76, 79)), IndicatorColumn(categorical_column=VocabularyListCategoricalColumn(key='Origin', vocabulary_list=(1, 2, 3), dtype=tf.int64, default_value=-1, num_oov_buckets=0))]\n"
     ]
    }
   ],
   "source": [
    "all_feature_columns = (numeric_features + \n",
    "                       bucketized_features + \n",
    "                       categorical_indicator_features)\n",
    "\n",
    "print(all_feature_columns)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Using default config.\n",
      "INFO:tensorflow:Using config: {'_model_dir': 'models/autompg-dnnregressor/', '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_steps': None, '_save_checkpoints_secs': 600, '_session_config': allow_soft_placement: true\n",
      "graph_options {\n",
      "  rewrite_options {\n",
      "    meta_optimizer_iterations: ONE\n",
      "  }\n",
      "}\n",
      ", '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 100, '_train_distribute': None, '_device_fn': None, '_protocol': None, '_eval_distribute': None, '_experimental_distribute': None, '_experimental_max_worker_delay_secs': None, '_session_creation_timeout_secs': 7200, '_service': None, '_cluster_spec': <tensorflow.python.training.server_lib.ClusterSpec object at 0x7fea703759d0>, '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1}\n"
     ]
    }
   ],
   "source": [
    "\n",
    "regressor = tf.estimator.DNNRegressor(\n",
    "    feature_columns=all_feature_columns,\n",
    "    hidden_units=[32, 10],\n",
    "    model_dir='models/autompg-dnnregressor/')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training Steps:  40000\n",
      "WARNING:tensorflow:From /home/vahid/anaconda3/envs/tf2/lib/python3.7/site-packages/tensorflow_core/python/ops/resource_variable_ops.py:1630: calling BaseResourceVariable.__init__ (from tensorflow.python.ops.resource_variable_ops) with constraint is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "If using Keras pass *_constraint arguments to layers.\n",
      "WARNING:tensorflow:From /home/vahid/anaconda3/envs/tf2/lib/python3.7/site-packages/tensorflow_core/python/training/training_util.py:236: Variable.initialized_value (from tensorflow.python.ops.variables) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use Variable.read_value. Variables in 2.X are initialized automatically both in eager and graph (inside tf.defun) contexts.\n",
      "INFO:tensorflow:Calling model_fn.\n",
      "WARNING:tensorflow:Layer dnn is casting an input tensor from dtype float64 to the layer's dtype of float32, which is new behavior in TensorFlow 2.  The layer has dtype float32 because it's dtype defaults to floatx.\n",
      "\n",
      "If you intended to run this layer in float32, you can safely ignore this warning. If in doubt, this warning is likely only an issue if you are porting a TensorFlow 1.X model to TensorFlow 2.\n",
      "\n",
      "To change all layers to have dtype float64 by default, call `tf.keras.backend.set_floatx('float64')`. To change just this layer, pass dtype='float64' to the layer constructor. If you are the author of this layer, you can disable autocasting by passing autocast=False to the base Layer constructor.\n",
      "\n",
      "WARNING:tensorflow:From /home/vahid/anaconda3/envs/tf2/lib/python3.7/site-packages/tensorflow_core/python/feature_column/feature_column_v2.py:4276: IndicatorColumn._variable_shape (from tensorflow.python.feature_column.feature_column_v2) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "The old _FeatureColumn APIs are being deprecated. Please use the new FeatureColumn APIs instead.\n",
      "WARNING:tensorflow:From /home/vahid/anaconda3/envs/tf2/lib/python3.7/site-packages/tensorflow_core/python/feature_column/feature_column_v2.py:4331: VocabularyListCategoricalColumn._num_buckets (from tensorflow.python.feature_column.feature_column_v2) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "The old _FeatureColumn APIs are being deprecated. Please use the new FeatureColumn APIs instead.\n",
      "WARNING:tensorflow:From /home/vahid/anaconda3/envs/tf2/lib/python3.7/site-packages/tensorflow_estimator/python/estimator/head/regression_head.py:156: to_float (from tensorflow.python.ops.math_ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use `tf.cast` instead.\n",
      "WARNING:tensorflow:From /home/vahid/anaconda3/envs/tf2/lib/python3.7/site-packages/tensorflow_core/python/keras/optimizer_v2/adagrad.py:108: calling Constant.__init__ (from tensorflow.python.ops.init_ops) with dtype is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Call initializer instance with the dtype argument instead of passing it to the constructor\n",
      "INFO:tensorflow:Done calling model_fn.\n",
      "INFO:tensorflow:Create CheckpointSaverHook.\n",
      "INFO:tensorflow:Graph was finalized.\n",
      "INFO:tensorflow:Running local_init_op.\n",
      "INFO:tensorflow:Done running local_init_op.\n",
      "INFO:tensorflow:Saving checkpoints for 0 into models/autompg-dnnregressor/model.ckpt.\n",
      "INFO:tensorflow:loss = 657.5952, step = 0\n",
      "INFO:tensorflow:global_step/sec: 482.683\n",
      "INFO:tensorflow:loss = 557.6489, step = 100 (0.209 sec)\n",
      "INFO:tensorflow:global_step/sec: 658.251\n",
      "INFO:tensorflow:loss = 484.67407, step = 200 (0.152 sec)\n",
      "INFO:tensorflow:global_step/sec: 640.107\n",
      "INFO:tensorflow:loss = 578.31995, step = 300 (0.156 sec)\n",
      "INFO:tensorflow:global_step/sec: 638.856\n",
      "INFO:tensorflow:loss = 457.42548, step = 400 (0.156 sec)\n",
      "INFO:tensorflow:global_step/sec: 643.696\n",
      "INFO:tensorflow:loss = 368.1149, step = 500 (0.155 sec)\n",
      "INFO:tensorflow:global_step/sec: 648.612\n",
      "INFO:tensorflow:loss = 376.00436, step = 600 (0.155 sec)\n",
      "INFO:tensorflow:global_step/sec: 642.11\n",
      "INFO:tensorflow:loss = 426.9007, step = 700 (0.156 sec)\n",
      "INFO:tensorflow:global_step/sec: 641.277\n",
      "INFO:tensorflow:loss = 460.12323, step = 800 (0.156 sec)\n",
      "INFO:tensorflow:global_step/sec: 638.549\n",
      "INFO:tensorflow:loss = 536.4379, step = 900 (0.157 sec)\n",
      "INFO:tensorflow:global_step/sec: 649.691\n",
      "INFO:tensorflow:loss = 373.92722, step = 1000 (0.154 sec)\n",
      "INFO:tensorflow:global_step/sec: 647.897\n",
      "INFO:tensorflow:loss = 334.62622, step = 1100 (0.154 sec)\n",
      "INFO:tensorflow:global_step/sec: 643.841\n",
      "INFO:tensorflow:loss = 337.9565, step = 1200 (0.155 sec)\n",
      "INFO:tensorflow:global_step/sec: 645.425\n",
      "INFO:tensorflow:loss = 484.2738, step = 1300 (0.155 sec)\n",
      "INFO:tensorflow:global_step/sec: 647.563\n",
      "INFO:tensorflow:loss = 387.98175, step = 1400 (0.154 sec)\n",
      "INFO:tensorflow:global_step/sec: 647.963\n",
      "INFO:tensorflow:loss = 330.1019, step = 1500 (0.154 sec)\n",
      "INFO:tensorflow:global_step/sec: 649.298\n",
      "INFO:tensorflow:loss = 320.49606, step = 1600 (0.154 sec)\n",
      "INFO:tensorflow:global_step/sec: 654.825\n",
      "INFO:tensorflow:loss = 261.08185, step = 1700 (0.153 sec)\n",
      "INFO:tensorflow:global_step/sec: 645.502\n",
      "INFO:tensorflow:loss = 304.45633, step = 1800 (0.155 sec)\n",
      "INFO:tensorflow:global_step/sec: 654.494\n",
      "INFO:tensorflow:loss = 301.4652, step = 1900 (0.153 sec)\n",
      "INFO:tensorflow:global_step/sec: 650.278\n",
      "INFO:tensorflow:loss = 198.7786, step = 2000 (0.154 sec)\n",
      "INFO:tensorflow:global_step/sec: 665.325\n",
      "INFO:tensorflow:loss = 262.18463, step = 2100 (0.150 sec)\n",
      "INFO:tensorflow:global_step/sec: 898.968\n",
      "INFO:tensorflow:loss = 246.47246, step = 2200 (0.111 sec)\n",
      "INFO:tensorflow:global_step/sec: 991.915\n",
      "INFO:tensorflow:loss = 180.72266, step = 2300 (0.101 sec)\n",
      "INFO:tensorflow:global_step/sec: 725.679\n",
      "INFO:tensorflow:loss = 380.47226, step = 2400 (0.138 sec)\n",
      "INFO:tensorflow:global_step/sec: 634.304\n",
      "INFO:tensorflow:loss = 320.3031, step = 2500 (0.158 sec)\n",
      "INFO:tensorflow:global_step/sec: 614.874\n",
      "INFO:tensorflow:loss = 273.86218, step = 2600 (0.163 sec)\n",
      "INFO:tensorflow:global_step/sec: 619.638\n",
      "INFO:tensorflow:loss = 285.63263, step = 2700 (0.161 sec)\n",
      "INFO:tensorflow:global_step/sec: 619.486\n",
      "INFO:tensorflow:loss = 416.43893, step = 2800 (0.161 sec)\n",
      "INFO:tensorflow:global_step/sec: 722.359\n",
      "INFO:tensorflow:loss = 163.24045, step = 2900 (0.138 sec)\n",
      "INFO:tensorflow:global_step/sec: 922.801\n",
      "INFO:tensorflow:loss = 235.00891, step = 3000 (0.108 sec)\n",
      "INFO:tensorflow:global_step/sec: 995.65\n",
      "INFO:tensorflow:loss = 146.46678, step = 3100 (0.100 sec)\n",
      "INFO:tensorflow:global_step/sec: 979.547\n",
      "INFO:tensorflow:loss = 256.28195, step = 3200 (0.102 sec)\n",
      "INFO:tensorflow:global_step/sec: 965.009\n",
      "INFO:tensorflow:loss = 232.42818, step = 3300 (0.104 sec)\n",
      "INFO:tensorflow:global_step/sec: 972.996\n",
      "INFO:tensorflow:loss = 180.57608, step = 3400 (0.103 sec)\n",
      "INFO:tensorflow:global_step/sec: 970.931\n",
      "INFO:tensorflow:loss = 179.35796, step = 3500 (0.103 sec)\n",
      "INFO:tensorflow:global_step/sec: 973.794\n",
      "INFO:tensorflow:loss = 138.38496, step = 3600 (0.103 sec)\n",
      "INFO:tensorflow:global_step/sec: 981.751\n",
      "INFO:tensorflow:loss = 238.2626, step = 3700 (0.102 sec)\n",
      "INFO:tensorflow:global_step/sec: 973.545\n",
      "INFO:tensorflow:loss = 203.41815, step = 3800 (0.103 sec)\n",
      "INFO:tensorflow:global_step/sec: 643.759\n",
      "INFO:tensorflow:loss = 171.89471, step = 3900 (0.156 sec)\n",
      "INFO:tensorflow:global_step/sec: 628.217\n",
      "INFO:tensorflow:loss = 134.16959, step = 4000 (0.159 sec)\n",
      "INFO:tensorflow:global_step/sec: 628.573\n",
      "INFO:tensorflow:loss = 117.263145, step = 4100 (0.159 sec)\n",
      "INFO:tensorflow:global_step/sec: 618.326\n",
      "INFO:tensorflow:loss = 156.63441, step = 4200 (0.162 sec)\n",
      "INFO:tensorflow:global_step/sec: 620.197\n",
      "INFO:tensorflow:loss = 176.01846, step = 4300 (0.161 sec)\n",
      "INFO:tensorflow:global_step/sec: 625.409\n",
      "INFO:tensorflow:loss = 137.88644, step = 4400 (0.160 sec)\n",
      "INFO:tensorflow:global_step/sec: 615.348\n",
      "INFO:tensorflow:loss = 103.77842, step = 4500 (0.162 sec)\n",
      "INFO:tensorflow:global_step/sec: 626.611\n",
      "INFO:tensorflow:loss = 89.257866, step = 4600 (0.160 sec)\n",
      "INFO:tensorflow:global_step/sec: 625.172\n",
      "INFO:tensorflow:loss = 109.813065, step = 4700 (0.160 sec)\n",
      "INFO:tensorflow:global_step/sec: 618.611\n",
      "INFO:tensorflow:loss = 80.15389, step = 4800 (0.162 sec)\n",
      "INFO:tensorflow:global_step/sec: 621.131\n",
      "INFO:tensorflow:loss = 83.17403, step = 4900 (0.161 sec)\n",
      "INFO:tensorflow:global_step/sec: 623.994\n",
      "INFO:tensorflow:loss = 80.266884, step = 5000 (0.160 sec)\n",
      "INFO:tensorflow:global_step/sec: 618.513\n",
      "INFO:tensorflow:loss = 106.402695, step = 5100 (0.162 sec)\n",
      "INFO:tensorflow:global_step/sec: 622.772\n",
      "INFO:tensorflow:loss = 159.29117, step = 5200 (0.161 sec)\n",
      "INFO:tensorflow:global_step/sec: 628.738\n",
      "INFO:tensorflow:loss = 93.6469, step = 5300 (0.159 sec)\n",
      "INFO:tensorflow:global_step/sec: 625.903\n",
      "INFO:tensorflow:loss = 90.42153, step = 5400 (0.160 sec)\n",
      "INFO:tensorflow:global_step/sec: 617.311\n",
      "INFO:tensorflow:loss = 117.86067, step = 5500 (0.162 sec)\n",
      "INFO:tensorflow:global_step/sec: 614.181\n",
      "INFO:tensorflow:loss = 69.909386, step = 5600 (0.163 sec)\n",
      "INFO:tensorflow:global_step/sec: 619.233\n",
      "INFO:tensorflow:loss = 97.84955, step = 5700 (0.162 sec)\n",
      "INFO:tensorflow:global_step/sec: 617.055\n",
      "INFO:tensorflow:loss = 57.248146, step = 5800 (0.162 sec)\n",
      "INFO:tensorflow:global_step/sec: 616.22\n",
      "INFO:tensorflow:loss = 131.23868, step = 5900 (0.162 sec)\n",
      "INFO:tensorflow:global_step/sec: 624.358\n",
      "INFO:tensorflow:loss = 77.497375, step = 6000 (0.160 sec)\n",
      "INFO:tensorflow:global_step/sec: 627.69\n",
      "INFO:tensorflow:loss = 44.59199, step = 6100 (0.159 sec)\n",
      "INFO:tensorflow:global_step/sec: 621.763\n",
      "INFO:tensorflow:loss = 87.97707, step = 6200 (0.161 sec)\n",
      "INFO:tensorflow:global_step/sec: 625.197\n",
      "INFO:tensorflow:loss = 49.96405, step = 6300 (0.160 sec)\n",
      "INFO:tensorflow:global_step/sec: 620.7\n",
      "INFO:tensorflow:loss = 52.705406, step = 6400 (0.161 sec)\n",
      "INFO:tensorflow:global_step/sec: 616.607\n",
      "INFO:tensorflow:loss = 71.76206, step = 6500 (0.162 sec)\n",
      "INFO:tensorflow:global_step/sec: 622.576\n",
      "INFO:tensorflow:loss = 34.005905, step = 6600 (0.161 sec)\n",
      "INFO:tensorflow:global_step/sec: 623.471\n",
      "INFO:tensorflow:loss = 51.795105, step = 6700 (0.160 sec)\n",
      "INFO:tensorflow:global_step/sec: 621.201\n",
      "INFO:tensorflow:loss = 24.481604, step = 6800 (0.161 sec)\n",
      "INFO:tensorflow:global_step/sec: 623.32\n",
      "INFO:tensorflow:loss = 57.33905, step = 6900 (0.160 sec)\n",
      "INFO:tensorflow:global_step/sec: 619.291\n",
      "INFO:tensorflow:loss = 53.956146, step = 7000 (0.161 sec)\n",
      "INFO:tensorflow:global_step/sec: 621.409\n",
      "INFO:tensorflow:loss = 66.21356, step = 7100 (0.161 sec)\n",
      "INFO:tensorflow:global_step/sec: 623.781\n",
      "INFO:tensorflow:loss = 42.552338, step = 7200 (0.160 sec)\n",
      "INFO:tensorflow:global_step/sec: 628.149\n",
      "INFO:tensorflow:loss = 60.83576, step = 7300 (0.159 sec)\n",
      "INFO:tensorflow:global_step/sec: 621.733\n",
      "INFO:tensorflow:loss = 47.406822, step = 7400 (0.161 sec)\n",
      "INFO:tensorflow:global_step/sec: 624.65\n",
      "INFO:tensorflow:loss = 102.1715, step = 7500 (0.160 sec)\n",
      "INFO:tensorflow:global_step/sec: 623.111\n",
      "INFO:tensorflow:loss = 55.28649, step = 7600 (0.160 sec)\n",
      "INFO:tensorflow:global_step/sec: 621.739\n",
      "INFO:tensorflow:loss = 35.528416, step = 7700 (0.161 sec)\n",
      "INFO:tensorflow:global_step/sec: 619.409\n",
      "INFO:tensorflow:loss = 28.756922, step = 7800 (0.161 sec)\n",
      "INFO:tensorflow:global_step/sec: 619.223\n",
      "INFO:tensorflow:loss = 26.715008, step = 7900 (0.161 sec)\n",
      "INFO:tensorflow:global_step/sec: 624.634\n",
      "INFO:tensorflow:loss = 48.81586, step = 8000 (0.160 sec)\n",
      "INFO:tensorflow:global_step/sec: 622.308\n",
      "INFO:tensorflow:loss = 59.67297, step = 8100 (0.161 sec)\n",
      "INFO:tensorflow:global_step/sec: 621.701\n",
      "INFO:tensorflow:loss = 22.939081, step = 8200 (0.161 sec)\n",
      "INFO:tensorflow:global_step/sec: 630.179\n",
      "INFO:tensorflow:loss = 40.912636, step = 8300 (0.159 sec)\n",
      "INFO:tensorflow:global_step/sec: 619.781\n",
      "INFO:tensorflow:loss = 68.91703, step = 8400 (0.161 sec)\n",
      "INFO:tensorflow:global_step/sec: 627.098\n",
      "INFO:tensorflow:loss = 38.17033, step = 8500 (0.159 sec)\n",
      "INFO:tensorflow:global_step/sec: 626.28\n",
      "INFO:tensorflow:loss = 24.129894, step = 8600 (0.159 sec)\n",
      "INFO:tensorflow:global_step/sec: 621.645\n",
      "INFO:tensorflow:loss = 26.56329, step = 8700 (0.161 sec)\n",
      "INFO:tensorflow:global_step/sec: 631.187\n",
      "INFO:tensorflow:loss = 36.76889, step = 8800 (0.158 sec)\n",
      "INFO:tensorflow:global_step/sec: 622.526\n",
      "INFO:tensorflow:loss = 11.12675, step = 8900 (0.161 sec)\n",
      "INFO:tensorflow:global_step/sec: 622.975\n",
      "INFO:tensorflow:loss = 33.61374, step = 9000 (0.161 sec)\n",
      "INFO:tensorflow:global_step/sec: 616.611\n",
      "INFO:tensorflow:loss = 40.575306, step = 9100 (0.162 sec)\n",
      "INFO:tensorflow:global_step/sec: 615.565\n",
      "INFO:tensorflow:loss = 28.530561, step = 9200 (0.162 sec)\n",
      "INFO:tensorflow:global_step/sec: 616.044\n",
      "INFO:tensorflow:loss = 18.963575, step = 9300 (0.162 sec)\n",
      "INFO:tensorflow:global_step/sec: 626.178\n",
      "INFO:tensorflow:loss = 29.736134, step = 9400 (0.160 sec)\n",
      "INFO:tensorflow:global_step/sec: 618.863\n",
      "INFO:tensorflow:loss = 19.305485, step = 9500 (0.162 sec)\n",
      "INFO:tensorflow:global_step/sec: 625.883\n",
      "INFO:tensorflow:loss = 39.44049, step = 9600 (0.160 sec)\n",
      "INFO:tensorflow:global_step/sec: 624.775\n",
      "INFO:tensorflow:loss = 9.117452, step = 9700 (0.160 sec)\n",
      "INFO:tensorflow:global_step/sec: 627.555\n",
      "INFO:tensorflow:loss = 39.3379, step = 9800 (0.159 sec)\n",
      "INFO:tensorflow:global_step/sec: 623.687\n",
      "INFO:tensorflow:loss = 30.72681, step = 9900 (0.160 sec)\n",
      "INFO:tensorflow:global_step/sec: 623.212\n",
      "INFO:tensorflow:loss = 41.16591, step = 10000 (0.160 sec)\n",
      "INFO:tensorflow:global_step/sec: 573.764\n",
      "INFO:tensorflow:loss = 28.702877, step = 10100 (0.174 sec)\n",
      "INFO:tensorflow:global_step/sec: 602.922\n",
      "INFO:tensorflow:loss = 76.39154, step = 10200 (0.166 sec)\n",
      "INFO:tensorflow:global_step/sec: 605.797\n",
      "INFO:tensorflow:loss = 26.063759, step = 10300 (0.165 sec)\n",
      "INFO:tensorflow:global_step/sec: 610.422\n",
      "INFO:tensorflow:loss = 9.598902, step = 10400 (0.164 sec)\n",
      "INFO:tensorflow:global_step/sec: 604.798\n",
      "INFO:tensorflow:loss = 93.17958, step = 10500 (0.165 sec)\n",
      "INFO:tensorflow:global_step/sec: 599.286\n",
      "INFO:tensorflow:loss = 48.746246, step = 10600 (0.167 sec)\n",
      "INFO:tensorflow:global_step/sec: 607.786\n",
      "INFO:tensorflow:loss = 40.0269, step = 10700 (0.164 sec)\n",
      "INFO:tensorflow:global_step/sec: 604.492\n",
      "INFO:tensorflow:loss = 33.373196, step = 10800 (0.165 sec)\n",
      "INFO:tensorflow:global_step/sec: 602.762\n",
      "INFO:tensorflow:loss = 38.592262, step = 10900 (0.166 sec)\n",
      "INFO:tensorflow:global_step/sec: 609.195\n",
      "INFO:tensorflow:loss = 14.427067, step = 11000 (0.164 sec)\n",
      "INFO:tensorflow:global_step/sec: 606.696\n",
      "INFO:tensorflow:loss = 10.515163, step = 11100 (0.165 sec)\n",
      "INFO:tensorflow:global_step/sec: 605.022\n",
      "INFO:tensorflow:loss = 26.500973, step = 11200 (0.165 sec)\n",
      "INFO:tensorflow:global_step/sec: 609.582\n",
      "INFO:tensorflow:loss = 9.660977, step = 11300 (0.164 sec)\n",
      "INFO:tensorflow:global_step/sec: 605.105\n",
      "INFO:tensorflow:loss = 44.603836, step = 11400 (0.165 sec)\n",
      "INFO:tensorflow:global_step/sec: 600.799\n",
      "INFO:tensorflow:loss = 18.39376, step = 11500 (0.166 sec)\n",
      "INFO:tensorflow:global_step/sec: 601.462\n",
      "INFO:tensorflow:loss = 38.262527, step = 11600 (0.166 sec)\n",
      "INFO:tensorflow:global_step/sec: 609.453\n",
      "INFO:tensorflow:loss = 26.374014, step = 11700 (0.164 sec)\n",
      "INFO:tensorflow:global_step/sec: 611.235\n",
      "INFO:tensorflow:loss = 39.07757, step = 11800 (0.164 sec)\n",
      "INFO:tensorflow:global_step/sec: 602.921\n",
      "INFO:tensorflow:loss = 41.0062, step = 11900 (0.166 sec)\n",
      "INFO:tensorflow:global_step/sec: 602.694\n",
      "INFO:tensorflow:loss = 11.513717, step = 12000 (0.166 sec)\n",
      "INFO:tensorflow:global_step/sec: 608.999\n",
      "INFO:tensorflow:loss = 32.633133, step = 12100 (0.164 sec)\n",
      "INFO:tensorflow:global_step/sec: 595.658\n",
      "INFO:tensorflow:loss = 27.65621, step = 12200 (0.168 sec)\n",
      "INFO:tensorflow:global_step/sec: 609\n",
      "INFO:tensorflow:loss = 80.21222, step = 12300 (0.164 sec)\n",
      "INFO:tensorflow:global_step/sec: 608.706\n",
      "INFO:tensorflow:loss = 38.21443, step = 12400 (0.164 sec)\n",
      "INFO:tensorflow:global_step/sec: 606.311\n",
      "INFO:tensorflow:loss = 35.619156, step = 12500 (0.165 sec)\n",
      "INFO:tensorflow:global_step/sec: 608.527\n",
      "INFO:tensorflow:loss = 10.762424, step = 12600 (0.164 sec)\n",
      "INFO:tensorflow:global_step/sec: 596.98\n",
      "INFO:tensorflow:loss = 11.522208, step = 12700 (0.167 sec)\n",
      "INFO:tensorflow:global_step/sec: 603.401\n",
      "INFO:tensorflow:loss = 5.938079, step = 12800 (0.166 sec)\n",
      "INFO:tensorflow:global_step/sec: 607.507\n",
      "INFO:tensorflow:loss = 18.7967, step = 12900 (0.165 sec)\n",
      "INFO:tensorflow:global_step/sec: 606.794\n",
      "INFO:tensorflow:loss = 20.214, step = 13000 (0.165 sec)\n",
      "INFO:tensorflow:global_step/sec: 609.062\n",
      "INFO:tensorflow:loss = 33.071213, step = 13100 (0.164 sec)\n",
      "INFO:tensorflow:global_step/sec: 605.735\n",
      "INFO:tensorflow:loss = 31.293764, step = 13200 (0.165 sec)\n",
      "INFO:tensorflow:global_step/sec: 607.502\n",
      "INFO:tensorflow:loss = 12.629317, step = 13300 (0.165 sec)\n",
      "INFO:tensorflow:global_step/sec: 608.678\n",
      "INFO:tensorflow:loss = 14.218715, step = 13400 (0.164 sec)\n",
      "INFO:tensorflow:global_step/sec: 607.488\n",
      "INFO:tensorflow:loss = 26.199917, step = 13500 (0.165 sec)\n",
      "INFO:tensorflow:global_step/sec: 604.629\n",
      "INFO:tensorflow:loss = 5.435256, step = 13600 (0.165 sec)\n",
      "INFO:tensorflow:global_step/sec: 610.282\n",
      "INFO:tensorflow:loss = 16.59472, step = 13700 (0.164 sec)\n",
      "INFO:tensorflow:global_step/sec: 616.118\n",
      "INFO:tensorflow:loss = 16.815441, step = 13800 (0.162 sec)\n",
      "INFO:tensorflow:global_step/sec: 605.576\n",
      "INFO:tensorflow:loss = 18.003456, step = 13900 (0.165 sec)\n",
      "INFO:tensorflow:global_step/sec: 605.57\n",
      "INFO:tensorflow:loss = 9.101876, step = 14000 (0.165 sec)\n",
      "INFO:tensorflow:global_step/sec: 600.381\n",
      "INFO:tensorflow:loss = 16.405924, step = 14100 (0.167 sec)\n",
      "INFO:tensorflow:global_step/sec: 601.84\n",
      "INFO:tensorflow:loss = 11.358658, step = 14200 (0.166 sec)\n",
      "INFO:tensorflow:global_step/sec: 607.085\n",
      "INFO:tensorflow:loss = 15.51166, step = 14300 (0.165 sec)\n",
      "INFO:tensorflow:global_step/sec: 607.916\n",
      "INFO:tensorflow:loss = 27.684124, step = 14400 (0.164 sec)\n",
      "INFO:tensorflow:global_step/sec: 587.864\n",
      "INFO:tensorflow:loss = 13.142756, step = 14500 (0.170 sec)\n",
      "INFO:tensorflow:global_step/sec: 601.048\n",
      "INFO:tensorflow:loss = 24.95385, step = 14600 (0.167 sec)\n",
      "INFO:tensorflow:global_step/sec: 608.581\n",
      "INFO:tensorflow:loss = 15.6557865, step = 14700 (0.164 sec)\n",
      "INFO:tensorflow:global_step/sec: 611.622\n",
      "INFO:tensorflow:loss = 10.379879, step = 14800 (0.164 sec)\n",
      "INFO:tensorflow:global_step/sec: 610.372\n",
      "INFO:tensorflow:loss = 7.709038, step = 14900 (0.164 sec)\n",
      "INFO:tensorflow:global_step/sec: 616.309\n",
      "INFO:tensorflow:loss = 23.517546, step = 15000 (0.162 sec)\n",
      "INFO:tensorflow:global_step/sec: 604.346\n",
      "INFO:tensorflow:loss = 40.877735, step = 15100 (0.165 sec)\n",
      "INFO:tensorflow:global_step/sec: 615.822\n",
      "INFO:tensorflow:loss = 11.076447, step = 15200 (0.162 sec)\n",
      "INFO:tensorflow:global_step/sec: 610.551\n",
      "INFO:tensorflow:loss = 16.282972, step = 15300 (0.164 sec)\n",
      "INFO:tensorflow:global_step/sec: 607.242\n",
      "INFO:tensorflow:loss = 6.8650227, step = 15400 (0.165 sec)\n",
      "INFO:tensorflow:global_step/sec: 674.284\n",
      "INFO:tensorflow:loss = 17.083073, step = 15500 (0.148 sec)\n",
      "INFO:tensorflow:global_step/sec: 739.228\n",
      "INFO:tensorflow:loss = 15.280033, step = 15600 (0.135 sec)\n",
      "INFO:tensorflow:global_step/sec: 762.612\n",
      "INFO:tensorflow:loss = 8.369352, step = 15700 (0.131 sec)\n",
      "INFO:tensorflow:global_step/sec: 744.624\n",
      "INFO:tensorflow:loss = 8.618115, step = 15800 (0.134 sec)\n",
      "INFO:tensorflow:global_step/sec: 754.731\n",
      "INFO:tensorflow:loss = 10.968094, step = 15900 (0.132 sec)\n",
      "INFO:tensorflow:global_step/sec: 749.999\n",
      "INFO:tensorflow:loss = 19.594482, step = 16000 (0.133 sec)\n",
      "INFO:tensorflow:global_step/sec: 746.238\n",
      "INFO:tensorflow:loss = 47.87027, step = 16100 (0.134 sec)\n",
      "INFO:tensorflow:global_step/sec: 764.314\n",
      "INFO:tensorflow:loss = 49.53106, step = 16200 (0.131 sec)\n",
      "INFO:tensorflow:global_step/sec: 756.615\n",
      "INFO:tensorflow:loss = 18.40356, step = 16300 (0.132 sec)\n",
      "INFO:tensorflow:global_step/sec: 772.288\n",
      "INFO:tensorflow:loss = 19.90119, step = 16400 (0.130 sec)\n",
      "INFO:tensorflow:global_step/sec: 757.055\n",
      "INFO:tensorflow:loss = 17.226856, step = 16500 (0.132 sec)\n",
      "INFO:tensorflow:global_step/sec: 697.754\n",
      "INFO:tensorflow:loss = 8.586212, step = 16600 (0.143 sec)\n",
      "INFO:tensorflow:global_step/sec: 606.509\n",
      "INFO:tensorflow:loss = 18.545927, step = 16700 (0.165 sec)\n",
      "INFO:tensorflow:global_step/sec: 612.569\n",
      "INFO:tensorflow:loss = 23.221504, step = 16800 (0.163 sec)\n",
      "INFO:tensorflow:global_step/sec: 606.226\n",
      "INFO:tensorflow:loss = 8.447188, step = 16900 (0.165 sec)\n",
      "INFO:tensorflow:global_step/sec: 610.809\n",
      "INFO:tensorflow:loss = 13.326759, step = 17000 (0.164 sec)\n",
      "INFO:tensorflow:global_step/sec: 605.898\n",
      "INFO:tensorflow:loss = 11.969912, step = 17100 (0.165 sec)\n",
      "INFO:tensorflow:global_step/sec: 603.404\n",
      "INFO:tensorflow:loss = 18.360952, step = 17200 (0.166 sec)\n",
      "INFO:tensorflow:global_step/sec: 604.536\n",
      "INFO:tensorflow:loss = 11.262244, step = 17300 (0.165 sec)\n",
      "INFO:tensorflow:global_step/sec: 607.551\n",
      "INFO:tensorflow:loss = 32.929844, step = 17400 (0.165 sec)\n",
      "INFO:tensorflow:global_step/sec: 609.551\n",
      "INFO:tensorflow:loss = 20.396812, step = 17500 (0.164 sec)\n",
      "INFO:tensorflow:global_step/sec: 605.031\n",
      "INFO:tensorflow:loss = 12.920612, step = 17600 (0.165 sec)\n",
      "INFO:tensorflow:global_step/sec: 611.482\n",
      "INFO:tensorflow:loss = 9.952381, step = 17700 (0.164 sec)\n",
      "INFO:tensorflow:global_step/sec: 613.001\n",
      "INFO:tensorflow:loss = 28.488035, step = 17800 (0.163 sec)\n",
      "INFO:tensorflow:global_step/sec: 611.831\n",
      "INFO:tensorflow:loss = 27.86641, step = 17900 (0.163 sec)\n",
      "INFO:tensorflow:global_step/sec: 616.497\n",
      "INFO:tensorflow:loss = 17.584126, step = 18000 (0.162 sec)\n",
      "INFO:tensorflow:global_step/sec: 613.092\n",
      "INFO:tensorflow:loss = 8.948881, step = 18100 (0.163 sec)\n",
      "INFO:tensorflow:global_step/sec: 614.748\n",
      "INFO:tensorflow:loss = 5.8416195, step = 18200 (0.163 sec)\n",
      "INFO:tensorflow:global_step/sec: 610.935\n",
      "INFO:tensorflow:loss = 13.873205, step = 18300 (0.164 sec)\n",
      "INFO:tensorflow:global_step/sec: 615.909\n",
      "INFO:tensorflow:loss = 20.545958, step = 18400 (0.162 sec)\n",
      "INFO:tensorflow:global_step/sec: 756.712\n",
      "INFO:tensorflow:loss = 2.066881, step = 18500 (0.132 sec)\n",
      "INFO:tensorflow:global_step/sec: 781.41\n",
      "INFO:tensorflow:loss = 16.299616, step = 18600 (0.128 sec)\n",
      "INFO:tensorflow:global_step/sec: 772.12\n",
      "INFO:tensorflow:loss = 4.5948644, step = 18700 (0.130 sec)\n",
      "INFO:tensorflow:global_step/sec: 770.107\n",
      "INFO:tensorflow:loss = 11.63568, step = 18800 (0.130 sec)\n",
      "INFO:tensorflow:global_step/sec: 774.62\n",
      "INFO:tensorflow:loss = 12.472652, step = 18900 (0.129 sec)\n",
      "INFO:tensorflow:global_step/sec: 768.344\n",
      "INFO:tensorflow:loss = 8.941952, step = 19000 (0.130 sec)\n",
      "INFO:tensorflow:global_step/sec: 626.681\n",
      "INFO:tensorflow:loss = 5.836118, step = 19100 (0.160 sec)\n",
      "INFO:tensorflow:global_step/sec: 605.548\n",
      "INFO:tensorflow:loss = 21.993288, step = 19200 (0.165 sec)\n",
      "INFO:tensorflow:global_step/sec: 611.955\n",
      "INFO:tensorflow:loss = 19.100883, step = 19300 (0.163 sec)\n",
      "INFO:tensorflow:global_step/sec: 614.95\n",
      "INFO:tensorflow:loss = 34.08346, step = 19400 (0.163 sec)\n",
      "INFO:tensorflow:global_step/sec: 608.846\n",
      "INFO:tensorflow:loss = 11.387133, step = 19500 (0.164 sec)\n",
      "INFO:tensorflow:global_step/sec: 611.662\n",
      "INFO:tensorflow:loss = 9.136641, step = 19600 (0.164 sec)\n",
      "INFO:tensorflow:global_step/sec: 610.799\n",
      "INFO:tensorflow:loss = 15.39927, step = 19700 (0.164 sec)\n",
      "INFO:tensorflow:global_step/sec: 609.212\n",
      "INFO:tensorflow:loss = 12.568081, step = 19800 (0.164 sec)\n",
      "INFO:tensorflow:global_step/sec: 611.52\n",
      "INFO:tensorflow:loss = 21.756775, step = 19900 (0.164 sec)\n",
      "INFO:tensorflow:global_step/sec: 610.826\n",
      "INFO:tensorflow:loss = 14.076336, step = 20000 (0.164 sec)\n",
      "INFO:tensorflow:global_step/sec: 611.464\n",
      "INFO:tensorflow:loss = 16.634796, step = 20100 (0.164 sec)\n",
      "INFO:tensorflow:global_step/sec: 614.801\n",
      "INFO:tensorflow:loss = 10.392862, step = 20200 (0.163 sec)\n",
      "INFO:tensorflow:global_step/sec: 610.627\n",
      "INFO:tensorflow:loss = 31.27934, step = 20300 (0.164 sec)\n",
      "INFO:tensorflow:global_step/sec: 604.712\n",
      "INFO:tensorflow:loss = 40.382988, step = 20400 (0.165 sec)\n",
      "INFO:tensorflow:global_step/sec: 612.132\n",
      "INFO:tensorflow:loss = 8.734255, step = 20500 (0.163 sec)\n",
      "INFO:tensorflow:global_step/sec: 609.701\n",
      "INFO:tensorflow:loss = 27.545942, step = 20600 (0.164 sec)\n",
      "INFO:tensorflow:global_step/sec: 615.364\n",
      "INFO:tensorflow:loss = 8.844204, step = 20700 (0.163 sec)\n",
      "INFO:tensorflow:global_step/sec: 612.615\n",
      "INFO:tensorflow:loss = 26.93731, step = 20800 (0.163 sec)\n",
      "INFO:tensorflow:global_step/sec: 609.244\n",
      "INFO:tensorflow:loss = 19.305067, step = 20900 (0.164 sec)\n",
      "INFO:tensorflow:global_step/sec: 558.601\n",
      "INFO:tensorflow:loss = 10.0130205, step = 21000 (0.179 sec)\n",
      "INFO:tensorflow:global_step/sec: 605.761\n",
      "INFO:tensorflow:loss = 11.569003, step = 21100 (0.165 sec)\n",
      "INFO:tensorflow:global_step/sec: 604.735\n",
      "INFO:tensorflow:loss = 34.495773, step = 21200 (0.165 sec)\n",
      "INFO:tensorflow:global_step/sec: 602.215\n",
      "INFO:tensorflow:loss = 13.63604, step = 21300 (0.166 sec)\n",
      "INFO:tensorflow:global_step/sec: 616.56\n",
      "INFO:tensorflow:loss = 26.493355, step = 21400 (0.162 sec)\n",
      "INFO:tensorflow:global_step/sec: 601.674\n",
      "INFO:tensorflow:loss = 12.689213, step = 21500 (0.166 sec)\n",
      "INFO:tensorflow:global_step/sec: 603.798\n",
      "INFO:tensorflow:loss = 10.207602, step = 21600 (0.166 sec)\n",
      "INFO:tensorflow:global_step/sec: 599.011\n",
      "INFO:tensorflow:loss = 16.83073, step = 21700 (0.167 sec)\n",
      "INFO:tensorflow:global_step/sec: 608.903\n",
      "INFO:tensorflow:loss = 10.836359, step = 21800 (0.164 sec)\n",
      "INFO:tensorflow:global_step/sec: 606.629\n",
      "INFO:tensorflow:loss = 34.256092, step = 21900 (0.165 sec)\n",
      "INFO:tensorflow:global_step/sec: 604.292\n",
      "INFO:tensorflow:loss = 15.966996, step = 22000 (0.165 sec)\n",
      "INFO:tensorflow:global_step/sec: 607.63\n",
      "INFO:tensorflow:loss = 15.95005, step = 22100 (0.164 sec)\n",
      "INFO:tensorflow:global_step/sec: 604.487\n",
      "INFO:tensorflow:loss = 5.6824765, step = 22200 (0.166 sec)\n",
      "INFO:tensorflow:global_step/sec: 603.422\n",
      "INFO:tensorflow:loss = 10.286382, step = 22300 (0.166 sec)\n",
      "INFO:tensorflow:global_step/sec: 603.339\n",
      "INFO:tensorflow:loss = 28.465061, step = 22400 (0.166 sec)\n",
      "INFO:tensorflow:global_step/sec: 607.018\n",
      "INFO:tensorflow:loss = 2.88454, step = 22500 (0.165 sec)\n",
      "INFO:tensorflow:global_step/sec: 598.424\n",
      "INFO:tensorflow:loss = 27.438784, step = 22600 (0.167 sec)\n",
      "INFO:tensorflow:global_step/sec: 608.424\n",
      "INFO:tensorflow:loss = 5.9430523, step = 22700 (0.164 sec)\n",
      "INFO:tensorflow:global_step/sec: 606.829\n",
      "INFO:tensorflow:loss = 13.255681, step = 22800 (0.165 sec)\n",
      "INFO:tensorflow:global_step/sec: 607.999\n",
      "INFO:tensorflow:loss = 11.189652, step = 22900 (0.164 sec)\n",
      "INFO:tensorflow:global_step/sec: 601.59\n",
      "INFO:tensorflow:loss = 19.604465, step = 23000 (0.166 sec)\n",
      "INFO:tensorflow:global_step/sec: 608.021\n",
      "INFO:tensorflow:loss = 3.9995828, step = 23100 (0.165 sec)\n",
      "INFO:tensorflow:global_step/sec: 601.434\n",
      "INFO:tensorflow:loss = 21.67474, step = 23200 (0.166 sec)\n",
      "INFO:tensorflow:global_step/sec: 613.374\n",
      "INFO:tensorflow:loss = 9.510488, step = 23300 (0.163 sec)\n",
      "INFO:tensorflow:global_step/sec: 616.818\n",
      "INFO:tensorflow:loss = 38.460045, step = 23400 (0.162 sec)\n",
      "INFO:tensorflow:global_step/sec: 602.982\n",
      "INFO:tensorflow:loss = 23.460163, step = 23500 (0.166 sec)\n",
      "INFO:tensorflow:global_step/sec: 609.268\n",
      "INFO:tensorflow:loss = 17.171442, step = 23600 (0.164 sec)\n",
      "INFO:tensorflow:global_step/sec: 610.147\n",
      "INFO:tensorflow:loss = 14.378641, step = 23700 (0.164 sec)\n",
      "INFO:tensorflow:global_step/sec: 603.86\n",
      "INFO:tensorflow:loss = 14.936234, step = 23800 (0.166 sec)\n",
      "INFO:tensorflow:global_step/sec: 611.93\n",
      "INFO:tensorflow:loss = 14.854445, step = 23900 (0.163 sec)\n",
      "INFO:tensorflow:global_step/sec: 618.821\n",
      "INFO:tensorflow:loss = 22.6666, step = 24000 (0.161 sec)\n",
      "INFO:tensorflow:global_step/sec: 620.802\n",
      "INFO:tensorflow:loss = 8.079822, step = 24100 (0.161 sec)\n",
      "INFO:tensorflow:global_step/sec: 553.731\n",
      "INFO:tensorflow:loss = 15.68051, step = 24200 (0.181 sec)\n",
      "INFO:tensorflow:global_step/sec: 552.014\n",
      "INFO:tensorflow:loss = 49.282066, step = 24300 (0.181 sec)\n",
      "INFO:tensorflow:global_step/sec: 608.417\n",
      "INFO:tensorflow:loss = 16.399416, step = 24400 (0.164 sec)\n",
      "INFO:tensorflow:global_step/sec: 614.481\n",
      "INFO:tensorflow:loss = 22.882565, step = 24500 (0.163 sec)\n",
      "INFO:tensorflow:global_step/sec: 609.287\n",
      "INFO:tensorflow:loss = 36.95665, step = 24600 (0.164 sec)\n",
      "INFO:tensorflow:global_step/sec: 612.596\n",
      "INFO:tensorflow:loss = 13.419166, step = 24700 (0.163 sec)\n",
      "INFO:tensorflow:global_step/sec: 614.013\n",
      "INFO:tensorflow:loss = 10.809979, step = 24800 (0.163 sec)\n",
      "INFO:tensorflow:global_step/sec: 600.459\n",
      "INFO:tensorflow:loss = 2.9137425, step = 24900 (0.167 sec)\n",
      "INFO:tensorflow:global_step/sec: 685.728\n",
      "INFO:tensorflow:loss = 25.615978, step = 25000 (0.146 sec)\n",
      "INFO:tensorflow:global_step/sec: 744.237\n",
      "INFO:tensorflow:loss = 10.670422, step = 25100 (0.134 sec)\n",
      "INFO:tensorflow:global_step/sec: 757.144\n",
      "INFO:tensorflow:loss = 11.097601, step = 25200 (0.132 sec)\n",
      "INFO:tensorflow:global_step/sec: 732.711\n",
      "INFO:tensorflow:loss = 25.267418, step = 25300 (0.136 sec)\n",
      "INFO:tensorflow:global_step/sec: 774.527\n",
      "INFO:tensorflow:loss = 8.309276, step = 25400 (0.129 sec)\n",
      "INFO:tensorflow:global_step/sec: 753.369\n",
      "INFO:tensorflow:loss = 6.0909967, step = 25500 (0.133 sec)\n",
      "INFO:tensorflow:global_step/sec: 745.901\n",
      "INFO:tensorflow:loss = 25.735033, step = 25600 (0.134 sec)\n",
      "INFO:tensorflow:global_step/sec: 760.032\n",
      "INFO:tensorflow:loss = 7.798992, step = 25700 (0.132 sec)\n",
      "INFO:tensorflow:global_step/sec: 763.56\n",
      "INFO:tensorflow:loss = 7.57805, step = 25800 (0.131 sec)\n",
      "INFO:tensorflow:global_step/sec: 733.36\n",
      "INFO:tensorflow:loss = 6.260689, step = 25900 (0.137 sec)\n",
      "INFO:tensorflow:global_step/sec: 740.984\n",
      "INFO:tensorflow:loss = 11.36092, step = 26000 (0.135 sec)\n",
      "INFO:tensorflow:global_step/sec: 752.378\n",
      "INFO:tensorflow:loss = 6.9703417, step = 26100 (0.133 sec)\n",
      "INFO:tensorflow:global_step/sec: 759.179\n",
      "INFO:tensorflow:loss = 9.569019, step = 26200 (0.132 sec)\n",
      "INFO:tensorflow:global_step/sec: 745.488\n",
      "INFO:tensorflow:loss = 18.731903, step = 26300 (0.134 sec)\n",
      "INFO:tensorflow:global_step/sec: 736.009\n",
      "INFO:tensorflow:loss = 14.059604, step = 26400 (0.136 sec)\n",
      "INFO:tensorflow:global_step/sec: 733.205\n",
      "INFO:tensorflow:loss = 19.93857, step = 26500 (0.136 sec)\n",
      "INFO:tensorflow:global_step/sec: 748.705\n",
      "INFO:tensorflow:loss = 17.956787, step = 26600 (0.134 sec)\n",
      "INFO:tensorflow:global_step/sec: 729.537\n",
      "INFO:tensorflow:loss = 3.5695877, step = 26700 (0.137 sec)\n",
      "INFO:tensorflow:global_step/sec: 750.863\n",
      "INFO:tensorflow:loss = 10.5764885, step = 26800 (0.133 sec)\n",
      "INFO:tensorflow:global_step/sec: 741.196\n",
      "INFO:tensorflow:loss = 14.619806, step = 26900 (0.135 sec)\n",
      "INFO:tensorflow:global_step/sec: 649.018\n",
      "INFO:tensorflow:loss = 13.653896, step = 27000 (0.154 sec)\n",
      "INFO:tensorflow:global_step/sec: 610.383\n",
      "INFO:tensorflow:loss = 8.245964, step = 27100 (0.164 sec)\n",
      "INFO:tensorflow:global_step/sec: 606.626\n",
      "INFO:tensorflow:loss = 20.350132, step = 27200 (0.165 sec)\n",
      "INFO:tensorflow:global_step/sec: 603.537\n",
      "INFO:tensorflow:loss = 8.16834, step = 27300 (0.166 sec)\n",
      "INFO:tensorflow:global_step/sec: 599.621\n",
      "INFO:tensorflow:loss = 8.52783, step = 27400 (0.167 sec)\n",
      "INFO:tensorflow:global_step/sec: 600.211\n",
      "INFO:tensorflow:loss = 8.029388, step = 27500 (0.167 sec)\n",
      "INFO:tensorflow:global_step/sec: 601.51\n",
      "INFO:tensorflow:loss = 17.739235, step = 27600 (0.166 sec)\n",
      "INFO:tensorflow:global_step/sec: 613.108\n",
      "INFO:tensorflow:loss = 6.0851307, step = 27700 (0.163 sec)\n",
      "INFO:tensorflow:global_step/sec: 605.336\n",
      "INFO:tensorflow:loss = 13.124583, step = 27800 (0.165 sec)\n",
      "INFO:tensorflow:global_step/sec: 606.811\n",
      "INFO:tensorflow:loss = 8.335943, step = 27900 (0.165 sec)\n",
      "INFO:tensorflow:global_step/sec: 607.242\n",
      "INFO:tensorflow:loss = 10.207844, step = 28000 (0.165 sec)\n",
      "INFO:tensorflow:global_step/sec: 608.625\n",
      "INFO:tensorflow:loss = 11.327834, step = 28100 (0.164 sec)\n",
      "INFO:tensorflow:global_step/sec: 608.721\n",
      "INFO:tensorflow:loss = 19.798035, step = 28200 (0.164 sec)\n",
      "INFO:tensorflow:global_step/sec: 603.486\n",
      "INFO:tensorflow:loss = 18.708885, step = 28300 (0.166 sec)\n",
      "INFO:tensorflow:global_step/sec: 614.562\n",
      "INFO:tensorflow:loss = 7.7426343, step = 28400 (0.163 sec)\n",
      "INFO:tensorflow:global_step/sec: 605.068\n",
      "INFO:tensorflow:loss = 19.358358, step = 28500 (0.165 sec)\n",
      "INFO:tensorflow:global_step/sec: 608.208\n",
      "INFO:tensorflow:loss = 18.976181, step = 28600 (0.164 sec)\n",
      "INFO:tensorflow:global_step/sec: 608.223\n",
      "INFO:tensorflow:loss = 7.950467, step = 28700 (0.165 sec)\n",
      "INFO:tensorflow:global_step/sec: 613.428\n",
      "INFO:tensorflow:loss = 26.61744, step = 28800 (0.163 sec)\n",
      "INFO:tensorflow:global_step/sec: 605.761\n",
      "INFO:tensorflow:loss = 6.503431, step = 28900 (0.165 sec)\n",
      "INFO:tensorflow:global_step/sec: 608.031\n",
      "INFO:tensorflow:loss = 11.75782, step = 29000 (0.164 sec)\n",
      "INFO:tensorflow:global_step/sec: 606.465\n",
      "INFO:tensorflow:loss = 2.7832427, step = 29100 (0.165 sec)\n",
      "INFO:tensorflow:global_step/sec: 600.807\n",
      "INFO:tensorflow:loss = 10.834962, step = 29200 (0.166 sec)\n",
      "INFO:tensorflow:global_step/sec: 602.098\n",
      "INFO:tensorflow:loss = 6.8787136, step = 29300 (0.166 sec)\n",
      "INFO:tensorflow:global_step/sec: 602.762\n",
      "INFO:tensorflow:loss = 6.808033, step = 29400 (0.166 sec)\n",
      "INFO:tensorflow:global_step/sec: 610.062\n",
      "INFO:tensorflow:loss = 9.8611145, step = 29500 (0.164 sec)\n",
      "INFO:tensorflow:global_step/sec: 608.143\n",
      "INFO:tensorflow:loss = 2.415665, step = 29600 (0.164 sec)\n",
      "INFO:tensorflow:global_step/sec: 611.1\n",
      "INFO:tensorflow:loss = 18.143162, step = 29700 (0.164 sec)\n",
      "INFO:tensorflow:global_step/sec: 605.798\n",
      "INFO:tensorflow:loss = 32.53024, step = 29800 (0.165 sec)\n",
      "INFO:tensorflow:global_step/sec: 608.495\n",
      "INFO:tensorflow:loss = 20.985128, step = 29900 (0.164 sec)\n",
      "INFO:tensorflow:global_step/sec: 605.6\n",
      "INFO:tensorflow:loss = 6.416387, step = 30000 (0.165 sec)\n",
      "INFO:tensorflow:global_step/sec: 602.897\n",
      "INFO:tensorflow:loss = 9.8632765, step = 30100 (0.166 sec)\n",
      "INFO:tensorflow:global_step/sec: 610.569\n",
      "INFO:tensorflow:loss = 11.159876, step = 30200 (0.164 sec)\n",
      "INFO:tensorflow:global_step/sec: 604.003\n",
      "INFO:tensorflow:loss = 9.881433, step = 30300 (0.166 sec)\n",
      "INFO:tensorflow:global_step/sec: 543.879\n",
      "INFO:tensorflow:loss = 9.262335, step = 30400 (0.184 sec)\n",
      "INFO:tensorflow:global_step/sec: 546.511\n",
      "INFO:tensorflow:loss = 17.03417, step = 30500 (0.183 sec)\n",
      "INFO:tensorflow:global_step/sec: 545.885\n",
      "INFO:tensorflow:loss = 10.3673935, step = 30600 (0.183 sec)\n",
      "INFO:tensorflow:global_step/sec: 546.124\n",
      "INFO:tensorflow:loss = 25.351206, step = 30700 (0.183 sec)\n",
      "INFO:tensorflow:global_step/sec: 543.776\n",
      "INFO:tensorflow:loss = 8.311635, step = 30800 (0.184 sec)\n",
      "INFO:tensorflow:global_step/sec: 542.803\n",
      "INFO:tensorflow:loss = 8.52332, step = 30900 (0.184 sec)\n",
      "INFO:tensorflow:global_step/sec: 544.122\n",
      "INFO:tensorflow:loss = 10.649828, step = 31000 (0.184 sec)\n",
      "INFO:tensorflow:global_step/sec: 544.884\n",
      "INFO:tensorflow:loss = 22.182236, step = 31100 (0.183 sec)\n",
      "INFO:tensorflow:global_step/sec: 546.106\n",
      "INFO:tensorflow:loss = 20.22522, step = 31200 (0.183 sec)\n",
      "INFO:tensorflow:global_step/sec: 543.58\n",
      "INFO:tensorflow:loss = 14.5345745, step = 31300 (0.184 sec)\n",
      "INFO:tensorflow:global_step/sec: 545.816\n",
      "INFO:tensorflow:loss = 9.6771145, step = 31400 (0.183 sec)\n",
      "INFO:tensorflow:global_step/sec: 544.645\n",
      "INFO:tensorflow:loss = 2.5696018, step = 31500 (0.183 sec)\n",
      "INFO:tensorflow:global_step/sec: 544.149\n",
      "INFO:tensorflow:loss = 9.068397, step = 31600 (0.184 sec)\n",
      "INFO:tensorflow:global_step/sec: 546.632\n",
      "INFO:tensorflow:loss = 6.858538, step = 31700 (0.183 sec)\n",
      "INFO:tensorflow:global_step/sec: 570.394\n",
      "INFO:tensorflow:loss = 18.26683, step = 31800 (0.175 sec)\n",
      "INFO:tensorflow:global_step/sec: 543.878\n",
      "INFO:tensorflow:loss = 17.251534, step = 31900 (0.184 sec)\n",
      "INFO:tensorflow:global_step/sec: 542.828\n",
      "INFO:tensorflow:loss = 10.44895, step = 32000 (0.184 sec)\n",
      "INFO:tensorflow:global_step/sec: 543.41\n",
      "INFO:tensorflow:loss = 18.04864, step = 32100 (0.184 sec)\n",
      "INFO:tensorflow:global_step/sec: 544.2\n",
      "INFO:tensorflow:loss = 13.094084, step = 32200 (0.184 sec)\n",
      "INFO:tensorflow:global_step/sec: 546.057\n",
      "INFO:tensorflow:loss = 8.776364, step = 32300 (0.183 sec)\n",
      "INFO:tensorflow:global_step/sec: 643.668\n",
      "INFO:tensorflow:loss = 14.646915, step = 32400 (0.155 sec)\n",
      "INFO:tensorflow:global_step/sec: 775.954\n",
      "INFO:tensorflow:loss = 20.17769, step = 32500 (0.129 sec)\n",
      "INFO:tensorflow:global_step/sec: 770.345\n",
      "INFO:tensorflow:loss = 19.51951, step = 32600 (0.130 sec)\n",
      "INFO:tensorflow:global_step/sec: 775.36\n",
      "INFO:tensorflow:loss = 5.5544243, step = 32700 (0.129 sec)\n",
      "INFO:tensorflow:global_step/sec: 765.466\n",
      "INFO:tensorflow:loss = 37.185738, step = 32800 (0.131 sec)\n",
      "INFO:tensorflow:global_step/sec: 768.973\n",
      "INFO:tensorflow:loss = 5.7744956, step = 32900 (0.130 sec)\n",
      "INFO:tensorflow:global_step/sec: 773.062\n",
      "INFO:tensorflow:loss = 17.285326, step = 33000 (0.129 sec)\n",
      "INFO:tensorflow:global_step/sec: 768.782\n",
      "INFO:tensorflow:loss = 11.432161, step = 33100 (0.130 sec)\n",
      "INFO:tensorflow:global_step/sec: 769.416\n",
      "INFO:tensorflow:loss = 10.647139, step = 33200 (0.130 sec)\n",
      "INFO:tensorflow:global_step/sec: 568.848\n",
      "INFO:tensorflow:loss = 17.527779, step = 33300 (0.176 sec)\n",
      "INFO:tensorflow:global_step/sec: 565.42\n",
      "INFO:tensorflow:loss = 8.771994, step = 33400 (0.177 sec)\n",
      "INFO:tensorflow:global_step/sec: 547.723\n",
      "INFO:tensorflow:loss = 5.8024187, step = 33500 (0.183 sec)\n",
      "INFO:tensorflow:global_step/sec: 548.616\n",
      "INFO:tensorflow:loss = 12.336805, step = 33600 (0.182 sec)\n",
      "INFO:tensorflow:global_step/sec: 546.078\n",
      "INFO:tensorflow:loss = 11.5433445, step = 33700 (0.183 sec)\n",
      "INFO:tensorflow:global_step/sec: 546.044\n",
      "INFO:tensorflow:loss = 24.768154, step = 33800 (0.183 sec)\n",
      "INFO:tensorflow:global_step/sec: 546.071\n",
      "INFO:tensorflow:loss = 22.965652, step = 33900 (0.183 sec)\n",
      "INFO:tensorflow:global_step/sec: 548.37\n",
      "INFO:tensorflow:loss = 3.0824807, step = 34000 (0.182 sec)\n",
      "INFO:tensorflow:global_step/sec: 548.365\n",
      "INFO:tensorflow:loss = 4.8034067, step = 34100 (0.182 sec)\n",
      "INFO:tensorflow:global_step/sec: 550.658\n",
      "INFO:tensorflow:loss = 7.623246, step = 34200 (0.182 sec)\n",
      "INFO:tensorflow:global_step/sec: 549.428\n",
      "INFO:tensorflow:loss = 13.926509, step = 34300 (0.182 sec)\n",
      "INFO:tensorflow:global_step/sec: 548.851\n",
      "INFO:tensorflow:loss = 4.921852, step = 34400 (0.182 sec)\n",
      "INFO:tensorflow:global_step/sec: 593.461\n",
      "INFO:tensorflow:loss = 15.878366, step = 34500 (0.169 sec)\n",
      "INFO:tensorflow:global_step/sec: 547.936\n",
      "INFO:tensorflow:loss = 6.4329367, step = 34600 (0.182 sec)\n",
      "INFO:tensorflow:global_step/sec: 552.165\n",
      "INFO:tensorflow:loss = 21.83181, step = 34700 (0.181 sec)\n",
      "INFO:tensorflow:global_step/sec: 546.055\n",
      "INFO:tensorflow:loss = 15.049608, step = 34800 (0.183 sec)\n",
      "INFO:tensorflow:global_step/sec: 564.433\n",
      "INFO:tensorflow:loss = 24.10469, step = 34900 (0.177 sec)\n",
      "INFO:tensorflow:global_step/sec: 615.854\n",
      "INFO:tensorflow:loss = 16.756222, step = 35000 (0.162 sec)\n",
      "INFO:tensorflow:global_step/sec: 564.854\n",
      "INFO:tensorflow:loss = 26.640182, step = 35100 (0.177 sec)\n",
      "INFO:tensorflow:global_step/sec: 598.873\n",
      "INFO:tensorflow:loss = 14.472396, step = 35200 (0.167 sec)\n",
      "INFO:tensorflow:global_step/sec: 607.23\n",
      "INFO:tensorflow:loss = 9.683292, step = 35300 (0.165 sec)\n",
      "INFO:tensorflow:global_step/sec: 606.485\n",
      "INFO:tensorflow:loss = 12.334396, step = 35400 (0.165 sec)\n",
      "INFO:tensorflow:global_step/sec: 607.167\n",
      "INFO:tensorflow:loss = 14.236019, step = 35500 (0.165 sec)\n",
      "INFO:tensorflow:global_step/sec: 606.019\n",
      "INFO:tensorflow:loss = 2.557418, step = 35600 (0.165 sec)\n",
      "INFO:tensorflow:global_step/sec: 604.564\n",
      "INFO:tensorflow:loss = 6.4518137, step = 35700 (0.165 sec)\n",
      "INFO:tensorflow:global_step/sec: 602.769\n",
      "INFO:tensorflow:loss = 7.5966053, step = 35800 (0.166 sec)\n",
      "INFO:tensorflow:global_step/sec: 606.048\n",
      "INFO:tensorflow:loss = 2.8703623, step = 35900 (0.165 sec)\n",
      "INFO:tensorflow:global_step/sec: 606.159\n",
      "INFO:tensorflow:loss = 13.266034, step = 36000 (0.165 sec)\n",
      "INFO:tensorflow:global_step/sec: 608.452\n",
      "INFO:tensorflow:loss = 33.426186, step = 36100 (0.164 sec)\n",
      "INFO:tensorflow:global_step/sec: 614.914\n",
      "INFO:tensorflow:loss = 7.106618, step = 36200 (0.163 sec)\n",
      "INFO:tensorflow:global_step/sec: 579.671\n",
      "INFO:tensorflow:loss = 4.7745647, step = 36300 (0.173 sec)\n",
      "INFO:tensorflow:global_step/sec: 601.973\n",
      "INFO:tensorflow:loss = 5.621604, step = 36400 (0.166 sec)\n",
      "INFO:tensorflow:global_step/sec: 604.749\n",
      "INFO:tensorflow:loss = 13.650362, step = 36500 (0.165 sec)\n",
      "INFO:tensorflow:global_step/sec: 604.775\n",
      "INFO:tensorflow:loss = 8.876423, step = 36600 (0.165 sec)\n",
      "INFO:tensorflow:global_step/sec: 611.643\n",
      "INFO:tensorflow:loss = 4.1911793, step = 36700 (0.163 sec)\n",
      "INFO:tensorflow:global_step/sec: 604.658\n",
      "INFO:tensorflow:loss = 8.318517, step = 36800 (0.165 sec)\n",
      "INFO:tensorflow:global_step/sec: 587.601\n",
      "INFO:tensorflow:loss = 17.430899, step = 36900 (0.170 sec)\n",
      "INFO:tensorflow:global_step/sec: 551.054\n",
      "INFO:tensorflow:loss = 14.823732, step = 37000 (0.181 sec)\n",
      "INFO:tensorflow:global_step/sec: 553.571\n",
      "INFO:tensorflow:loss = 15.501139, step = 37100 (0.181 sec)\n",
      "INFO:tensorflow:global_step/sec: 547.342\n",
      "INFO:tensorflow:loss = 4.173862, step = 37200 (0.183 sec)\n",
      "INFO:tensorflow:global_step/sec: 550.411\n",
      "INFO:tensorflow:loss = 4.278327, step = 37300 (0.182 sec)\n",
      "INFO:tensorflow:global_step/sec: 623.356\n",
      "INFO:tensorflow:loss = 6.808351, step = 37400 (0.161 sec)\n",
      "INFO:tensorflow:global_step/sec: 633.486\n",
      "INFO:tensorflow:loss = 9.919334, step = 37500 (0.158 sec)\n",
      "INFO:tensorflow:global_step/sec: 634.199\n",
      "INFO:tensorflow:loss = 7.04196, step = 37600 (0.158 sec)\n",
      "INFO:tensorflow:global_step/sec: 632.811\n",
      "INFO:tensorflow:loss = 15.828875, step = 37700 (0.158 sec)\n",
      "INFO:tensorflow:global_step/sec: 622.919\n",
      "INFO:tensorflow:loss = 11.002477, step = 37800 (0.161 sec)\n",
      "INFO:tensorflow:global_step/sec: 632.102\n",
      "INFO:tensorflow:loss = 23.273972, step = 37900 (0.158 sec)\n",
      "INFO:tensorflow:global_step/sec: 625.609\n",
      "INFO:tensorflow:loss = 5.7780647, step = 38000 (0.160 sec)\n",
      "INFO:tensorflow:global_step/sec: 640.198\n",
      "INFO:tensorflow:loss = 24.69968, step = 38100 (0.156 sec)\n",
      "INFO:tensorflow:global_step/sec: 627.085\n",
      "INFO:tensorflow:loss = 14.841597, step = 38200 (0.159 sec)\n",
      "INFO:tensorflow:global_step/sec: 628.11\n",
      "INFO:tensorflow:loss = 9.693447, step = 38300 (0.159 sec)\n",
      "INFO:tensorflow:global_step/sec: 636.381\n",
      "INFO:tensorflow:loss = 8.004492, step = 38400 (0.157 sec)\n",
      "INFO:tensorflow:global_step/sec: 633.516\n",
      "INFO:tensorflow:loss = 8.497599, step = 38500 (0.158 sec)\n",
      "INFO:tensorflow:global_step/sec: 623.189\n",
      "INFO:tensorflow:loss = 12.888876, step = 38600 (0.160 sec)\n",
      "INFO:tensorflow:global_step/sec: 620.277\n",
      "INFO:tensorflow:loss = 3.6877656, step = 38700 (0.161 sec)\n",
      "INFO:tensorflow:global_step/sec: 623.356\n",
      "INFO:tensorflow:loss = 22.447525, step = 38800 (0.160 sec)\n",
      "INFO:tensorflow:global_step/sec: 635.261\n",
      "INFO:tensorflow:loss = 13.225922, step = 38900 (0.157 sec)\n",
      "INFO:tensorflow:global_step/sec: 631.679\n",
      "INFO:tensorflow:loss = 21.030441, step = 39000 (0.158 sec)\n",
      "INFO:tensorflow:global_step/sec: 631.577\n",
      "INFO:tensorflow:loss = 13.090731, step = 39100 (0.158 sec)\n",
      "INFO:tensorflow:global_step/sec: 622.036\n",
      "INFO:tensorflow:loss = 17.78622, step = 39200 (0.161 sec)\n",
      "INFO:tensorflow:global_step/sec: 627.711\n",
      "INFO:tensorflow:loss = 14.776085, step = 39300 (0.159 sec)\n",
      "INFO:tensorflow:global_step/sec: 632.626\n",
      "INFO:tensorflow:loss = 9.62057, step = 39400 (0.158 sec)\n",
      "INFO:tensorflow:global_step/sec: 637.925\n",
      "INFO:tensorflow:loss = 2.3708858, step = 39500 (0.157 sec)\n",
      "INFO:tensorflow:global_step/sec: 592.376\n",
      "INFO:tensorflow:loss = 11.080213, step = 39600 (0.169 sec)\n",
      "INFO:tensorflow:global_step/sec: 546.263\n",
      "INFO:tensorflow:loss = 5.8864245, step = 39700 (0.183 sec)\n",
      "INFO:tensorflow:global_step/sec: 545.308\n",
      "INFO:tensorflow:loss = 8.431757, step = 39800 (0.183 sec)\n",
      "INFO:tensorflow:global_step/sec: 545.548\n",
      "INFO:tensorflow:loss = 6.2483263, step = 39900 (0.183 sec)\n",
      "INFO:tensorflow:Saving checkpoints for 40000 into models/autompg-dnnregressor/model.ckpt.\n",
      "INFO:tensorflow:Loss for final step: 3.2347763.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<tensorflow_estimator.python.estimator.canned.dnn.DNNRegressorV2 at 0x7fea733d8e50>"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "EPOCHS = 1000\n",
    "BATCH_SIZE = 8\n",
    "total_steps = EPOCHS * int(np.ceil(len(df_train) / BATCH_SIZE))\n",
    "print('Training Steps: ', total_steps)\n",
    "\n",
    "regressor.train(\n",
    "    input_fn=lambda:train_input_fn(df_train_norm, batch_size=BATCH_SIZE),\n",
    "    steps=total_steps)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Using default config.\n",
      "INFO:tensorflow:Using config: {'_model_dir': 'models/autompg-dnnregressor/', '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_steps': None, '_save_checkpoints_secs': 600, '_session_config': allow_soft_placement: true\n",
      "graph_options {\n",
      "  rewrite_options {\n",
      "    meta_optimizer_iterations: ONE\n",
      "  }\n",
      "}\n",
      ", '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 100, '_train_distribute': None, '_device_fn': None, '_protocol': None, '_eval_distribute': None, '_experimental_distribute': None, '_experimental_max_worker_delay_secs': None, '_session_creation_timeout_secs': 7200, '_service': None, '_cluster_spec': <tensorflow.python.training.server_lib.ClusterSpec object at 0x7fea70321050>, '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1}\n"
     ]
    }
   ],
   "source": [
    "reloaded_regressor = tf.estimator.DNNRegressor(\n",
    "    feature_columns=all_feature_columns,\n",
    "    hidden_units=[32, 10],\n",
    "    warm_start_from='models/autompg-dnnregressor/',\n",
    "    model_dir='models/autompg-dnnregressor/')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Calling model_fn.\n",
      "WARNING:tensorflow:Layer dnn is casting an input tensor from dtype float64 to the layer's dtype of float32, which is new behavior in TensorFlow 2.  The layer has dtype float32 because it's dtype defaults to floatx.\n",
      "\n",
      "If you intended to run this layer in float32, you can safely ignore this warning. If in doubt, this warning is likely only an issue if you are porting a TensorFlow 1.X model to TensorFlow 2.\n",
      "\n",
      "To change all layers to have dtype float64 by default, call `tf.keras.backend.set_floatx('float64')`. To change just this layer, pass dtype='float64' to the layer constructor. If you are the author of this layer, you can disable autocasting by passing autocast=False to the base Layer constructor.\n",
      "\n",
      "INFO:tensorflow:Done calling model_fn.\n",
      "INFO:tensorflow:Starting evaluation at 2019-10-06T17:55:16Z\n",
      "INFO:tensorflow:Graph was finalized.\n",
      "INFO:tensorflow:Restoring parameters from models/autompg-dnnregressor/model.ckpt-40000\n",
      "INFO:tensorflow:Running local_init_op.\n",
      "INFO:tensorflow:Done running local_init_op.\n",
      "INFO:tensorflow:Finished evaluation at 2019-10-06-17:55:16\n",
      "INFO:tensorflow:Saving dict for global step 40000: average_loss = 15.186558, global_step = 40000, label/mean = 23.611393, loss = 15.09321, prediction/mean = 22.16366\n",
      "INFO:tensorflow:Saving 'checkpoint_path' summary for global step 40000: models/autompg-dnnregressor/model.ckpt-40000\n",
      "average_loss    15.18655776977539\n",
      "label/mean      23.611392974853516\n",
      "loss            15.093210220336914\n",
      "prediction/mean 22.163660049438477\n",
      "global_step     40000\n",
      "Average-Loss 15.1866\n"
     ]
    }
   ],
   "source": [
    "def eval_input_fn(df_test, batch_size=8):\n",
    "    df = df_test.copy()\n",
    "    test_x, test_y = df, df.pop('MPG')\n",
    "    dataset = tf.data.Dataset.from_tensor_slices((dict(test_x), test_y))\n",
    "\n",
    "    return dataset.batch(batch_size)\n",
    "\n",
    "eval_results = reloaded_regressor.evaluate(\n",
    "    input_fn=lambda:eval_input_fn(df_test_norm, batch_size=8))\n",
    "\n",
    "for key in eval_results:\n",
    "    print('{:15s} {}'.format(key, eval_results[key]))\n",
    "    \n",
    "print('Average-Loss {:.4f}'.format(eval_results['average_loss']))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Calling model_fn.\n",
      "WARNING:tensorflow:Layer dnn is casting an input tensor from dtype float64 to the layer's dtype of float32, which is new behavior in TensorFlow 2.  The layer has dtype float32 because it's dtype defaults to floatx.\n",
      "\n",
      "If you intended to run this layer in float32, you can safely ignore this warning. If in doubt, this warning is likely only an issue if you are porting a TensorFlow 1.X model to TensorFlow 2.\n",
      "\n",
      "To change all layers to have dtype float64 by default, call `tf.keras.backend.set_floatx('float64')`. To change just this layer, pass dtype='float64' to the layer constructor. If you are the author of this layer, you can disable autocasting by passing autocast=False to the base Layer constructor.\n",
      "\n",
      "INFO:tensorflow:Done calling model_fn.\n",
      "INFO:tensorflow:Graph was finalized.\n",
      "INFO:tensorflow:Restoring parameters from models/autompg-dnnregressor/model.ckpt-40000\n",
      "INFO:tensorflow:Running local_init_op.\n",
      "INFO:tensorflow:Done running local_init_op.\n",
      "{'predictions': array([23.747658], dtype=float32)}\n"
     ]
    }
   ],
   "source": [
    "\n",
    "\n",
    "pred_res = regressor.predict(input_fn=lambda: eval_input_fn(df_test_norm, batch_size=8))\n",
    "\n",
    "print(next(iter(pred_res)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Boosted Tree Regressor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Using default config.\n",
      "WARNING:tensorflow:Using temporary folder as model directory: /tmp/tmpos_6ksrf\n",
      "INFO:tensorflow:Using config: {'_model_dir': '/tmp/tmpos_6ksrf', '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_steps': None, '_save_checkpoints_secs': 600, '_session_config': allow_soft_placement: true\n",
      "graph_options {\n",
      "  rewrite_options {\n",
      "    meta_optimizer_iterations: ONE\n",
      "  }\n",
      "}\n",
      ", '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 100, '_train_distribute': None, '_device_fn': None, '_protocol': None, '_eval_distribute': None, '_experimental_distribute': None, '_experimental_max_worker_delay_secs': None, '_session_creation_timeout_secs': 7200, '_service': None, '_cluster_spec': <tensorflow.python.training.server_lib.ClusterSpec object at 0x7fea70138e10>, '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1}\n",
      "INFO:tensorflow:Calling model_fn.\n",
      "INFO:tensorflow:Done calling model_fn.\n",
      "INFO:tensorflow:Create CheckpointSaverHook.\n",
      "WARNING:tensorflow:Issue encountered when serializing resources.\n",
      "Type is unsupported, or the types of the items don't match field type in CollectionDef. Note this is a warning and probably safe to ignore.\n",
      "'_Resource' object has no attribute 'name'\n",
      "INFO:tensorflow:Graph was finalized.\n",
      "INFO:tensorflow:Running local_init_op.\n",
      "INFO:tensorflow:Done running local_init_op.\n",
      "WARNING:tensorflow:Issue encountered when serializing resources.\n",
      "Type is unsupported, or the types of the items don't match field type in CollectionDef. Note this is a warning and probably safe to ignore.\n",
      "'_Resource' object has no attribute 'name'\n",
      "INFO:tensorflow:Saving checkpoints for 0 into /tmp/tmpos_6ksrf/model.ckpt.\n",
      "WARNING:tensorflow:Issue encountered when serializing resources.\n",
      "Type is unsupported, or the types of the items don't match field type in CollectionDef. Note this is a warning and probably safe to ignore.\n",
      "'_Resource' object has no attribute 'name'\n",
      "INFO:tensorflow:loss = 623.53503, step = 0\n",
      "INFO:tensorflow:loss = 253.33023, step = 80 (0.447 sec)\n",
      "INFO:tensorflow:global_step/sec: 160.905\n",
      "INFO:tensorflow:loss = 86.758156, step = 180 (0.366 sec)\n",
      "INFO:tensorflow:global_step/sec: 420.518\n",
      "INFO:tensorflow:loss = 41.81453, step = 280 (0.247 sec)\n",
      "INFO:tensorflow:global_step/sec: 408.12\n",
      "INFO:tensorflow:loss = 10.729473, step = 380 (0.249 sec)\n",
      "INFO:tensorflow:global_step/sec: 401.775\n",
      "INFO:tensorflow:loss = 7.053065, step = 480 (0.251 sec)\n",
      "INFO:tensorflow:global_step/sec: 399.654\n",
      "INFO:tensorflow:loss = 5.803857, step = 580 (0.240 sec)\n",
      "INFO:tensorflow:global_step/sec: 392.589\n",
      "INFO:tensorflow:loss = 10.6741085, step = 680 (0.250 sec)\n",
      "INFO:tensorflow:global_step/sec: 410.962\n",
      "INFO:tensorflow:loss = 2.0203042, step = 780 (0.250 sec)\n",
      "INFO:tensorflow:global_step/sec: 405.152\n",
      "INFO:tensorflow:loss = 6.1307974, step = 880 (0.254 sec)\n",
      "INFO:tensorflow:global_step/sec: 399.381\n",
      "INFO:tensorflow:loss = 3.539592, step = 980 (0.255 sec)\n",
      "INFO:tensorflow:global_step/sec: 391.912\n",
      "INFO:tensorflow:loss = 4.290577, step = 1080 (0.255 sec)\n",
      "INFO:tensorflow:global_step/sec: 392.68\n",
      "INFO:tensorflow:loss = 1.6383308, step = 1180 (0.245 sec)\n",
      "INFO:tensorflow:global_step/sec: 387.588\n",
      "INFO:tensorflow:loss = 0.8708091, step = 1280 (0.253 sec)\n",
      "INFO:tensorflow:global_step/sec: 405.002\n",
      "INFO:tensorflow:loss = 1.3396549, step = 1380 (0.255 sec)\n",
      "INFO:tensorflow:global_step/sec: 400.188\n",
      "INFO:tensorflow:loss = 6.682251, step = 1480 (0.254 sec)\n",
      "INFO:tensorflow:global_step/sec: 394.264\n",
      "INFO:tensorflow:loss = 4.10042, step = 1580 (0.258 sec)\n",
      "INFO:tensorflow:global_step/sec: 388.049\n",
      "INFO:tensorflow:loss = 2.662496, step = 1680 (0.263 sec)\n",
      "INFO:tensorflow:global_step/sec: 380.532\n",
      "INFO:tensorflow:loss = 1.244699, step = 1780 (0.246 sec)\n",
      "INFO:tensorflow:global_step/sec: 388.456\n",
      "INFO:tensorflow:loss = 1.9717957, step = 1880 (0.249 sec)\n",
      "INFO:tensorflow:global_step/sec: 409.251\n",
      "INFO:tensorflow:loss = 0.9274743, step = 1980 (0.262 sec)\n",
      "INFO:tensorflow:global_step/sec: 386.986\n",
      "INFO:tensorflow:loss = 0.40791252, step = 2080 (0.261 sec)\n",
      "INFO:tensorflow:global_step/sec: 385.011\n",
      "INFO:tensorflow:loss = 0.65465933, step = 2180 (0.260 sec)\n",
      "INFO:tensorflow:global_step/sec: 386.87\n",
      "INFO:tensorflow:loss = 0.41372976, step = 2280 (0.263 sec)\n",
      "INFO:tensorflow:global_step/sec: 382.75\n",
      "INFO:tensorflow:loss = 1.3418026, step = 2380 (0.246 sec)\n",
      "INFO:tensorflow:global_step/sec: 384.233\n",
      "INFO:tensorflow:loss = 0.60337806, step = 2480 (0.254 sec)\n",
      "INFO:tensorflow:global_step/sec: 402.181\n",
      "INFO:tensorflow:loss = 1.4781059, step = 2580 (0.260 sec)\n",
      "INFO:tensorflow:global_step/sec: 389.426\n",
      "INFO:tensorflow:loss = 0.19650409, step = 2680 (0.264 sec)\n",
      "INFO:tensorflow:global_step/sec: 380.339\n",
      "INFO:tensorflow:loss = 1.1014357, step = 2780 (0.267 sec)\n",
      "INFO:tensorflow:global_step/sec: 375.959\n",
      "INFO:tensorflow:loss = 0.6665402, step = 2880 (0.269 sec)\n",
      "INFO:tensorflow:global_step/sec: 371.947\n",
      "INFO:tensorflow:loss = 0.3238989, step = 2980 (0.256 sec)\n",
      "INFO:tensorflow:global_step/sec: 372.197\n",
      "INFO:tensorflow:loss = 0.6706404, step = 3080 (0.263 sec)\n",
      "INFO:tensorflow:global_step/sec: 388.704\n",
      "INFO:tensorflow:loss = 0.95094025, step = 3180 (0.271 sec)\n",
      "INFO:tensorflow:global_step/sec: 377.66\n",
      "INFO:tensorflow:loss = 0.15089291, step = 3280 (0.263 sec)\n",
      "INFO:tensorflow:global_step/sec: 383.576\n",
      "INFO:tensorflow:loss = 0.20291357, step = 3380 (0.267 sec)\n",
      "INFO:tensorflow:global_step/sec: 372.998\n",
      "INFO:tensorflow:loss = 0.49755168, step = 3480 (0.269 sec)\n",
      "INFO:tensorflow:global_step/sec: 370.159\n",
      "INFO:tensorflow:loss = 0.6534091, step = 3580 (0.261 sec)\n",
      "INFO:tensorflow:global_step/sec: 367.568\n",
      "INFO:tensorflow:loss = 0.14818114, step = 3680 (0.263 sec)\n",
      "INFO:tensorflow:global_step/sec: 389.315\n",
      "INFO:tensorflow:loss = 0.23829585, step = 3780 (0.267 sec)\n",
      "INFO:tensorflow:global_step/sec: 380.231\n",
      "INFO:tensorflow:loss = 0.7760176, step = 3880 (0.270 sec)\n",
      "INFO:tensorflow:global_step/sec: 373.111\n",
      "INFO:tensorflow:loss = 0.6041539, step = 3980 (0.272 sec)\n",
      "INFO:tensorflow:global_step/sec: 370.583\n",
      "INFO:tensorflow:loss = 0.5407955, step = 4080 (0.270 sec)\n",
      "INFO:tensorflow:global_step/sec: 370.641\n",
      "INFO:tensorflow:loss = 0.5053086, step = 4180 (0.259 sec)\n",
      "INFO:tensorflow:global_step/sec: 365.036\n",
      "INFO:tensorflow:loss = 0.18544577, step = 4280 (0.266 sec)\n",
      "INFO:tensorflow:global_step/sec: 386.884\n",
      "INFO:tensorflow:loss = 0.46846813, step = 4380 (0.270 sec)\n",
      "INFO:tensorflow:global_step/sec: 376.621\n",
      "INFO:tensorflow:loss = 0.32655868, step = 4480 (0.273 sec)\n",
      "INFO:tensorflow:global_step/sec: 368.212\n",
      "INFO:tensorflow:loss = 0.4194101, step = 4580 (0.273 sec)\n",
      "INFO:tensorflow:global_step/sec: 367.991\n",
      "INFO:tensorflow:loss = 0.18378381, step = 4680 (0.274 sec)\n",
      "INFO:tensorflow:global_step/sec: 363.512\n",
      "INFO:tensorflow:loss = 0.15389407, step = 4780 (0.267 sec)\n",
      "INFO:tensorflow:global_step/sec: 360.834\n",
      "INFO:tensorflow:loss = 0.1345658, step = 4880 (0.266 sec)\n",
      "INFO:tensorflow:global_step/sec: 382.84\n",
      "INFO:tensorflow:loss = 0.241535, step = 4980 (0.274 sec)\n",
      "INFO:tensorflow:global_step/sec: 368.686\n",
      "INFO:tensorflow:loss = 0.21019253, step = 5080 (0.275 sec)\n",
      "INFO:tensorflow:global_step/sec: 364.975\n",
      "INFO:tensorflow:loss = 1.229659, step = 5180 (0.278 sec)\n",
      "INFO:tensorflow:global_step/sec: 360.945\n",
      "INFO:tensorflow:loss = 0.3842961, step = 5280 (0.277 sec)\n",
      "INFO:tensorflow:global_step/sec: 360.749\n",
      "INFO:tensorflow:loss = 0.30949628, step = 5380 (0.268 sec)\n",
      "INFO:tensorflow:global_step/sec: 355.466\n",
      "INFO:tensorflow:loss = 0.37451607, step = 5480 (0.273 sec)\n",
      "INFO:tensorflow:global_step/sec: 376.807\n",
      "INFO:tensorflow:loss = 0.20820905, step = 5580 (0.278 sec)\n",
      "INFO:tensorflow:global_step/sec: 363.899\n",
      "INFO:tensorflow:loss = 0.13567057, step = 5680 (0.287 sec)\n",
      "INFO:tensorflow:global_step/sec: 348.619\n",
      "INFO:tensorflow:loss = 0.2721311, step = 5780 (0.284 sec)\n",
      "INFO:tensorflow:global_step/sec: 355.045\n",
      "INFO:tensorflow:loss = 0.35641688, step = 5880 (0.283 sec)\n",
      "INFO:tensorflow:global_step/sec: 354.04\n",
      "INFO:tensorflow:loss = 0.17041269, step = 5980 (0.271 sec)\n",
      "INFO:tensorflow:global_step/sec: 351.08\n",
      "INFO:tensorflow:loss = 0.60950536, step = 6080 (0.253 sec)\n",
      "INFO:tensorflow:global_step/sec: 417.202\n",
      "INFO:tensorflow:loss = 0.26656717, step = 6180 (0.247 sec)\n",
      "INFO:tensorflow:global_step/sec: 407.654\n",
      "INFO:tensorflow:loss = 0.77231365, step = 6280 (0.257 sec)\n",
      "INFO:tensorflow:global_step/sec: 392.997\n",
      "INFO:tensorflow:loss = 0.22460794, step = 6380 (0.261 sec)\n",
      "INFO:tensorflow:global_step/sec: 382.983\n",
      "INFO:tensorflow:loss = 0.18314129, step = 6480 (0.255 sec)\n",
      "INFO:tensorflow:global_step/sec: 395.772\n",
      "INFO:tensorflow:loss = 0.08586919, step = 6580 (0.268 sec)\n",
      "INFO:tensorflow:global_step/sec: 346.516\n",
      "INFO:tensorflow:loss = 0.08796426, step = 6680 (0.289 sec)\n",
      "INFO:tensorflow:global_step/sec: 353.103\n",
      "INFO:tensorflow:loss = 0.08278617, step = 6780 (0.290 sec)\n",
      "INFO:tensorflow:global_step/sec: 349.923\n",
      "INFO:tensorflow:loss = 0.17962529, step = 6880 (0.293 sec)\n",
      "INFO:tensorflow:global_step/sec: 342.997\n",
      "INFO:tensorflow:loss = 0.098591894, step = 6980 (0.295 sec)\n",
      "INFO:tensorflow:global_step/sec: 340.433\n",
      "INFO:tensorflow:loss = 0.12199256, step = 7080 (0.294 sec)\n",
      "INFO:tensorflow:global_step/sec: 341.197\n",
      "INFO:tensorflow:loss = 0.08100985, step = 7180 (0.282 sec)\n",
      "INFO:tensorflow:global_step/sec: 338.347\n",
      "INFO:tensorflow:loss = 0.10816482, step = 7280 (0.290 sec)\n",
      "INFO:tensorflow:global_step/sec: 352.32\n",
      "INFO:tensorflow:loss = 0.06819467, step = 7380 (0.293 sec)\n",
      "INFO:tensorflow:global_step/sec: 347.007\n",
      "INFO:tensorflow:loss = 0.046484947, step = 7480 (0.295 sec)\n",
      "INFO:tensorflow:global_step/sec: 339.75\n",
      "INFO:tensorflow:loss = 0.046328872, step = 7580 (0.298 sec)\n",
      "INFO:tensorflow:global_step/sec: 335.183\n",
      "INFO:tensorflow:loss = 0.57472974, step = 7680 (0.305 sec)\n",
      "INFO:tensorflow:global_step/sec: 328.977\n",
      "INFO:tensorflow:loss = 0.12615885, step = 7780 (0.291 sec)\n",
      "INFO:tensorflow:global_step/sec: 327.683\n",
      "INFO:tensorflow:loss = 0.4255345, step = 7880 (0.300 sec)\n",
      "INFO:tensorflow:global_step/sec: 342.059\n",
      "INFO:tensorflow:loss = 0.08983396, step = 7980 (0.301 sec)\n",
      "INFO:tensorflow:global_step/sec: 335.722\n",
      "INFO:tensorflow:loss = 0.0242597, step = 8080 (0.304 sec)\n",
      "INFO:tensorflow:global_step/sec: 330.006\n",
      "INFO:tensorflow:loss = 0.014305854, step = 8180 (0.307 sec)\n",
      "INFO:tensorflow:global_step/sec: 325.291\n",
      "INFO:tensorflow:loss = 0.064209536, step = 8280 (0.309 sec)\n",
      "INFO:tensorflow:global_step/sec: 325.855\n",
      "INFO:tensorflow:loss = 0.07691235, step = 8380 (0.293 sec)\n",
      "INFO:tensorflow:global_step/sec: 324.868\n",
      "INFO:tensorflow:loss = 0.18103845, step = 8480 (0.301 sec)\n",
      "INFO:tensorflow:global_step/sec: 340.311\n",
      "INFO:tensorflow:loss = 0.10037625, step = 8580 (0.309 sec)\n",
      "INFO:tensorflow:global_step/sec: 327.601\n",
      "INFO:tensorflow:loss = 0.110353254, step = 8680 (0.309 sec)\n",
      "INFO:tensorflow:global_step/sec: 326.795\n",
      "INFO:tensorflow:loss = 0.03432948, step = 8780 (0.306 sec)\n",
      "INFO:tensorflow:global_step/sec: 326.107\n",
      "INFO:tensorflow:loss = 0.059009552, step = 8880 (0.308 sec)\n",
      "INFO:tensorflow:global_step/sec: 325.489\n",
      "INFO:tensorflow:loss = 0.032255642, step = 8980 (0.296 sec)\n",
      "INFO:tensorflow:global_step/sec: 320.843\n",
      "INFO:tensorflow:loss = 0.077510275, step = 9080 (0.306 sec)\n",
      "INFO:tensorflow:global_step/sec: 335.829\n",
      "INFO:tensorflow:loss = 0.028462265, step = 9180 (0.306 sec)\n",
      "INFO:tensorflow:global_step/sec: 332.152\n",
      "INFO:tensorflow:loss = 0.04032657, step = 9280 (0.303 sec)\n",
      "INFO:tensorflow:global_step/sec: 331.884\n",
      "INFO:tensorflow:loss = 0.030592121, step = 9380 (0.310 sec)\n",
      "INFO:tensorflow:global_step/sec: 322.62\n",
      "INFO:tensorflow:loss = 0.083413005, step = 9480 (0.312 sec)\n",
      "INFO:tensorflow:global_step/sec: 319.082\n",
      "INFO:tensorflow:loss = 0.043285307, step = 9580 (0.299 sec)\n",
      "INFO:tensorflow:global_step/sec: 322.143\n",
      "INFO:tensorflow:loss = 0.026327636, step = 9680 (0.304 sec)\n",
      "INFO:tensorflow:global_step/sec: 334.422\n",
      "INFO:tensorflow:loss = 0.151696, step = 9780 (0.308 sec)\n",
      "INFO:tensorflow:global_step/sec: 327.693\n",
      "INFO:tensorflow:loss = 0.119765855, step = 9880 (0.310 sec)\n",
      "INFO:tensorflow:global_step/sec: 324.721\n",
      "INFO:tensorflow:loss = 0.03941699, step = 9980 (0.315 sec)\n",
      "INFO:tensorflow:global_step/sec: 317.946\n",
      "INFO:tensorflow:loss = 0.042621423, step = 10080 (0.313 sec)\n",
      "INFO:tensorflow:global_step/sec: 319.929\n",
      "INFO:tensorflow:loss = 0.058344625, step = 10180 (0.307 sec)\n",
      "INFO:tensorflow:global_step/sec: 309.841\n",
      "INFO:tensorflow:loss = 0.076871246, step = 10280 (0.317 sec)\n",
      "INFO:tensorflow:global_step/sec: 324.418\n",
      "INFO:tensorflow:loss = 0.021496374, step = 10380 (0.321 sec)\n",
      "INFO:tensorflow:global_step/sec: 314.226\n",
      "INFO:tensorflow:loss = 0.006834712, step = 10480 (0.320 sec)\n",
      "INFO:tensorflow:global_step/sec: 313.808\n",
      "INFO:tensorflow:loss = 0.032068744, step = 10580 (0.322 sec)\n",
      "INFO:tensorflow:global_step/sec: 311.058\n",
      "INFO:tensorflow:loss = 0.012654156, step = 10680 (0.324 sec)\n",
      "INFO:tensorflow:global_step/sec: 309.638\n",
      "INFO:tensorflow:loss = 0.04483257, step = 10780 (0.310 sec)\n",
      "INFO:tensorflow:global_step/sec: 307.224\n",
      "INFO:tensorflow:loss = 0.036381215, step = 10880 (0.322 sec)\n",
      "INFO:tensorflow:global_step/sec: 318.017\n",
      "INFO:tensorflow:loss = 0.010510937, step = 10980 (0.326 sec)\n",
      "INFO:tensorflow:global_step/sec: 309.865\n",
      "INFO:tensorflow:loss = 0.018372875, step = 11080 (0.328 sec)\n",
      "INFO:tensorflow:global_step/sec: 307.565\n",
      "INFO:tensorflow:loss = 0.05339595, step = 11180 (0.326 sec)\n",
      "INFO:tensorflow:global_step/sec: 307.967\n",
      "INFO:tensorflow:loss = 0.07428838, step = 11280 (0.328 sec)\n",
      "INFO:tensorflow:global_step/sec: 307.515\n",
      "INFO:tensorflow:loss = 0.011740442, step = 11380 (0.309 sec)\n",
      "INFO:tensorflow:global_step/sec: 308.752\n",
      "INFO:tensorflow:loss = 0.0074716154, step = 11480 (0.316 sec)\n",
      "INFO:tensorflow:global_step/sec: 322.593\n",
      "INFO:tensorflow:loss = 0.03239619, step = 11580 (0.321 sec)\n",
      "INFO:tensorflow:global_step/sec: 314.13\n",
      "INFO:tensorflow:loss = 0.028759517, step = 11680 (0.322 sec)\n",
      "INFO:tensorflow:global_step/sec: 313.896\n",
      "INFO:tensorflow:loss = 0.019010104, step = 11780 (0.322 sec)\n",
      "INFO:tensorflow:global_step/sec: 311.094\n",
      "INFO:tensorflow:loss = 0.013204106, step = 11880 (0.315 sec)\n",
      "INFO:tensorflow:global_step/sec: 317.402\n",
      "INFO:tensorflow:loss = 0.012117969, step = 11980 (0.308 sec)\n",
      "INFO:tensorflow:global_step/sec: 311.145\n",
      "INFO:tensorflow:loss = 0.019471288, step = 12080 (0.320 sec)\n",
      "INFO:tensorflow:global_step/sec: 318.951\n",
      "INFO:tensorflow:loss = 0.019658012, step = 12180 (0.326 sec)\n",
      "INFO:tensorflow:global_step/sec: 308.646\n",
      "INFO:tensorflow:loss = 0.005117608, step = 12280 (0.330 sec)\n",
      "INFO:tensorflow:global_step/sec: 306.945\n",
      "INFO:tensorflow:loss = 0.038993098, step = 12380 (0.327 sec)\n",
      "INFO:tensorflow:global_step/sec: 305.049\n",
      "INFO:tensorflow:loss = 0.020406593, step = 12480 (0.333 sec)\n",
      "INFO:tensorflow:global_step/sec: 299.871\n",
      "INFO:tensorflow:loss = 0.0090289805, step = 12580 (0.322 sec)\n",
      "INFO:tensorflow:global_step/sec: 299.939\n",
      "INFO:tensorflow:loss = 0.006531168, step = 12680 (0.328 sec)\n",
      "INFO:tensorflow:global_step/sec: 309.971\n",
      "INFO:tensorflow:loss = 0.0025853133, step = 12780 (0.333 sec)\n",
      "INFO:tensorflow:global_step/sec: 301.824\n",
      "INFO:tensorflow:loss = 0.0082032895, step = 12880 (0.332 sec)\n",
      "INFO:tensorflow:global_step/sec: 305.788\n",
      "INFO:tensorflow:loss = 0.006439007, step = 12980 (0.326 sec)\n",
      "INFO:tensorflow:global_step/sec: 306.069\n",
      "INFO:tensorflow:loss = 0.005619075, step = 13080 (0.335 sec)\n",
      "INFO:tensorflow:global_step/sec: 301.524\n",
      "INFO:tensorflow:loss = 0.010091941, step = 13180 (0.318 sec)\n",
      "INFO:tensorflow:global_step/sec: 299.022\n",
      "INFO:tensorflow:loss = 0.0130573055, step = 13280 (0.331 sec)\n",
      "INFO:tensorflow:global_step/sec: 307.753\n",
      "INFO:tensorflow:loss = 0.01725234, step = 13380 (0.338 sec)\n",
      "INFO:tensorflow:global_step/sec: 298.443\n",
      "INFO:tensorflow:loss = 0.02495825, step = 13480 (0.336 sec)\n",
      "INFO:tensorflow:global_step/sec: 301.305\n",
      "INFO:tensorflow:loss = 0.026571378, step = 13580 (0.334 sec)\n",
      "INFO:tensorflow:global_step/sec: 297.204\n",
      "INFO:tensorflow:loss = 0.019483749, step = 13680 (0.338 sec)\n",
      "INFO:tensorflow:global_step/sec: 299.13\n",
      "INFO:tensorflow:loss = 0.006268067, step = 13780 (0.320 sec)\n",
      "INFO:tensorflow:global_step/sec: 297.824\n",
      "INFO:tensorflow:loss = 0.009512516, step = 13880 (0.335 sec)\n",
      "INFO:tensorflow:global_step/sec: 304.389\n",
      "INFO:tensorflow:loss = 0.009578241, step = 13980 (0.338 sec)\n",
      "INFO:tensorflow:global_step/sec: 299.479\n",
      "INFO:tensorflow:loss = 0.013397868, step = 14080 (0.341 sec)\n",
      "INFO:tensorflow:global_step/sec: 293.311\n",
      "INFO:tensorflow:loss = 0.0042418875, step = 14180 (0.342 sec)\n",
      "INFO:tensorflow:global_step/sec: 294.558\n",
      "INFO:tensorflow:loss = 0.018557403, step = 14280 (0.340 sec)\n",
      "INFO:tensorflow:global_step/sec: 293.882\n",
      "INFO:tensorflow:loss = 0.011596655, step = 14380 (0.327 sec)\n",
      "INFO:tensorflow:global_step/sec: 293.636\n",
      "INFO:tensorflow:loss = 0.0056028846, step = 14480 (0.335 sec)\n",
      "INFO:tensorflow:global_step/sec: 304.153\n",
      "INFO:tensorflow:loss = 0.011124132, step = 14580 (0.343 sec)\n",
      "INFO:tensorflow:global_step/sec: 294.167\n",
      "INFO:tensorflow:loss = 0.0056153648, step = 14680 (0.345 sec)\n",
      "INFO:tensorflow:global_step/sec: 291.616\n",
      "INFO:tensorflow:loss = 0.0019941647, step = 14780 (0.347 sec)\n",
      "INFO:tensorflow:global_step/sec: 288.515\n",
      "INFO:tensorflow:loss = 0.004212275, step = 14880 (0.347 sec)\n",
      "INFO:tensorflow:global_step/sec: 290.284\n",
      "INFO:tensorflow:loss = 0.0037952317, step = 14980 (0.329 sec)\n",
      "INFO:tensorflow:global_step/sec: 290.445\n",
      "INFO:tensorflow:loss = 0.0042548347, step = 15080 (0.338 sec)\n",
      "INFO:tensorflow:global_step/sec: 301.729\n",
      "INFO:tensorflow:loss = 0.0047678244, step = 15180 (0.343 sec)\n",
      "INFO:tensorflow:global_step/sec: 295.52\n",
      "INFO:tensorflow:loss = 0.005469841, step = 15280 (0.346 sec)\n",
      "INFO:tensorflow:global_step/sec: 289.43\n",
      "INFO:tensorflow:loss = 0.00469305, step = 15380 (0.348 sec)\n",
      "INFO:tensorflow:global_step/sec: 288.639\n",
      "INFO:tensorflow:loss = 0.008090111, step = 15480 (0.350 sec)\n",
      "INFO:tensorflow:global_step/sec: 285.412\n",
      "INFO:tensorflow:loss = 0.017089844, step = 15580 (0.338 sec)\n",
      "INFO:tensorflow:global_step/sec: 286.625\n",
      "INFO:tensorflow:loss = 0.004096309, step = 15680 (0.341 sec)\n",
      "INFO:tensorflow:global_step/sec: 296.296\n",
      "INFO:tensorflow:loss = 0.011275276, step = 15780 (0.351 sec)\n",
      "INFO:tensorflow:global_step/sec: 288.606\n",
      "INFO:tensorflow:loss = 0.0025311639, step = 15880 (0.353 sec)\n",
      "INFO:tensorflow:global_step/sec: 284.449\n",
      "INFO:tensorflow:loss = 0.0062829275, step = 15980 (0.355 sec)\n",
      "INFO:tensorflow:global_step/sec: 281.733\n",
      "INFO:tensorflow:loss = 0.0016862957, step = 16080 (0.357 sec)\n",
      "INFO:tensorflow:global_step/sec: 282.034\n",
      "INFO:tensorflow:loss = 0.007675102, step = 16180 (0.340 sec)\n",
      "INFO:tensorflow:global_step/sec: 280.677\n",
      "INFO:tensorflow:loss = 0.0008325178, step = 16280 (0.351 sec)\n",
      "INFO:tensorflow:global_step/sec: 292.441\n",
      "INFO:tensorflow:loss = 0.0034268438, step = 16380 (0.352 sec)\n",
      "INFO:tensorflow:global_step/sec: 286.035\n",
      "INFO:tensorflow:loss = 0.0027856806, step = 16480 (0.357 sec)\n",
      "INFO:tensorflow:global_step/sec: 281.312\n",
      "INFO:tensorflow:loss = 0.0028347662, step = 16580 (0.356 sec)\n",
      "INFO:tensorflow:global_step/sec: 280.89\n",
      "INFO:tensorflow:loss = 0.00051759527, step = 16680 (0.356 sec)\n",
      "INFO:tensorflow:global_step/sec: 281.796\n",
      "INFO:tensorflow:loss = 0.003048962, step = 16780 (0.347 sec)\n",
      "INFO:tensorflow:global_step/sec: 276.664\n",
      "INFO:tensorflow:loss = 0.008885926, step = 16880 (0.351 sec)\n",
      "INFO:tensorflow:global_step/sec: 290.218\n",
      "INFO:tensorflow:loss = 0.006082525, step = 16980 (0.353 sec)\n",
      "INFO:tensorflow:global_step/sec: 287.865\n",
      "INFO:tensorflow:loss = 0.0015377826, step = 17080 (0.357 sec)\n",
      "INFO:tensorflow:global_step/sec: 280.16\n",
      "INFO:tensorflow:loss = 0.0063670063, step = 17180 (0.363 sec)\n",
      "INFO:tensorflow:global_step/sec: 277.212\n",
      "INFO:tensorflow:loss = 0.0042023608, step = 17280 (0.354 sec)\n",
      "INFO:tensorflow:global_step/sec: 283.186\n",
      "INFO:tensorflow:loss = 0.0048547797, step = 17380 (0.344 sec)\n",
      "INFO:tensorflow:global_step/sec: 280.674\n",
      "INFO:tensorflow:loss = 0.0041769175, step = 17480 (0.350 sec)\n",
      "INFO:tensorflow:global_step/sec: 290.777\n",
      "INFO:tensorflow:loss = 0.002464649, step = 17580 (0.352 sec)\n",
      "INFO:tensorflow:global_step/sec: 286.275\n",
      "INFO:tensorflow:loss = 0.0027441583, step = 17680 (0.357 sec)\n",
      "INFO:tensorflow:global_step/sec: 281.543\n",
      "INFO:tensorflow:loss = 0.0036998442, step = 17780 (0.359 sec)\n",
      "INFO:tensorflow:global_step/sec: 279.275\n",
      "INFO:tensorflow:loss = 0.0027609495, step = 17880 (0.360 sec)\n",
      "INFO:tensorflow:global_step/sec: 277.477\n",
      "INFO:tensorflow:loss = 0.0012809625, step = 17980 (0.348 sec)\n",
      "INFO:tensorflow:global_step/sec: 278.435\n",
      "INFO:tensorflow:loss = 0.004579692, step = 18080 (0.352 sec)\n",
      "INFO:tensorflow:global_step/sec: 288.879\n",
      "INFO:tensorflow:loss = 0.0010537787, step = 18180 (0.359 sec)\n",
      "INFO:tensorflow:global_step/sec: 281.447\n",
      "INFO:tensorflow:loss = 0.0012701816, step = 18280 (0.359 sec)\n",
      "INFO:tensorflow:global_step/sec: 279.135\n",
      "INFO:tensorflow:loss = 0.00076436147, step = 18380 (0.362 sec)\n",
      "INFO:tensorflow:global_step/sec: 277.3\n",
      "INFO:tensorflow:loss = 0.0041650557, step = 18480 (0.361 sec)\n",
      "INFO:tensorflow:global_step/sec: 277.072\n",
      "INFO:tensorflow:loss = 0.0017748652, step = 18580 (0.350 sec)\n",
      "INFO:tensorflow:global_step/sec: 275.214\n",
      "INFO:tensorflow:loss = 0.0019556829, step = 18680 (0.362 sec)\n",
      "INFO:tensorflow:global_step/sec: 280.496\n",
      "INFO:tensorflow:loss = 0.003920836, step = 18780 (0.366 sec)\n",
      "INFO:tensorflow:global_step/sec: 275.607\n",
      "INFO:tensorflow:loss = 0.001190217, step = 18880 (0.368 sec)\n",
      "INFO:tensorflow:global_step/sec: 273.728\n",
      "INFO:tensorflow:loss = 0.0007947081, step = 18980 (0.371 sec)\n",
      "INFO:tensorflow:global_step/sec: 270.167\n",
      "INFO:tensorflow:loss = 0.0017583217, step = 19080 (0.369 sec)\n",
      "INFO:tensorflow:global_step/sec: 271.871\n",
      "INFO:tensorflow:loss = 0.00043815974, step = 19180 (0.358 sec)\n",
      "INFO:tensorflow:global_step/sec: 268.466\n",
      "INFO:tensorflow:loss = 0.0010497833, step = 19280 (0.363 sec)\n",
      "INFO:tensorflow:global_step/sec: 280.565\n",
      "INFO:tensorflow:loss = 0.0007486555, step = 19380 (0.367 sec)\n",
      "INFO:tensorflow:global_step/sec: 274.422\n",
      "INFO:tensorflow:loss = 0.003815694, step = 19480 (0.368 sec)\n",
      "INFO:tensorflow:global_step/sec: 273.745\n",
      "INFO:tensorflow:loss = 0.0011952422, step = 19580 (0.370 sec)\n",
      "INFO:tensorflow:global_step/sec: 272.061\n",
      "INFO:tensorflow:loss = 0.0022656748, step = 19680 (0.369 sec)\n",
      "INFO:tensorflow:global_step/sec: 270.668\n",
      "INFO:tensorflow:loss = 0.000613081, step = 19780 (0.359 sec)\n",
      "INFO:tensorflow:global_step/sec: 268.513\n",
      "INFO:tensorflow:loss = 0.0014473374, step = 19880 (0.365 sec)\n",
      "INFO:tensorflow:global_step/sec: 278.904\n",
      "INFO:tensorflow:loss = 0.0017055769, step = 19980 (0.369 sec)\n",
      "INFO:tensorflow:global_step/sec: 274.849\n",
      "INFO:tensorflow:loss = 0.0013687317, step = 20080 (0.370 sec)\n",
      "INFO:tensorflow:global_step/sec: 270.543\n",
      "INFO:tensorflow:loss = 0.0007818587, step = 20180 (0.372 sec)\n",
      "INFO:tensorflow:global_step/sec: 269.421\n",
      "INFO:tensorflow:loss = 0.0005079101, step = 20280 (0.376 sec)\n",
      "INFO:tensorflow:global_step/sec: 266.07\n",
      "INFO:tensorflow:loss = 0.0010259222, step = 20380 (0.363 sec)\n",
      "INFO:tensorflow:global_step/sec: 266.589\n",
      "INFO:tensorflow:loss = 0.0012335249, step = 20480 (0.367 sec)\n",
      "INFO:tensorflow:global_step/sec: 277.408\n",
      "INFO:tensorflow:loss = 0.002605944, step = 20580 (0.365 sec)\n",
      "INFO:tensorflow:global_step/sec: 281.888\n",
      "INFO:tensorflow:loss = 0.0010553624, step = 20680 (0.336 sec)\n",
      "INFO:tensorflow:global_step/sec: 298.925\n",
      "INFO:tensorflow:loss = 0.00013761694, step = 20780 (0.362 sec)\n",
      "INFO:tensorflow:global_step/sec: 270.614\n",
      "INFO:tensorflow:loss = 0.0005673123, step = 20880 (0.378 sec)\n",
      "INFO:tensorflow:global_step/sec: 265.252\n",
      "INFO:tensorflow:loss = 0.00028406878, step = 20980 (0.364 sec)\n",
      "INFO:tensorflow:global_step/sec: 263.571\n",
      "INFO:tensorflow:loss = 0.00038662832, step = 21080 (0.373 sec)\n",
      "INFO:tensorflow:global_step/sec: 274.599\n",
      "INFO:tensorflow:loss = 0.00088284945, step = 21180 (0.378 sec)\n",
      "INFO:tensorflow:global_step/sec: 266.632\n",
      "INFO:tensorflow:loss = 0.002049651, step = 21280 (0.378 sec)\n",
      "INFO:tensorflow:global_step/sec: 266.92\n",
      "INFO:tensorflow:loss = 0.00040053113, step = 21380 (0.380 sec)\n",
      "INFO:tensorflow:global_step/sec: 263.138\n",
      "INFO:tensorflow:loss = 0.00041711246, step = 21480 (0.382 sec)\n",
      "INFO:tensorflow:global_step/sec: 262.812\n",
      "INFO:tensorflow:loss = 0.00042464054, step = 21580 (0.367 sec)\n",
      "INFO:tensorflow:global_step/sec: 261.846\n",
      "INFO:tensorflow:loss = 0.0010065361, step = 21680 (0.377 sec)\n",
      "INFO:tensorflow:global_step/sec: 271.22\n",
      "INFO:tensorflow:loss = 0.0005866914, step = 21780 (0.380 sec)\n",
      "INFO:tensorflow:global_step/sec: 265.848\n",
      "INFO:tensorflow:loss = 0.00027671893, step = 21880 (0.382 sec)\n",
      "INFO:tensorflow:global_step/sec: 262.055\n",
      "INFO:tensorflow:loss = 0.00036802975, step = 21980 (0.383 sec)\n",
      "INFO:tensorflow:global_step/sec: 261.948\n",
      "INFO:tensorflow:loss = 0.00013698009, step = 22080 (0.383 sec)\n",
      "INFO:tensorflow:global_step/sec: 260.444\n",
      "INFO:tensorflow:loss = 0.00017702841, step = 22180 (0.370 sec)\n",
      "INFO:tensorflow:global_step/sec: 262.067\n",
      "INFO:tensorflow:loss = 0.0015975421, step = 22280 (0.378 sec)\n",
      "INFO:tensorflow:global_step/sec: 268.495\n",
      "INFO:tensorflow:loss = 0.00070010894, step = 22380 (0.382 sec)\n",
      "INFO:tensorflow:global_step/sec: 263.104\n",
      "INFO:tensorflow:loss = 0.0007586455, step = 22480 (0.386 sec)\n",
      "INFO:tensorflow:global_step/sec: 261.308\n",
      "INFO:tensorflow:loss = 0.00030616176, step = 22580 (0.386 sec)\n",
      "INFO:tensorflow:global_step/sec: 258.783\n",
      "INFO:tensorflow:loss = 0.0015422241, step = 22680 (0.389 sec)\n",
      "INFO:tensorflow:global_step/sec: 258.694\n",
      "INFO:tensorflow:loss = 0.0011715429, step = 22780 (0.373 sec)\n",
      "INFO:tensorflow:global_step/sec: 257.923\n",
      "INFO:tensorflow:loss = 0.00029495667, step = 22880 (0.385 sec)\n",
      "INFO:tensorflow:global_step/sec: 264.829\n",
      "INFO:tensorflow:loss = 0.0006073343, step = 22980 (0.386 sec)\n",
      "INFO:tensorflow:global_step/sec: 262.215\n",
      "INFO:tensorflow:loss = 0.00061574497, step = 23080 (0.389 sec)\n",
      "INFO:tensorflow:global_step/sec: 257.536\n",
      "INFO:tensorflow:loss = 0.00054436014, step = 23180 (0.391 sec)\n",
      "INFO:tensorflow:global_step/sec: 256.276\n",
      "INFO:tensorflow:loss = 0.00029620412, step = 23280 (0.392 sec)\n",
      "INFO:tensorflow:global_step/sec: 254.337\n",
      "INFO:tensorflow:loss = 0.00024264466, step = 23380 (0.380 sec)\n",
      "INFO:tensorflow:global_step/sec: 253.687\n",
      "INFO:tensorflow:loss = 0.00045313008, step = 23480 (0.385 sec)\n",
      "INFO:tensorflow:global_step/sec: 264.562\n",
      "INFO:tensorflow:loss = 0.00023694421, step = 23580 (0.391 sec)\n",
      "INFO:tensorflow:global_step/sec: 258.958\n",
      "INFO:tensorflow:loss = 0.00016719027, step = 23680 (0.391 sec)\n",
      "INFO:tensorflow:global_step/sec: 256.323\n",
      "INFO:tensorflow:loss = 0.00029504643, step = 23780 (0.395 sec)\n",
      "INFO:tensorflow:global_step/sec: 253.457\n",
      "INFO:tensorflow:loss = 0.0003263256, step = 23880 (0.397 sec)\n",
      "INFO:tensorflow:global_step/sec: 237.736\n",
      "INFO:tensorflow:loss = 0.0003567127, step = 23980 (0.448 sec)\n",
      "INFO:tensorflow:global_step/sec: 223.331\n",
      "INFO:tensorflow:Saving checkpoints for 24000 into /tmp/tmpos_6ksrf/model.ckpt.\n",
      "WARNING:tensorflow:Issue encountered when serializing resources.\n",
      "Type is unsupported, or the types of the items don't match field type in CollectionDef. Note this is a warning and probably safe to ignore.\n",
      "'_Resource' object has no attribute 'name'\n",
      "INFO:tensorflow:Loss for final step: 0.00016184276.\n",
      "INFO:tensorflow:Calling model_fn.\n",
      "INFO:tensorflow:Done calling model_fn.\n",
      "INFO:tensorflow:Starting evaluation at 2019-10-06T18:05:12Z\n",
      "INFO:tensorflow:Graph was finalized.\n",
      "INFO:tensorflow:Restoring parameters from /tmp/tmpos_6ksrf/model.ckpt-24000\n",
      "INFO:tensorflow:Running local_init_op.\n",
      "INFO:tensorflow:Done running local_init_op.\n",
      "INFO:tensorflow:Finished evaluation at 2019-10-06-18:05:12\n",
      "INFO:tensorflow:Saving dict for global step 24000: average_loss = 12.991299, global_step = 24000, label/mean = 23.611393, loss = 12.8544235, prediction/mean = 22.624313\n",
      "WARNING:tensorflow:Issue encountered when serializing resources.\n",
      "Type is unsupported, or the types of the items don't match field type in CollectionDef. Note this is a warning and probably safe to ignore.\n",
      "'_Resource' object has no attribute 'name'\n",
      "INFO:tensorflow:Saving 'checkpoint_path' summary for global step 24000: /tmp/tmpos_6ksrf/model.ckpt-24000\n",
      "{'average_loss': 12.991299, 'label/mean': 23.611393, 'loss': 12.8544235, 'prediction/mean': 22.624313, 'global_step': 24000}\n",
      "Average-Loss 12.9913\n"
     ]
    }
   ],
   "source": [
    "\n",
    "boosted_tree = tf.estimator.BoostedTreesRegressor(\n",
    "    feature_columns=all_feature_columns,\n",
    "    n_batches_per_layer=20,\n",
    "    n_trees=200)\n",
    "\n",
    "boosted_tree.train(\n",
    "    input_fn=lambda:train_input_fn(df_train_norm, batch_size=BATCH_SIZE))\n",
    "\n",
    "eval_results = boosted_tree.evaluate(\n",
    "    input_fn=lambda:eval_input_fn(df_test_norm, batch_size=8))\n",
    "\n",
    "print(eval_results)\n",
    "\n",
    "print('Average-Loss {:.4f}'.format(eval_results['average_loss']))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Using Estimators for MNIST hand-written digit classification"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "import tensorflow_datasets as tfds\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "BUFFER_SIZE = 10000\n",
    "BATCH_SIZE = 64\n",
    "NUM_EPOCHS = 20\n",
    "steps_per_epoch = np.ceil(60000 / BATCH_SIZE)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def preprocess(item):\n",
    "    image = item['image']\n",
    "    label = item['label']\n",
    "    image = tf.image.convert_image_dtype(\n",
    "        image, tf.float32)\n",
    "    image = tf.reshape(image, (-1,))\n",
    "\n",
    "    return {'image-pixels':image}, label[..., tf.newaxis]\n",
    "\n",
    "#Step 1: Defining the input functions (one for training and one for evaluation)\n",
    "## Step 1: Define the input function for training\n",
    "def train_input_fn():\n",
    "    datasets = tfds.load(name='mnist')\n",
    "    mnist_train = datasets['train']\n",
    "\n",
    "    dataset = mnist_train.map(preprocess)\n",
    "    dataset = dataset.shuffle(BUFFER_SIZE)\n",
    "    dataset = dataset.batch(BATCH_SIZE)\n",
    "    return dataset.repeat()\n",
    "\n",
    "## define input-function for evaluation:\n",
    "def eval_input_fn():\n",
    "    datasets = tfds.load(name='mnist')\n",
    "    mnist_test = datasets['test']\n",
    "    dataset = mnist_test.map(preprocess).batch(BATCH_SIZE)\n",
    "    return dataset\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Step 2: feature column\n",
    "image_feature_column = tf.feature_column.numeric_column(\n",
    "    key='image-pixels', shape=(28*28))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Using default config.\n",
      "INFO:tensorflow:Using config: {'_model_dir': 'models/mnist-dnn/', '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_steps': None, '_save_checkpoints_secs': 600, '_session_config': allow_soft_placement: true\n",
      "graph_options {\n",
      "  rewrite_options {\n",
      "    meta_optimizer_iterations: ONE\n",
      "  }\n",
      "}\n",
      ", '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 100, '_train_distribute': None, '_device_fn': None, '_protocol': None, '_eval_distribute': None, '_experimental_distribute': None, '_experimental_max_worker_delay_secs': None, '_session_creation_timeout_secs': 7200, '_service': None, '_cluster_spec': <tensorflow.python.training.server_lib.ClusterSpec object at 0x7f84b0103a10>, '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1}\n",
      "WARNING:tensorflow:From /home/vahid/anaconda3/envs/tf2/lib/python3.7/site-packages/tensorflow_core/python/ops/resource_variable_ops.py:1630: calling BaseResourceVariable.__init__ (from tensorflow.python.ops.resource_variable_ops) with constraint is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "If using Keras pass *_constraint arguments to layers.\n",
      "WARNING:tensorflow:From /home/vahid/anaconda3/envs/tf2/lib/python3.7/site-packages/tensorflow_core/python/training/training_util.py:236: Variable.initialized_value (from tensorflow.python.ops.variables) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use Variable.read_value. Variables in 2.X are initialized automatically both in eager and graph (inside tf.defun) contexts.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:absl:Warning: Setting shuffle_files=True because split=TRAIN and shuffle_files=None. This behavior will be deprecated on 2019-08-06, at which point shuffle_files=False will be the default for all splits.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Calling model_fn.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Calling model_fn.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From /home/vahid/anaconda3/envs/tf2/lib/python3.7/site-packages/tensorflow_core/python/keras/optimizer_v2/adagrad.py:108: calling Constant.__init__ (from tensorflow.python.ops.init_ops) with dtype is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Call initializer instance with the dtype argument instead of passing it to the constructor\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From /home/vahid/anaconda3/envs/tf2/lib/python3.7/site-packages/tensorflow_core/python/keras/optimizer_v2/adagrad.py:108: calling Constant.__init__ (from tensorflow.python.ops.init_ops) with dtype is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Call initializer instance with the dtype argument instead of passing it to the constructor\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Done calling model_fn.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Done calling model_fn.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Create CheckpointSaverHook.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Create CheckpointSaverHook.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Graph was finalized.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Graph was finalized.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Running local_init_op.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Running local_init_op.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Done running local_init_op.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Done running local_init_op.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Saving checkpoints for 0 into models/mnist-dnn/model.ckpt.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Saving checkpoints for 0 into models/mnist-dnn/model.ckpt.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 2.2911584, step = 0\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 2.2911584, step = 0\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 103.413\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 103.413\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 2.2823455, step = 100 (0.970 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 2.2823455, step = 100 (0.970 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 114.706\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 114.706\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 2.1860042, step = 200 (0.872 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 2.1860042, step = 200 (0.872 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 114.522\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 114.522\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 2.1106935, step = 300 (0.873 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 2.1106935, step = 300 (0.873 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 112.807\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 112.807\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 2.1935492, step = 400 (0.886 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 2.1935492, step = 400 (0.886 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 118.975\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 118.975\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 2.1524801, step = 500 (0.841 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 2.1524801, step = 500 (0.841 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 129.316\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 129.316\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 1.9318869, step = 600 (0.773 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 1.9318869, step = 600 (0.773 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 131.012\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 131.012\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 2.0087776, step = 700 (0.763 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 2.0087776, step = 700 (0.763 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 143.963\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 143.963\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 1.8597662, step = 800 (0.695 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 1.8597662, step = 800 (0.695 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 368.727\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 368.727\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 1.8434176, step = 900 (0.271 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 1.8434176, step = 900 (0.271 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 53.9182\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 53.9182\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 1.825604, step = 1000 (1.855 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 1.825604, step = 1000 (1.855 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 112.703\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 112.703\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 1.8583578, step = 1100 (0.887 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 1.8583578, step = 1100 (0.887 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 113.852\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 113.852\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 1.6823219, step = 1200 (0.878 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 1.6823219, step = 1200 (0.878 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 112.63\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 112.63\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 1.8250992, step = 1300 (0.888 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 1.8250992, step = 1300 (0.888 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 114.176\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 114.176\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 1.756686, step = 1400 (0.876 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 1.756686, step = 1400 (0.876 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 113.677\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 113.677\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 1.81184, step = 1500 (0.880 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 1.81184, step = 1500 (0.880 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 113.666\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 113.666\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 1.6275679, step = 1600 (0.880 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 1.6275679, step = 1600 (0.880 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 115.224\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 115.224\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 1.5493795, step = 1700 (0.868 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 1.5493795, step = 1700 (0.868 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 266.337\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 266.337\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 1.4609478, step = 1800 (0.376 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 1.4609478, step = 1800 (0.376 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 61.4064\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 61.4064\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 1.4662864, step = 1900 (1.628 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 1.4662864, step = 1900 (1.628 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 113.01\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 113.01\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 1.5063202, step = 2000 (0.885 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 1.5063202, step = 2000 (0.885 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 112.874\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 112.874\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 1.5632205, step = 2100 (0.886 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 1.5632205, step = 2100 (0.886 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 112.57\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 112.57\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 1.3806043, step = 2200 (0.888 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 1.3806043, step = 2200 (0.888 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 114.595\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 114.595\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 1.4552122, step = 2300 (0.872 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 1.4552122, step = 2300 (0.872 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 113.828\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 113.828\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 1.4628265, step = 2400 (0.878 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 1.4628265, step = 2400 (0.878 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 113.415\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 113.415\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 1.2242792, step = 2500 (0.882 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 1.2242792, step = 2500 (0.882 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 114.199\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 114.199\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 1.26544, step = 2600 (0.876 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 1.26544, step = 2600 (0.876 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 160.867\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 160.867\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 1.1611787, step = 2700 (0.622 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 1.1611787, step = 2700 (0.622 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 360.855\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 360.855\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 1.1868796, step = 2800 (0.277 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 1.1868796, step = 2800 (0.277 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 61.3427\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 61.3427\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 1.3102021, step = 2900 (1.630 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 1.3102021, step = 2900 (1.630 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 113.321\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 113.321\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 1.287333, step = 3000 (0.882 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 1.287333, step = 3000 (0.882 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 113.287\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 113.287\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 1.3193758, step = 3100 (0.883 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 1.3193758, step = 3100 (0.883 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 112.965\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 112.965\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 1.0507755, step = 3200 (0.885 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 1.0507755, step = 3200 (0.885 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 113.219\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 113.219\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 1.0760037, step = 3300 (0.883 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 1.0760037, step = 3300 (0.883 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 113.1\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 113.1\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.9973794, step = 3400 (0.884 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.9973794, step = 3400 (0.884 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 113.269\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 113.269\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 1.1815102, step = 3500 (0.883 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 1.1815102, step = 3500 (0.883 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 118.013\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 118.013\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 1.0979999, step = 3600 (0.848 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 1.0979999, step = 3600 (0.848 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 374.028\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 374.028\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 1.0193896, step = 3700 (0.267 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 1.0193896, step = 3700 (0.267 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 56.696\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 56.696\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.96348107, step = 3800 (1.764 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.96348107, step = 3800 (1.764 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 113.953\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 113.953\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 1.0168278, step = 3900 (0.877 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 1.0168278, step = 3900 (0.877 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 114.646\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 114.646\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.9198128, step = 4000 (0.872 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.9198128, step = 4000 (0.872 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 113.161\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 113.161\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.802637, step = 4100 (0.884 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.802637, step = 4100 (0.884 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 116.967\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 116.967\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 1.0178231, step = 4200 (0.855 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 1.0178231, step = 4200 (0.855 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 114.172\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 114.172\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.82982206, step = 4300 (0.876 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.82982206, step = 4300 (0.876 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 114.276\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 114.276\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.93774354, step = 4400 (0.875 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.93774354, step = 4400 (0.875 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 114.967\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 114.967\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.9086722, step = 4500 (0.870 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.9086722, step = 4500 (0.870 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 223.506\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 223.506\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.9719672, step = 4600 (0.448 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.9719672, step = 4600 (0.448 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 85.1966\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 85.1966\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.7319959, step = 4700 (1.174 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.7319959, step = 4700 (1.174 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 114.762\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 114.762\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.8509946, step = 4800 (0.871 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.8509946, step = 4800 (0.871 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 114.479\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 114.479\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.83272266, step = 4900 (0.874 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.83272266, step = 4900 (0.874 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 114.192\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 114.192\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.73900056, step = 5000 (0.876 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.73900056, step = 5000 (0.876 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 113.049\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 113.049\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.8810166, step = 5100 (0.884 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.8810166, step = 5100 (0.884 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 114.157\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 114.157\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.6312516, step = 5200 (0.876 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.6312516, step = 5200 (0.876 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 113.086\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 113.086\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.7533829, step = 5300 (0.884 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.7533829, step = 5300 (0.884 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 114.184\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 114.184\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.7571323, step = 5400 (0.876 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.7571323, step = 5400 (0.876 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 141.811\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 141.811\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.78724813, step = 5500 (0.705 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.78724813, step = 5500 (0.705 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 363.272\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 363.272\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.6710961, step = 5600 (0.275 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.6710961, step = 5600 (0.275 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 54.4942\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 54.4942\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.77730715, step = 5700 (1.835 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.77730715, step = 5700 (1.835 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 113.938\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 113.938\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.70322883, step = 5800 (0.878 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.70322883, step = 5800 (0.878 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 113.055\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 113.055\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.565181, step = 5900 (0.884 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.565181, step = 5900 (0.884 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 113.104\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 113.104\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.63991463, step = 6000 (0.884 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.63991463, step = 6000 (0.884 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 112.607\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 112.607\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.693486, step = 6100 (0.888 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.693486, step = 6100 (0.888 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 112.827\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 112.827\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.81442523, step = 6200 (0.886 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.81442523, step = 6200 (0.886 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 114.905\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 114.905\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.6881059, step = 6300 (0.870 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.6881059, step = 6300 (0.870 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 114.642\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 114.642\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.66631556, step = 6400 (0.872 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.66631556, step = 6400 (0.872 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 310.415\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 310.415\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.5797583, step = 6500 (0.322 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.5797583, step = 6500 (0.322 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 76.1143\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 76.1143\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.6987842, step = 6600 (1.314 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.6987842, step = 6600 (1.314 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 112.871\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 112.871\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.69951165, step = 6700 (0.885 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.69951165, step = 6700 (0.885 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 112.564\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 112.564\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.7545166, step = 6800 (0.889 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.7545166, step = 6800 (0.889 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 113.2\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 113.2\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.7573935, step = 6900 (0.884 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.7573935, step = 6900 (0.884 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 112.581\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 112.581\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.69914496, step = 7000 (0.888 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.69914496, step = 7000 (0.888 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 113.63\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 113.63\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.70136493, step = 7100 (0.880 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.70136493, step = 7100 (0.880 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 114.321\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 114.321\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.7457304, step = 7200 (0.875 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.7457304, step = 7200 (0.875 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 113.015\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 113.015\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.6303762, step = 7300 (0.885 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.6303762, step = 7300 (0.885 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 181.441\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 181.441\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.58647394, step = 7400 (0.551 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.58647394, step = 7400 (0.551 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 362.958\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 362.958\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.6209979, step = 7500 (0.275 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.6209979, step = 7500 (0.275 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 47.9044\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 47.9044\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.60263544, step = 7600 (2.087 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.60263544, step = 7600 (2.087 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 114.406\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 114.406\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.50438195, step = 7700 (0.874 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.50438195, step = 7700 (0.874 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 114.461\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 114.461\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.6837965, step = 7800 (0.873 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.6837965, step = 7800 (0.873 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 114.019\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 114.019\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.5446137, step = 7900 (0.877 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.5446137, step = 7900 (0.877 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 114.699\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 114.699\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.48533368, step = 8000 (0.872 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.48533368, step = 8000 (0.872 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 115.261\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 115.261\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.44975787, step = 8100 (0.868 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.44975787, step = 8100 (0.868 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 114.32\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 114.32\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.5842058, step = 8200 (0.875 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.5842058, step = 8200 (0.875 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 127.416\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 127.416\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.61852735, step = 8300 (0.785 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.61852735, step = 8300 (0.785 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 371.705\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 371.705\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.7116207, step = 8400 (0.269 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.7116207, step = 8400 (0.269 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 68.8109\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 68.8109\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.4465224, step = 8500 (1.453 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.4465224, step = 8500 (1.453 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 113.002\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 113.002\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.65266263, step = 8600 (0.885 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.65266263, step = 8600 (0.885 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 115.499\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 115.499\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.5622315, step = 8700 (0.866 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.5622315, step = 8700 (0.866 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 115.406\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 115.406\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.5153136, step = 8800 (0.866 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.5153136, step = 8800 (0.866 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 115.433\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 115.433\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.42014232, step = 8900 (0.866 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.42014232, step = 8900 (0.866 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 114.113\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 114.113\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.42485464, step = 9000 (0.876 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.42485464, step = 9000 (0.876 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 114.144\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 114.144\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.5743935, step = 9100 (0.876 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.5743935, step = 9100 (0.876 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 114.741\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 114.741\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.671422, step = 9200 (0.872 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.671422, step = 9200 (0.872 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 242.343\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 242.343\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.48479798, step = 9300 (0.413 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.48479798, step = 9300 (0.413 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 83.5698\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 83.5698\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.6025954, step = 9400 (1.196 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.6025954, step = 9400 (1.196 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 129.15\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 129.15\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.44718996, step = 9500 (0.774 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.44718996, step = 9500 (0.774 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 120.364\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 120.364\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.7617692, step = 9600 (0.831 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.7617692, step = 9600 (0.831 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 114.263\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 114.263\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.5299103, step = 9700 (0.875 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.5299103, step = 9700 (0.875 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 113.736\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 113.736\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.43787265, step = 9800 (0.879 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.43787265, step = 9800 (0.879 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 113.327\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 113.327\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.3690548, step = 9900 (0.882 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.3690548, step = 9900 (0.882 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 112.415\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 112.415\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.5275825, step = 10000 (0.890 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.5275825, step = 10000 (0.890 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 113.327\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 113.327\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.40371907, step = 10100 (0.882 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.40371907, step = 10100 (0.882 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 156.161\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 156.161\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.4844839, step = 10200 (0.641 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.4844839, step = 10200 (0.641 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 367.758\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 367.758\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.38525915, step = 10300 (0.272 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.38525915, step = 10300 (0.272 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 62.3575\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 62.3575\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.47613, step = 10400 (1.604 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.47613, step = 10400 (1.604 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 114.41\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 114.41\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.68314373, step = 10500 (0.874 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.68314373, step = 10500 (0.874 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 113.926\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 113.926\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.30651793, step = 10600 (0.878 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.30651793, step = 10600 (0.878 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 113.21\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 113.21\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.4338395, step = 10700 (0.883 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.4338395, step = 10700 (0.883 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 113.664\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 113.664\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.4499012, step = 10800 (0.880 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.4499012, step = 10800 (0.880 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 112.881\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 112.881\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.54250115, step = 10900 (0.886 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.54250115, step = 10900 (0.886 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 113.187\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 113.187\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.53265464, step = 11000 (0.884 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.53265464, step = 11000 (0.884 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 114.557\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 114.557\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.5215628, step = 11100 (0.873 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.5215628, step = 11100 (0.873 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 362.696\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 362.696\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.7979821, step = 11200 (0.276 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.7979821, step = 11200 (0.276 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 56.7931\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 56.7931\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.42034245, step = 11300 (1.760 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.42034245, step = 11300 (1.760 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 113.254\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 113.254\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.5292198, step = 11400 (0.883 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.5292198, step = 11400 (0.883 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 114.024\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 114.024\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.4254782, step = 11500 (0.877 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.4254782, step = 11500 (0.877 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 113.553\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 113.553\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.50970966, step = 11600 (0.881 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.50970966, step = 11600 (0.881 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 113.633\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 113.633\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.29519865, step = 11700 (0.880 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.29519865, step = 11700 (0.880 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 112.489\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 112.489\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.42551592, step = 11800 (0.889 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.42551592, step = 11800 (0.889 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 114.285\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 114.285\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.69208634, step = 11900 (0.875 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.69208634, step = 11900 (0.875 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 114.739\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 114.739\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.46524662, step = 12000 (0.871 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.46524662, step = 12000 (0.871 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 201.432\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 201.432\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.64448845, step = 12100 (0.497 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.64448845, step = 12100 (0.497 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 83.4712\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 83.4712\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.6804011, step = 12200 (1.197 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.6804011, step = 12200 (1.197 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 113.681\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 113.681\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.25450796, step = 12300 (0.880 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.25450796, step = 12300 (0.880 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 114.133\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 114.133\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.456465, step = 12400 (0.876 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.456465, step = 12400 (0.876 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 114.349\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 114.349\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.42321965, step = 12500 (0.875 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.42321965, step = 12500 (0.875 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 112.92\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 112.92\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.39983463, step = 12600 (0.886 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.39983463, step = 12600 (0.886 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 113.06\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 113.06\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.3548218, step = 12700 (0.885 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.3548218, step = 12700 (0.885 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 112.597\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 112.597\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.44753984, step = 12800 (0.888 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.44753984, step = 12800 (0.888 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 113.062\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 113.062\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.41929197, step = 12900 (0.885 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.41929197, step = 12900 (0.885 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 138.649\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 138.649\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.35650593, step = 13000 (0.721 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.35650593, step = 13000 (0.721 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 374.276\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 374.276\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.42515814, step = 13100 (0.267 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.42515814, step = 13100 (0.267 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 66.1085\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 66.1085\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.49356452, step = 13200 (1.513 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.49356452, step = 13200 (1.513 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 114.321\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 114.321\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.41032612, step = 13300 (0.875 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.41032612, step = 13300 (0.875 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 115.027\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 115.027\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.5270637, step = 13400 (0.869 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.5270637, step = 13400 (0.869 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 115.032\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 115.032\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.37458575, step = 13500 (0.869 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.37458575, step = 13500 (0.869 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 114.641\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 114.641\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.40344495, step = 13600 (0.872 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.40344495, step = 13600 (0.872 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 115.601\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 115.601\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.53613955, step = 13700 (0.865 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.53613955, step = 13700 (0.865 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 115.628\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 115.628\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.4105112, step = 13800 (0.865 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.4105112, step = 13800 (0.865 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 113.617\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 113.617\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.38070506, step = 13900 (0.880 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.38070506, step = 13900 (0.880 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 289.21\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 289.21\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.49386114, step = 14000 (0.346 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.49386114, step = 14000 (0.346 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 60.6021\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 60.6021\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.55049473, step = 14100 (1.650 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.55049473, step = 14100 (1.650 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 114.677\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 114.677\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.42319727, step = 14200 (0.872 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.42319727, step = 14200 (0.872 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 113.916\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 113.916\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.4049874, step = 14300 (0.878 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.4049874, step = 14300 (0.878 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 114.132\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 114.132\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.43009394, step = 14400 (0.876 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.43009394, step = 14400 (0.876 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 113.773\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 113.773\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.48520046, step = 14500 (0.879 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.48520046, step = 14500 (0.879 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 114.622\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 114.622\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.34818208, step = 14600 (0.872 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.34818208, step = 14600 (0.872 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 114.907\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 114.907\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.3500738, step = 14700 (0.870 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.3500738, step = 14700 (0.870 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 114.216\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 114.216\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.36332196, step = 14800 (0.876 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.36332196, step = 14800 (0.876 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 175.485\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 175.485\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.4468686, step = 14900 (0.570 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.4468686, step = 14900 (0.570 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 365.413\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 365.413\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.42602667, step = 15000 (0.274 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.42602667, step = 15000 (0.274 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 48.86\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 48.86\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.44417766, step = 15100 (2.047 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.44417766, step = 15100 (2.047 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 116.518\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 116.518\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.4127115, step = 15200 (0.858 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.4127115, step = 15200 (0.858 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 114.024\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 114.024\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.36801755, step = 15300 (0.877 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.36801755, step = 15300 (0.877 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 113.828\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 113.828\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.4315992, step = 15400 (0.878 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.4315992, step = 15400 (0.878 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 114.734\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 114.734\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.40361735, step = 15500 (0.872 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.40361735, step = 15500 (0.872 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 115.736\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 115.736\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.2569517, step = 15600 (0.864 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.2569517, step = 15600 (0.864 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 115.164\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 115.164\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.6191261, step = 15700 (0.868 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.6191261, step = 15700 (0.868 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 125.364\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 125.364\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.51780957, step = 15800 (0.798 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.51780957, step = 15800 (0.798 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 371.551\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 371.551\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.41759554, step = 15900 (0.269 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.41759554, step = 15900 (0.269 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 55.5316\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 55.5316\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.42506653, step = 16000 (1.801 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.42506653, step = 16000 (1.801 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 116.078\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 116.078\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.5116013, step = 16100 (0.861 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.5116013, step = 16100 (0.861 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 114.288\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 114.288\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.41195214, step = 16200 (0.875 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.41195214, step = 16200 (0.875 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 113.028\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 113.028\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.50017667, step = 16300 (0.885 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.50017667, step = 16300 (0.885 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 113.825\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 113.825\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.4877981, step = 16400 (0.879 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.4877981, step = 16400 (0.879 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 114.086\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 114.086\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.44067618, step = 16500 (0.876 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.44067618, step = 16500 (0.876 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 113.174\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 113.174\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.41255957, step = 16600 (0.884 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.41255957, step = 16600 (0.884 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 114.05\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 114.05\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.42842972, step = 16700 (0.877 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.42842972, step = 16700 (0.877 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 228.281\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 228.281\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.38361323, step = 16800 (0.439 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.38361323, step = 16800 (0.439 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 65.3225\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 65.3225\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.35772476, step = 16900 (1.531 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.35772476, step = 16900 (1.531 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 114.907\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 114.907\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.3619805, step = 17000 (0.870 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.3619805, step = 17000 (0.870 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 113.694\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 113.694\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.52509713, step = 17100 (0.879 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.52509713, step = 17100 (0.879 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 113.523\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 113.523\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.42296046, step = 17200 (0.881 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.42296046, step = 17200 (0.881 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 114.753\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 114.753\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.48458552, step = 17300 (0.871 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.48458552, step = 17300 (0.871 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 112.992\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 112.992\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.30212393, step = 17400 (0.885 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.30212393, step = 17400 (0.885 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 112.902\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 112.902\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.50265574, step = 17500 (0.886 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.50265574, step = 17500 (0.886 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 112.921\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 112.921\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.29823345, step = 17600 (0.885 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.29823345, step = 17600 (0.885 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 150.37\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 150.37\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.3331016, step = 17700 (0.665 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.3331016, step = 17700 (0.665 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 380.586\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 380.586\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.38862753, step = 17800 (0.263 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.38862753, step = 17800 (0.263 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 52.4361\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 52.4361\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.44772893, step = 17900 (1.907 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.44772893, step = 17900 (1.907 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 113.274\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 113.274\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.28227234, step = 18000 (0.882 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.28227234, step = 18000 (0.882 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 114.795\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 114.795\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.24277452, step = 18100 (0.872 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.24277452, step = 18100 (0.872 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 114.489\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 114.489\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.31620902, step = 18200 (0.874 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.31620902, step = 18200 (0.874 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 114.686\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 114.686\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.34351897, step = 18300 (0.872 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.34351897, step = 18300 (0.872 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 113.773\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 113.773\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.3088002, step = 18400 (0.879 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.3088002, step = 18400 (0.879 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 114.688\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 114.688\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.43423826, step = 18500 (0.872 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.43423826, step = 18500 (0.872 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 113.319\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 113.319\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.42925596, step = 18600 (0.882 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.42925596, step = 18600 (0.882 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 366.589\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:global_step/sec: 366.589\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.29147583, step = 18700 (0.273 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loss = 0.29147583, step = 18700 (0.273 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Saving checkpoints for 18760 into models/mnist-dnn/model.ckpt.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Saving checkpoints for 18760 into models/mnist-dnn/model.ckpt.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Loss for final step: 0.35029247.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Loss for final step: 0.35029247.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<tensorflow_estimator.python.estimator.canned.dnn.DNNClassifierV2 at 0x7f843848bc10>"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "## Step 3: instantiate the estimator\n",
    "dnn_classifier = tf.estimator.DNNClassifier(\n",
    "    feature_columns=[image_feature_column],\n",
    "    hidden_units=[32, 16],\n",
    "    n_classes=10,\n",
    "    model_dir='models/mnist-dnn/')\n",
    "\n",
    "\n",
    "## Step 4: train\n",
    "dnn_classifier.train(\n",
    "    input_fn=train_input_fn,\n",
    "    steps=NUM_EPOCHS * steps_per_epoch)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:absl:Warning: Setting shuffle_files=True because split=TRAIN and shuffle_files=None. This behavior will be deprecated on 2019-08-06, at which point shuffle_files=False will be the default for all splits.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Calling model_fn.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Calling model_fn.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Done calling model_fn.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Done calling model_fn.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Starting evaluation at 2019-10-06T20:09:11Z\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Starting evaluation at 2019-10-06T20:09:11Z\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Graph was finalized.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Graph was finalized.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Restoring parameters from models/mnist-dnn/model.ckpt-18760\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Restoring parameters from models/mnist-dnn/model.ckpt-18760\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Running local_init_op.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Running local_init_op.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Done running local_init_op.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Done running local_init_op.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Finished evaluation at 2019-10-06-20:09:13\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Finished evaluation at 2019-10-06-20:09:13\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Saving dict for global step 18760: accuracy = 0.8957, average_loss = 0.3876346, global_step = 18760, loss = 0.38815108\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Saving dict for global step 18760: accuracy = 0.8957, average_loss = 0.3876346, global_step = 18760, loss = 0.38815108\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Saving 'checkpoint_path' summary for global step 18760: models/mnist-dnn/model.ckpt-18760\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Saving 'checkpoint_path' summary for global step 18760: models/mnist-dnn/model.ckpt-18760\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'accuracy': 0.8957, 'average_loss': 0.3876346, 'loss': 0.38815108, 'global_step': 18760}\n"
     ]
    }
   ],
   "source": [
    "eval_result = dnn_classifier.evaluate(\n",
    "    input_fn=eval_input_fn)\n",
    "\n",
    "print(eval_result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Creating a custom Estimator from an existing Keras model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "## Set random seeds for reproducibility\n",
    "tf.random.set_seed(1)\n",
    "np.random.seed(1)\n",
    "\n",
    "## Create the data\n",
    "x = np.random.uniform(low=-1, high=1, size=(200, 2))\n",
    "y = np.ones(len(x))\n",
    "y[x[:, 0] * x[:, 1]<0] = 0\n",
    "\n",
    "x_train = x[:100, :]\n",
    "y_train = y[:100]\n",
    "x_valid = x[100:, :]\n",
    "y_valid = y[100:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Step 1: Define the input functions\n",
    "def train_input_fn(x_train, y_train, batch_size=8):\n",
    "    dataset = tf.data.Dataset.from_tensor_slices(\n",
    "        ({'input-features':x_train}, y_train.reshape(-1, 1)))\n",
    "\n",
    "    # Shuffle, repeat, and batch the examples.\n",
    "    return dataset.shuffle(100).repeat().batch(batch_size)\n",
    "\n",
    "def eval_input_fn(x_test, y_test=None, batch_size=8):\n",
    "    if y_test is None:\n",
    "        dataset = tf.data.Dataset.from_tensor_slices(\n",
    "            {'input-features':x_test})\n",
    "    else:\n",
    "        dataset = tf.data.Dataset.from_tensor_slices(\n",
    "            ({'input-features':x_test}, y_test.reshape(-1, 1)))\n",
    "\n",
    "\n",
    "    # Shuffle, repeat, and batch the examples.\n",
    "    return dataset.batch(batch_size)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[NumericColumn(key='input-features:', shape=(2,), default_value=None, dtype=tf.float32, normalizer_fn=None)]"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "## Step 2: Define the feature columns\n",
    "features = [\n",
    "    tf.feature_column.numeric_column(\n",
    "        key='input-features:', shape=(2,))\n",
    "]\n",
    "    \n",
    "features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential_1\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "dense_4 (Dense)              (None, 4)                 12        \n",
      "_________________________________________________________________\n",
      "dense_5 (Dense)              (None, 4)                 20        \n",
      "_________________________________________________________________\n",
      "dense_6 (Dense)              (None, 4)                 20        \n",
      "_________________________________________________________________\n",
      "dense_7 (Dense)              (None, 1)                 5         \n",
      "=================================================================\n",
      "Total params: 57\n",
      "Trainable params: 57\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "INFO:tensorflow:Using default config.\n",
      "INFO:tensorflow:Using the Keras model provided.\n",
      "INFO:tensorflow:Using config: {'_model_dir': 'models/estimator-for-XOR/', '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_steps': None, '_save_checkpoints_secs': 600, '_session_config': allow_soft_placement: true\n",
      "graph_options {\n",
      "  rewrite_options {\n",
      "    meta_optimizer_iterations: ONE\n",
      "  }\n",
      "}\n",
      ", '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 100, '_train_distribute': None, '_device_fn': None, '_protocol': None, '_eval_distribute': None, '_experimental_distribute': None, '_experimental_max_worker_delay_secs': None, '_session_creation_timeout_secs': 7200, '_service': None, '_cluster_spec': <tensorflow.python.training.server_lib.ClusterSpec object at 0x7fe1145c5490>, '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1}\n"
     ]
    }
   ],
   "source": [
    "## Step 3: Create the estimator: convert from a Keras model\n",
    "model = tf.keras.Sequential([\n",
    "    tf.keras.layers.Input(shape=(2,), name='input-features'),\n",
    "    tf.keras.layers.Dense(units=4, activation='relu'),\n",
    "    tf.keras.layers.Dense(units=4, activation='relu'),\n",
    "    tf.keras.layers.Dense(units=4, activation='relu'),\n",
    "    tf.keras.layers.Dense(1, activation='sigmoid')\n",
    "])\n",
    "\n",
    "model.summary()\n",
    "\n",
    "model.compile(optimizer=tf.keras.optimizers.SGD(),\n",
    "              loss=tf.keras.losses.BinaryCrossentropy(),\n",
    "              metrics=[tf.keras.metrics.BinaryAccuracy()])\n",
    "\n",
    "my_estimator = tf.keras.estimator.model_to_estimator(\n",
    "    keras_model=model,\n",
    "    model_dir='models/estimator-for-XOR/')\n",
    "\n",
    "#help(tf.keras.estimator.model_to_estimator)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Calling model_fn.\n",
      "INFO:tensorflow:Done calling model_fn.\n",
      "INFO:tensorflow:Warm-starting with WarmStartSettings: WarmStartSettings(ckpt_to_initialize_from='models/estimator-for-XOR/keras/keras_model.ckpt', vars_to_warm_start='.*', var_name_to_vocab_info={}, var_name_to_prev_var_name={})\n",
      "INFO:tensorflow:Warm-starting from: models/estimator-for-XOR/keras/keras_model.ckpt\n",
      "INFO:tensorflow:Warm-starting variables only in TRAINABLE_VARIABLES.\n",
      "INFO:tensorflow:Warm-started 8 variables.\n",
      "INFO:tensorflow:Create CheckpointSaverHook.\n",
      "INFO:tensorflow:Graph was finalized.\n",
      "INFO:tensorflow:Running local_init_op.\n",
      "INFO:tensorflow:Done running local_init_op.\n",
      "INFO:tensorflow:Saving checkpoints for 0 into models/estimator-for-XOR/model.ckpt.\n",
      "INFO:tensorflow:loss = 0.67477477, step = 0\n",
      "INFO:tensorflow:global_step/sec: 574.172\n",
      "INFO:tensorflow:loss = 0.6321867, step = 100 (0.176 sec)\n",
      "INFO:tensorflow:global_step/sec: 798.178\n",
      "INFO:tensorflow:loss = 0.534695, step = 200 (0.125 sec)\n",
      "INFO:tensorflow:global_step/sec: 787.151\n",
      "INFO:tensorflow:loss = 0.68169975, step = 300 (0.127 sec)\n",
      "INFO:tensorflow:global_step/sec: 744.349\n",
      "INFO:tensorflow:loss = 0.3399461, step = 400 (0.134 sec)\n",
      "INFO:tensorflow:global_step/sec: 740.664\n",
      "INFO:tensorflow:loss = 0.34612662, step = 500 (0.135 sec)\n",
      "INFO:tensorflow:global_step/sec: 742.643\n",
      "INFO:tensorflow:loss = 0.5351488, step = 600 (0.135 sec)\n",
      "INFO:tensorflow:global_step/sec: 760.274\n",
      "INFO:tensorflow:loss = 0.5951747, step = 700 (0.132 sec)\n",
      "INFO:tensorflow:global_step/sec: 758.965\n",
      "INFO:tensorflow:loss = 0.3279724, step = 800 (0.132 sec)\n",
      "INFO:tensorflow:global_step/sec: 755.136\n",
      "INFO:tensorflow:loss = 0.3465306, step = 900 (0.133 sec)\n",
      "INFO:tensorflow:global_step/sec: 721.75\n",
      "INFO:tensorflow:loss = 0.47171068, step = 1000 (0.139 sec)\n",
      "INFO:tensorflow:global_step/sec: 776.736\n",
      "INFO:tensorflow:loss = 0.4781041, step = 1100 (0.129 sec)\n",
      "INFO:tensorflow:global_step/sec: 789.161\n",
      "INFO:tensorflow:loss = 0.5628091, step = 1200 (0.127 sec)\n",
      "INFO:tensorflow:global_step/sec: 759.355\n",
      "INFO:tensorflow:loss = 0.18982677, step = 1300 (0.132 sec)\n",
      "INFO:tensorflow:global_step/sec: 782.603\n",
      "INFO:tensorflow:loss = 0.30944666, step = 1400 (0.128 sec)\n",
      "INFO:tensorflow:global_step/sec: 780.022\n",
      "INFO:tensorflow:loss = 0.5283603, step = 1500 (0.128 sec)\n",
      "INFO:tensorflow:global_step/sec: 768.739\n",
      "INFO:tensorflow:loss = 0.09619397, step = 1600 (0.130 sec)\n",
      "INFO:tensorflow:global_step/sec: 774.064\n",
      "INFO:tensorflow:loss = 0.25747803, step = 1700 (0.129 sec)\n",
      "INFO:tensorflow:global_step/sec: 770.068\n",
      "INFO:tensorflow:loss = 0.11317325, step = 1800 (0.130 sec)\n",
      "INFO:tensorflow:global_step/sec: 778.389\n",
      "INFO:tensorflow:loss = 0.15888521, step = 1900 (0.128 sec)\n",
      "INFO:tensorflow:global_step/sec: 791.814\n",
      "INFO:tensorflow:loss = 0.29326433, step = 2000 (0.126 sec)\n",
      "INFO:tensorflow:global_step/sec: 828.68\n",
      "INFO:tensorflow:loss = 0.4962164, step = 2100 (0.121 sec)\n",
      "INFO:tensorflow:global_step/sec: 827.592\n",
      "INFO:tensorflow:loss = 0.07616831, step = 2200 (0.121 sec)\n",
      "INFO:tensorflow:global_step/sec: 810.752\n",
      "INFO:tensorflow:loss = 0.09109494, step = 2300 (0.123 sec)\n",
      "INFO:tensorflow:global_step/sec: 762.748\n",
      "INFO:tensorflow:loss = 0.17533378, step = 2400 (0.131 sec)\n",
      "INFO:tensorflow:global_step/sec: 767.635\n",
      "INFO:tensorflow:loss = 0.2621813, step = 2500 (0.130 sec)\n",
      "INFO:tensorflow:global_step/sec: 796.129\n",
      "INFO:tensorflow:loss = 0.25053543, step = 2600 (0.126 sec)\n",
      "INFO:tensorflow:global_step/sec: 777.264\n",
      "INFO:tensorflow:loss = 6.320847e-05, step = 2700 (0.129 sec)\n",
      "INFO:tensorflow:global_step/sec: 779.224\n",
      "INFO:tensorflow:loss = 0.051956728, step = 2800 (0.128 sec)\n",
      "INFO:tensorflow:global_step/sec: 836.752\n",
      "INFO:tensorflow:loss = 0.04556096, step = 2900 (0.120 sec)\n",
      "INFO:tensorflow:global_step/sec: 812.958\n",
      "INFO:tensorflow:loss = 0.054016236, step = 3000 (0.123 sec)\n",
      "INFO:tensorflow:global_step/sec: 831.439\n",
      "INFO:tensorflow:loss = 0.10925404, step = 3100 (0.120 sec)\n",
      "INFO:tensorflow:global_step/sec: 808.99\n",
      "INFO:tensorflow:loss = 0.00033308862, step = 3200 (0.124 sec)\n",
      "INFO:tensorflow:global_step/sec: 800.347\n",
      "INFO:tensorflow:loss = 1.492853e-05, step = 3300 (0.125 sec)\n",
      "INFO:tensorflow:global_step/sec: 804.795\n",
      "INFO:tensorflow:loss = 0.014800702, step = 3400 (0.124 sec)\n",
      "INFO:tensorflow:global_step/sec: 815.792\n",
      "INFO:tensorflow:loss = 0.031656396, step = 3500 (0.123 sec)\n",
      "INFO:tensorflow:global_step/sec: 838.497\n",
      "INFO:tensorflow:loss = 0.0056599732, step = 3600 (0.119 sec)\n",
      "INFO:tensorflow:global_step/sec: 815.693\n",
      "INFO:tensorflow:loss = 0.058009762, step = 3700 (0.123 sec)\n",
      "INFO:tensorflow:global_step/sec: 813.719\n",
      "INFO:tensorflow:loss = 0.113356866, step = 3800 (0.123 sec)\n",
      "INFO:tensorflow:global_step/sec: 823.145\n",
      "INFO:tensorflow:loss = 0.008040999, step = 3900 (0.122 sec)\n",
      "INFO:tensorflow:global_step/sec: 807.229\n",
      "INFO:tensorflow:loss = 0.025541877, step = 4000 (0.124 sec)\n",
      "INFO:tensorflow:global_step/sec: 773.022\n",
      "INFO:tensorflow:loss = 0.0064005647, step = 4100 (0.129 sec)\n",
      "INFO:tensorflow:global_step/sec: 802.403\n",
      "INFO:tensorflow:loss = 0.064237915, step = 4200 (0.125 sec)\n",
      "INFO:tensorflow:global_step/sec: 801.679\n",
      "INFO:tensorflow:loss = 0.004642074, step = 4300 (0.125 sec)\n",
      "INFO:tensorflow:global_step/sec: 779.961\n",
      "INFO:tensorflow:loss = 0.0012563752, step = 4400 (0.128 sec)\n",
      "INFO:tensorflow:global_step/sec: 787.182\n",
      "INFO:tensorflow:loss = 1.6980503e-05, step = 4500 (0.127 sec)\n",
      "INFO:tensorflow:global_step/sec: 784.774\n",
      "INFO:tensorflow:loss = 0.023048583, step = 4600 (0.127 sec)\n",
      "INFO:tensorflow:global_step/sec: 794.629\n",
      "INFO:tensorflow:loss = 0.0041898433, step = 4700 (0.126 sec)\n",
      "INFO:tensorflow:global_step/sec: 768.154\n",
      "INFO:tensorflow:loss = 0.05029011, step = 4800 (0.130 sec)\n",
      "INFO:tensorflow:global_step/sec: 749.79\n",
      "INFO:tensorflow:loss = 0.04048004, step = 4900 (0.133 sec)\n",
      "INFO:tensorflow:global_step/sec: 751.737\n",
      "INFO:tensorflow:loss = 0.02229347, step = 5000 (0.133 sec)\n",
      "INFO:tensorflow:global_step/sec: 768.048\n",
      "INFO:tensorflow:loss = 0.0055005806, step = 5100 (0.130 sec)\n",
      "INFO:tensorflow:global_step/sec: 728.385\n",
      "INFO:tensorflow:loss = 7.945169e-05, step = 5200 (0.137 sec)\n",
      "INFO:tensorflow:global_step/sec: 690.054\n",
      "INFO:tensorflow:loss = 0.075152755, step = 5300 (0.145 sec)\n",
      "INFO:tensorflow:global_step/sec: 694.668\n",
      "INFO:tensorflow:loss = 0.0013963212, step = 5400 (0.144 sec)\n",
      "INFO:tensorflow:global_step/sec: 808.131\n",
      "INFO:tensorflow:loss = 0.003022093, step = 5500 (0.124 sec)\n",
      "INFO:tensorflow:global_step/sec: 814.838\n",
      "INFO:tensorflow:loss = 0.014565887, step = 5600 (0.123 sec)\n",
      "INFO:tensorflow:global_step/sec: 789.301\n",
      "INFO:tensorflow:loss = 0.014141492, step = 5700 (0.127 sec)\n",
      "INFO:tensorflow:global_step/sec: 781.824\n",
      "INFO:tensorflow:loss = 0.0025591291, step = 5800 (0.128 sec)\n",
      "INFO:tensorflow:global_step/sec: 843.941\n",
      "INFO:tensorflow:loss = 0.023362594, step = 5900 (0.118 sec)\n",
      "INFO:tensorflow:global_step/sec: 871.435\n",
      "INFO:tensorflow:loss = 0.015386263, step = 6000 (0.115 sec)\n",
      "INFO:tensorflow:global_step/sec: 785.155\n",
      "INFO:tensorflow:loss = 7.1655855e-08, step = 6100 (0.127 sec)\n",
      "INFO:tensorflow:global_step/sec: 829.173\n",
      "INFO:tensorflow:loss = 0.012131969, step = 6200 (0.121 sec)\n",
      "INFO:tensorflow:global_step/sec: 846.307\n",
      "INFO:tensorflow:loss = 0.027618604, step = 6300 (0.118 sec)\n",
      "INFO:tensorflow:global_step/sec: 829.765\n",
      "INFO:tensorflow:loss = 0.0269943, step = 6400 (0.120 sec)\n",
      "INFO:tensorflow:global_step/sec: 773.718\n",
      "INFO:tensorflow:loss = 0.0027163997, step = 6500 (0.129 sec)\n",
      "INFO:tensorflow:global_step/sec: 814.246\n",
      "INFO:tensorflow:loss = 0.080381945, step = 6600 (0.123 sec)\n",
      "INFO:tensorflow:global_step/sec: 810.719\n",
      "INFO:tensorflow:loss = 0.010852154, step = 6700 (0.123 sec)\n",
      "INFO:tensorflow:global_step/sec: 811.726\n",
      "INFO:tensorflow:loss = 1.708062e-08, step = 6800 (0.123 sec)\n",
      "INFO:tensorflow:global_step/sec: 821.314\n",
      "INFO:tensorflow:loss = 6.749074e-06, step = 6900 (0.122 sec)\n",
      "INFO:tensorflow:global_step/sec: 781.595\n",
      "INFO:tensorflow:loss = 0.021214139, step = 7000 (0.128 sec)\n",
      "INFO:tensorflow:global_step/sec: 794.561\n",
      "INFO:tensorflow:loss = 0.021281583, step = 7100 (0.126 sec)\n",
      "INFO:tensorflow:global_step/sec: 782.203\n",
      "INFO:tensorflow:loss = 0.07172878, step = 7200 (0.128 sec)\n",
      "INFO:tensorflow:global_step/sec: 784.871\n",
      "INFO:tensorflow:loss = 0.073791675, step = 7300 (0.128 sec)\n",
      "INFO:tensorflow:global_step/sec: 764.855\n",
      "INFO:tensorflow:loss = 0.002004325, step = 7400 (0.131 sec)\n",
      "INFO:tensorflow:global_step/sec: 791.502\n",
      "INFO:tensorflow:loss = 0.004043079, step = 7500 (0.126 sec)\n",
      "INFO:tensorflow:global_step/sec: 836.65\n",
      "INFO:tensorflow:loss = 0.027419746, step = 7600 (0.119 sec)\n",
      "INFO:tensorflow:global_step/sec: 852.347\n",
      "INFO:tensorflow:loss = 0.019583877, step = 7700 (0.117 sec)\n",
      "INFO:tensorflow:global_step/sec: 854.007\n",
      "INFO:tensorflow:loss = 0.0009029062, step = 7800 (0.117 sec)\n",
      "INFO:tensorflow:global_step/sec: 837.487\n",
      "INFO:tensorflow:loss = 5.2825213e-11, step = 7900 (0.119 sec)\n",
      "INFO:tensorflow:global_step/sec: 856.328\n",
      "INFO:tensorflow:loss = 0.010316769, step = 8000 (0.117 sec)\n",
      "INFO:tensorflow:global_step/sec: 836.253\n",
      "INFO:tensorflow:loss = 0.0013620084, step = 8100 (0.120 sec)\n",
      "INFO:tensorflow:global_step/sec: 839.269\n",
      "INFO:tensorflow:loss = 0.008181376, step = 8200 (0.119 sec)\n",
      "INFO:tensorflow:global_step/sec: 809.317\n",
      "INFO:tensorflow:loss = 0.033164613, step = 8300 (0.123 sec)\n",
      "INFO:tensorflow:global_step/sec: 799.395\n",
      "INFO:tensorflow:loss = 1.0116619, step = 8400 (0.125 sec)\n",
      "INFO:tensorflow:global_step/sec: 789.458\n",
      "INFO:tensorflow:loss = 0.37799022, step = 8500 (0.127 sec)\n",
      "INFO:tensorflow:global_step/sec: 804.451\n",
      "INFO:tensorflow:loss = 0.0018210857, step = 8600 (0.124 sec)\n",
      "INFO:tensorflow:global_step/sec: 769.172\n",
      "INFO:tensorflow:loss = 0.00077041663, step = 8700 (0.130 sec)\n",
      "INFO:tensorflow:global_step/sec: 790.124\n",
      "INFO:tensorflow:loss = 1.1200687e-05, step = 8800 (0.127 sec)\n",
      "INFO:tensorflow:global_step/sec: 810.337\n",
      "INFO:tensorflow:loss = 0.0015405031, step = 8900 (0.123 sec)\n",
      "INFO:tensorflow:global_step/sec: 811.975\n",
      "INFO:tensorflow:loss = 0.0018443201, step = 9000 (0.123 sec)\n",
      "INFO:tensorflow:global_step/sec: 847.237\n",
      "INFO:tensorflow:loss = 0.0039219605, step = 9100 (0.118 sec)\n",
      "INFO:tensorflow:global_step/sec: 750.282\n",
      "INFO:tensorflow:loss = 0.012582438, step = 9200 (0.133 sec)\n",
      "INFO:tensorflow:global_step/sec: 774.686\n",
      "INFO:tensorflow:loss = 3.4304968e-09, step = 9300 (0.129 sec)\n",
      "INFO:tensorflow:global_step/sec: 790.759\n",
      "INFO:tensorflow:loss = 0.0017814172, step = 9400 (0.127 sec)\n",
      "INFO:tensorflow:global_step/sec: 816.71\n",
      "INFO:tensorflow:loss = 0.014989376, step = 9500 (0.122 sec)\n",
      "INFO:tensorflow:global_step/sec: 811.376\n",
      "INFO:tensorflow:loss = 0.0004930453, step = 9600 (0.123 sec)\n",
      "INFO:tensorflow:global_step/sec: 798.564\n",
      "INFO:tensorflow:loss = 0.007868855, step = 9700 (0.125 sec)\n",
      "INFO:tensorflow:global_step/sec: 799.509\n",
      "INFO:tensorflow:loss = 8.356229e-07, step = 9800 (0.125 sec)\n",
      "INFO:tensorflow:global_step/sec: 781.742\n",
      "INFO:tensorflow:loss = 0.00047293206, step = 9900 (0.128 sec)\n",
      "INFO:tensorflow:Saving checkpoints for 10000 into models/estimator-for-XOR/model.ckpt.\n",
      "INFO:tensorflow:Loss for final step: 0.006963645.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<tensorflow_estimator.python.estimator.estimator.EstimatorV2 at 0x7fe11c596710>"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "## Step 4: use the estimator: train/evaluate/predict\n",
    "\n",
    "num_epochs = 200\n",
    "batch_size = 2\n",
    "steps_per_epoch = np.ceil(len(x_train) / batch_size)\n",
    "\n",
    "my_estimator.train(\n",
    "    input_fn=lambda: train_input_fn(x_train, y_train, batch_size),\n",
    "    steps=num_epochs * steps_per_epoch)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Calling model_fn.\n",
      "INFO:tensorflow:Done calling model_fn.\n",
      "INFO:tensorflow:Starting evaluation at 2019-10-06T20:23:58Z\n",
      "INFO:tensorflow:Graph was finalized.\n",
      "INFO:tensorflow:Restoring parameters from models/estimator-for-XOR/model.ckpt-10000\n",
      "INFO:tensorflow:Running local_init_op.\n",
      "INFO:tensorflow:Done running local_init_op.\n",
      "INFO:tensorflow:Finished evaluation at 2019-10-06-20:23:58\n",
      "INFO:tensorflow:Saving dict for global step 10000: binary_accuracy = 0.94, global_step = 10000, loss = 0.08391656\n",
      "INFO:tensorflow:Saving 'checkpoint_path' summary for global step 10000: models/estimator-for-XOR/model.ckpt-10000\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'binary_accuracy': 0.94, 'loss': 0.08391656, 'global_step': 10000}"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_estimator.evaluate(\n",
    "    input_fn=lambda: eval_input_fn(x_valid, y_valid, batch_size))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Summary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "Readers may ignore the next cell."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[NbConvertApp] Converting notebook ch12.ipynb to script\n",
      "[NbConvertApp] Writing 19212 bytes to ch12.py\n"
     ]
    }
   ],
   "source": [
    "! python ../.convert_notebook_to_script.py --input ch14.ipynb --output ch14.py"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}