diff --git a/ch13/ch13-notebook.ipynb b/ch13/ch13-notebook.ipynb
index a65ec96b..c3b6bbaf 100644
--- a/ch13/ch13-notebook.ipynb
+++ b/ch13/ch13-notebook.ipynb
@@ -3257,6 +3257,27 @@
     "<br>"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "..."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Summary"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "..."
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -3268,9 +3289,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 28,
    "metadata": {},
-   "outputs": [],
+   "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 ch13.ipynb --output ch13.py"
    ]
diff --git a/ch14/ch14-notebook.ipynb b/ch14/ch14-notebook.ipynb
new file mode 100644
index 00000000..bf5dceba
--- /dev/null
+++ b/ch14/ch14-notebook.ipynb
@@ -0,0 +1,9993 @@
+{
+ "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": "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": "markdown",
+   "metadata": {},
+   "source": [
+    "### Migrating from TF version 1"
+   ]
+  },
+  {
+   "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": "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": "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": "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": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "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": [
+    "## Variables"
+   ]
+  },
+  {
+   "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\n",
+    "\n",
+    "### GradientTape"
+   ]
+  },
+  {
+   "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": [
+    "### Gradients of non-variables: `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": [
+    "### Multiple gradients in one forward call `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": [
+    "## Keras API"
+   ]
+  },
+  {
+   "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": [
+    "## XOR-example"
+   ]
+  },
+  {
+   "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": "iVBORw0KGgoAAAANSUhEUgAAA7AAAAEUCAYAAAASr9oTAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nOzdd3hUxfrA8e9k03tCGgmEjvQmohRBRJqCKAqCXkWuiKjY21X5IaKoVywoKIiI5YoiCAIqiqhYkS4tSBMQSCC9kr6Z3x+bhGxJskk22SS8n+fhuTlz5pwzy5Uk75mZ91Vaa4QQQgghhBBCiPrOxdkDEEIIIYQQQggh7CEBrBBCCCGEEEKIBkECWCGEEEIIIYQQDYIEsEIIIYQQQgghGgQJYIUQQgghhBBCNAgSwAohhBBCCCGEaBAkgBVCCCGEEEII0SBIACuEEEIIIYQQokGQAFYIIYQQQlhRSl2vlLpfKXWRRft0Z41JCCEkgBVCCCGEEGaUUi8BDwBtgY1KqQfLnP63c0YlhBCgtNbOHoMQQgghhKhHlFL7gJ5a60KlVBNgJbBTa/2YUupPrXVPJw9RCHGBkhlYIYQQQghhyUVrXQigtU4GRgAtlVLvIb8/CiGcSL4BCSGEEEIIS2eUUr1KDrTW+cBNgAa6OG1UQogLniwhFkIIIYQQZpRSzYBCrfVZG+f6aa03O2FYQghR/wLYkJAQ3bJlS2cPQwhRz+zcuTNJax3q7HE4kny/E0JYcub3OqXUPOAh7eBfDjcdTKhfv2wKUU1xp04QFPsrV/fr6uyhNHzth6nqXupqTyel1AjgDcAALNFav2RxPhr4EAgs7vMfrfV6pdRQ4CXAHcgHHtNa/1jRs1q2bMmOHTuq/EGEEI2bUuofZ4/B0eT7nRDCkpO/100EWimlJmqtsy1PKqVGaq2/qepNjyZkOWRwQjhTYUE+v707h/fvvQKSDjl7OA1f+2HVvrTSPbBKKQPwFjAS6ARMVEp1sug2A1hRnJFuAvB2cXsSMFpr3RWYBPyv2iMVQgghhBC16TJMZXN+VUo1LWlUSg1XSm0BvnLayIRwsi2fvcGzN3bH3c2u+T9Ri+xJ4tQHOKq1Pla8gX85MMaijwb8i78OAOIAtNZ/aq3jittjAC+llEfNhy2EEEIIIRxJa30c6IdpAmKbUurfSqnfgW+ADOAKJw5PCKc5snUjw6KLaNusUe1karDsCWCjgFNljk8Xt5U1C/iXUuo0sB64z8Z9bgB2aa3zLE8opaYqpXYopXYkJibaNXAhhBBCCOFYWut04BUgCHgX8AL6aq2Haa1/derghHCC1MSzFBzYwC1XSvLt+sJRc+ATgQ+01q8qpfoC/1NKddFaFwEopToD/wVsLnbWWi8GFgP07t1bNvoLIYQQQtSx4pwnT2Oahf0BOAr8G9Oy4q1OHJoQTlFkNLJr+VyW3j3A2UOxqQjFOUMwRldPoNo5kWqRxlCYi48xBRccF+LZE8DGAs3LHDcrbivrDkwFrtFa/6GU8gRCgITiNOxfALdprf+u+ZCFEEIIIUQtWA9sAgZprX8DUErtBt5XSrXXWj/j1NEJUce2rXqbp8d0wtvT3dlDsemcIRg330B8lRFVD+NXrSFPe3IuC/yMyQ67rz1LiLcD7ZRSrZRS7piSNK2z6HMSGAKglOoIeAKJSqlA4GtMWYl/d9iohRBCCCGEo12htR5SErxC6Sq5a4D7lVKfOm9oQtSt43s20ycona6tI5w9lHIZXT3xqKfBK4BS4KGMxTPEjlPpDKzWulApNR3YgKlEzlKtdYxSajawQ2u9DngEeFcp9RCmhE63a6118XVtgZlKqZnFtxymtU6o6cAX/vQ3f55MJSEzj8TMPBbc3JOe0UE1ve0FKSMjg4SEBAoKCpw9FHGBcnNzIywsDH9//8o7C3Ghyj8Hm16AuD9Nr7VdDBDcGgpyIP20457jFQj+kZD6j+mZYDoe/BSc3Qt/LjvfLuw3eh6EXuTsUVRIa/1LOe0blVIDgC/reEhCOEVmWgopW1cy5+4hzh5KJVS9DV5LmMbn2EHatQdWa70e07KSsm0zy3x9AOhv47rngedrOEabdpxI4YeD5+Pgs+m5tfGYRi8jI4P4+HiioqLw8vJC1fd/BaLR0VqTk5NDbKxpZ4IEsUKU48c5sOUt87YTdZhTZ//ndfesxii/YddCLZ68uNTZ4xCithUVFbF92Uu8M6W//F5cT9mzhLheCvM3r8aTmGWV3FjYISEhgaioKLy9veUfqXAKpRTe3t5ERUWRkFDjxRlCNF5HvnP2CMQFTmstpSJEo7dz3VIeHNYGfx8vZw+lwfj2151cdPXdtB0+lZferf2XnQ02gA31NQ9gEzIkgK2OgoICvLzkH6hwPi8vL1nGLkR58rIg+aizRyGEEI3aqYO76GA4xaUdmzl7KA2G0Wjk3uff4Zt3nuHAl2/x6fpfOHD0ZK0+01FldOpcqL/5ZuDETAlgq0tmXkV9IP8dClGB+P1QWQmCtkNhwEPVf8bxX+Dnl+zvP+p1CKnfezrrlZD2zh6BEKIC2VmZxG76iGenX+XsodSKPv96mqT0HKv2kAAvtn08p9r33bbvCG2jm9K6uSnZ1YSRl7P2x610ahtd7XtWpuEGsJYzsJmyB1YIUTPFNRDfwJSwbonW+iWL868Dg4sPvYEwrXVg8blJwIzic89rrT+sm1GLC8KZPZX3aX0FtLRKR2E/7+AqBLAKuo4DD7/qP08IIeoJrTVbl/2XN2/t22hfqCel59D5rtet2mPeqcGLTyA2PpnmESGlx80iQti691CN7lmZBhvAyh5YAfbN2m3atIkrrriiRs+JiIhgypQpPP98zXKSffvtt4wcOZIjR47Qtm3bGt1LOJZSygC8BQwFTgPblVLripPUAaC1fqhM//uAnsVfBwPPAL0xTZPtLL42tQ4/gqhPzu6HfSsdl6335B+V92narWbPaNKuCn3bSvAqhGg09mz4hDv7NyUk0NfZQxF2aLABrOyBFQB//HH+l7qcnByuvPJKZsyYwTXXXFPa3qlTpxo/Z/369YSFhdX4PqJe6wMc1VofA1BKLQfGAAfK6T8RU9AKMBzYqLVOKb52IzACkJqJF6LMs/DeUCjIrr1ndLoODqwxb4uoYQBrsPErQUntvkKLVU5Nu9fsWUIIUU+cOX6QplkHGNyjn7OH0iBFhTfh1Nmk0uPTZ5OICmtSq89suAGsn3kAm3wuH2ORxuDSOKf9hW2XXXZZ6ddZWaYSBW3atDFrL09ubi6envYVVu7Vq1f1BigakijgVJnj04DNkhFKqRZAK+DHCq6NKufaqcBUgOjo2tsfIpzo0De1G7wC9JlqHsD6NTXVb62pXpNgV5nV74Meh4PrIXaHeT8JYIUQjUBebg5Hv17E+/fV93qv9dclXdpx5J84jp8+S1RYE5Z/8yufvPxorT6zwWYh9nQz4O95Pv42FmlSzuU7cUSiPlu0aBFKKXbt2sXll1+Ol5cX8+fPR2vNI488QpcuXfDx8aF58+ZMmjSJxETzSgERERHMmDGj9HjChAkMGDCA9evX07lzZ3x9fRk0aBCHDlV9zX9WVhb33HMPYWFheHp6cumll7Jp0yazPj/99BP9+vXDz8+PgIAAevXqxdq1a0vPr1q1ip49e+Lt7U1wcDB9+/Zl8+bNVR6LsNsE4HOttbGqF2qtF2ute2ute4eGhtbC0ITT2bNftSa6joMW/aDVwPNt/R90zL373AmG4hfEnoHQ81a45A7zPp6B0OUGxzxPCCGcaMuyV3jplj4YDA02JHI6V1cDC56+i+F3zqLj6HsZP3wAndvV7gv6BjsDCxDm70lG7vnC4ImZeVYzs0KUddNNN3Hvvfcye/ZsgoODKSoqIiUlhRkzZtC0aVPi4+OZO3cuQ4cO5c8//6xwj+3Ro0eZMWMGs2bNws3NjYcffpibb76ZnTt3VmlMkyZN4vvvv+ell16iRYsWLFy4kOHDh/Pbb7/Rp08fkpOTGT16NDfddBOzZ8/GaDSyd+9eUlNN2ysPHDjAhAkTeOyxx3jttdfIzs5mx44dpeeF3WKB5mWOmxW32TIBuNfi2issrv3JgWMTDYllAHvpNAhu45h7+zeF9iNBKbhlFRzZAD6hEF35qhO7RHSFe7dA7C5TgOwbBj1uNu2PPbMbXD2gzZUQYHOBgRBCNBgxP63hpu5+RIYGOHsodSIkwMtmwqaQgJqX07x6UG+uHtS7xvexV4MOYEN9PTiacD6ATcjMpRP+ThxRw9fyP187ewgAnHjpmso7VcOjjz7KXXfdZdb2/vvvl35tNBq5+OKLadu2Ldu3b6dPnz7l3islJYWtW7fSokULwLQkeeLEiZw4cYKWLVvaNZ7du3ezevVqli9fzk033QTA8OHD6dChA3PmzGHt2rX89ddfnDt3jrfeegsPD4/SPiV27dpFWFgYL7zwQmlb2T3Awm7bgXZKqVaYAtIJwM2WnZRSHYAgoGxWnQ3AC0qpoOLjYcCTtTtcUS8ZCyA+xrzt8kdMgaCjubpDx9GOv29wa9OfsppfYvojhBCNQOLp43jH/sHoSQMr79xI1KRUTn3ToAPYCD8DTUkmTKXyt46UWrCiUrYCu3Xr1vHCCy/w119/kZGRUdp++PDhCgPY9u3blwavcD5Z1OnTp+0OYLdt24bBYGDs2LGlbQaDgRtvvJHFixeXPsfT05MJEybw73//m4EDBxIQcP5tYbdu3Thz5gxTpkxhwoQJ9OvXD29vb7ueL87TWhcqpaZjCkYNwFKtdYxSajawQ2u9rrjrBGC51lqXuTZFKfUcpiAYYHZJQidRT2gNx36C1ONVu86vqam+akmCI63hxG9QmAdNWsM/m8FYZvvKuSQwlvlZ5BtRO8GrEEKIainIzyNmzZu8f+8Vzh6KqKaGG8AuG89rR75DeZp+h5yY/zQJmT2dPChR34WHh5sd//7771x//fVMmDCBp59+mtDQUAoKChg4cCC5uRXXFg4MNE+Y4u7uDlDpdWWdOXOGoKAg3NzcrMZZsgQ4LCyMDRs2MHv2bG64wbTvbMSIEcyfP58WLVrQrVs3Vq9ezdy5cxk+fDgeHh7ceOONzJs3j+DgYLvHIkBrvR5Yb9E20+J4VjnXLgWW1trgRM38MBt+e61613YdBzcsMX29aQ78Mtf+ayXZkRBC1CtbP5vHc+N74u7WcMOgC13D3bHs5omidAKEUNJkBlZUynJP66pVq4iOjmbZsmWMHj2ayy67rE7L5TRt2pTU1FQKCgrM2uPj4wkKCio9vvzyy9m4cSOpqamsWLGCffv2MWnSpNLz1113Hb///jvJycm88847fP311zz88MN19jmEqNeKimD7kupfv28lnEuGIiNsnl+1a2tam1UIIYTDHPpjAyNbKVpH1m6ZF1G7Gu6rB7+mZofhKpW4LAlga6q29p7WVzk5OaUzpyWWLVtWZ8/v06cPRqORL774gvHjxwOmfbirVq1iwIABVv19fHy47rrr+PPPP1m4cKHV+cDAQG699Va+//57Dhwor3ypEBeYlGOQl1F5v4qc3QP+zazroVZEuUCnMTV7rhB1SCm1FBgFJGitu9g4fwWwFihZi79aaz277kYoRPWlJpyh6NBGJkwZ7OyhiBpquAGsr/lS0HCVyp4MCWBF1QwdOpRFixbx2GOPMWLECH755ReWL19eZ8/v0aMHY8eO5a677iIlJaU0C/GJEydKA+mSJE9jxoyhWbNmnDp1iqVLl3LllVcC8Oabb7Jnzx6GDRtGREQEhw4dYs2aNdx999119jmEqNfO7DY/Dow2ZdKtyKntkFAmGdOZPaZZ2PJ0v9mUVKmEq5cpwVJE16qPVwjn+QBYAHxUQZ9ftdaj6mY4QjiGsbCQPz+by9J7Lnf2UIQDNNwA1sYMbKLMwIoqGjt2LM899xxvv/02b7/9Npdffjlr1qyhc+fOdTaGDz/8kMcee4z/+7//IzMzk+7du/Ptt99yySWmjJ/t27ensLCQJ554gsTERMLCwrj22mtLsw736NGDb775hgcffJDU1FQiIyOZPn06s2bNqrPPIES9ZlnWpvP1MLSSSaNt78L6MoXYz+w1JWiyxTMQrnvbVNpGiAZMa/2LUqqls8chhKNtW/UWM67vgpeHe+WdRZX8++k3+OrnHYQFB7B/3YI6eWYDDmAjzA7DVBoJGVVY2iUaHV9fX8okhjUzbdo0pk2bZvPcjBkzmDFjhlmb5X3Onj1rdmxrlrZDhw7lPr/EiBEjrPr4+vqycOFCm0uCAbp06cLq1avLvefAgQMZOPDCSQMvRJUUFcEei3+v9iRWsuwTuwPSQsvvK8GruHD0VUrtAeKAR7XWMZVdIIQzHfvzV/oFZ9K5ZVtnD6VRuv36IUy/ZRS3/ef1Ontmw03iZDEDG0Yq5/KNnMsrdNKAhBBC1CuF+fDB1XAuwbw9wo4ANryzaQ9ribSTELvTdl/LmqlCNF67gBZa6+7AfGBNeR2VUlOVUjuUUjt+WfdpnQ1QiLIyUpNI376aO0b0cPZQ6o2k1AxumD6b5LQa5oYoNrB3F4IDfB1yL3s14ADWfAY2XKUBWjIRCyGEMDnxC5z8w7zN3de+gNPdB0La2/ec8LrbciCEM2mtM7TWWcVfrwfclFIh5fRdrLXurbXuPfDaiXU6TiEAioqK2PHJy/x30gCrKhQXso9WbyA19igfrtrg7KFUm10BrFJqhFLqkFLqqFLqPzbORyulNiml/lRK7VVKXV3m3JPF1x1SSg132Mg9A8DVs/TQW+XhR47sgxVCCGGSfMy6rc2V4GLnu9u2V1Xex9ULOl1XtXEJ0UAppSJUcSSglOqD6ffICrKbCeE8O9Yu4eERbfHz8ay88wUiKTWDrzZuYuHYcL7auMlhs7B1rdI9sEopA/AWMBQ4DWxXSq3TWpet0TEDWKG1XqiU6gSsB1oWfz0B6AxEAt8rpdprrY01HrlSplnY1BOlTWEqlQTJRCyEEAIg66x126gq7NEZ/BToItPSYV10vj0w2vQCNScNLp0KvuXsjRWigVFKfQpcAYQopU4DzwBuAFrrRcCNwN1KqUIgB5igK0v+IIQTnPxrJ13dz3DJRb2dPZR65aPVGxjVRnFRuCej2mTz4aoNPHzHOGcPq8rsSeLUBziqtT4GoJRaDowBygawGvAv/joA08Z+ivst11rnAceVUkeL72expqua/JpaBLBpJGZKIichhBBAVrz58TWvgo/N1Y62ufvAiBcdOyYh6jGtdYVrfbXWCzCV2RGi3srOzODMTx8ze/oQZw+lXimZfV0xPgCA2y72Z/yKTUy6YThNAv0rubp+sWcdVRRwqszx6eK2smYB/yp+W7ceuK8K11af5T5YUkmQPbBCCCEAMi0CWN8I2/0cRGvNubxCzuUVkldovdAoO992e0OXnW/6zLkFje+zCSEaFq01Wz5+iZcn9ZV9rxZKZl9DfE3zlyG+roxqo2q8F3bio3PpO/FxDp2Ipdngyby36jtHDLdCjiqjMxH4QGv9qlKqL/A/pVQXey9WSk0FpgJER0fb/1Rfy0ROqZLESQghhInlEmK/2gtgfz2SyMMr9pT+DHJRMLRTOG9M6MmZ9Fzu+t8ODsdnYXBRGIs07q4uRAZ4Mn9iL7o2C7B5T601z6yLYfn2U3SNCmDhLb0I87fey3U86Rx3f7yTkynZTBvUhvuHtKuVz6i1ZubaGFbsOEX3ZoE8Mqw9T6/Zz9GErNI+PaMDeedfF9scpyP8fDiRx1buoUhrXri+K8M6m/4//elQAo9/vtfudiFE47T7m4+ZNiiKYH8fZw+l3vlp2x7izuTxyb4zZu2RSXtqtIz401ceq+nQqsyeADYWaF7muFlxW1l3ACMAtNZ/KKU8gRA7r0VrvRhYDNC7d2/791JYZSJO5aAEsEIIIcDGDGx4rT1q9pcHzF6gFmnYEBPP+n1n+O1IEofjTUGescj0Iy6/sIgTydnMWX+A5VP72rznH8eS+eiPfwDY+U8q728+wRMjOlj1e/W7Qxw8mwnAaxsPM7ZXFM2CvB36+QC2HU/hf1tM49l2IoWbFm+x6vPnyTSW/Hacp67u6PDnAzy7LqZ0pdXMtTFc1TEcFxfFrHLan/3ygM12IUTjE3fsAM1yDjOo22XOHkq9tO6d5509BIexZwnxdqCdUqqVUsodU1KmdRZ9TgJDAJRSHQFPILG43wSllIdSqhXQDtjmqMFb1YJVabKEWAghBBgL4VyieZtvWK097kTyOZvt20+klnsOYMuxFPILi2yem7fxiNnxwp/+ttnvq73mb9O3HkupaKjV9uaPRyrvBGw/UTvPLzAWcSzp/N/l2Yxcks/lcy6vkBPJ2WbtKdn55BcWcdyif0p2fq2MTQjhXHk52Rxbv5gnbuzj7KGIOlBpAKu1LgSmAxuAvzBlG45RSs1WSl1b3O0R4E6l1B7gU+B2bRIDrMCU8Olb4F6HZCAuYTEDa8pCLEmchBDigncuEVN+wWJeQeDqUSuPyi8sosBoe/FQTFw6OQW2A9QSRxIybbaXDdbKY+tnnodb7ZR4z8gptKvfX2cySmeaHSk9p8CqLTEzz+bWocTMvHL7CyEanz+Wvcx/b70Ug6F2vv/VX5r6ngfcND7HDtKu/5e11uu11u211m201nOK22ZqrdcVf31Aa91fa91da91Da/1dmWvnFF93kdb6G4eO3mIGNpxUks/ll/s2WzQ+o0ePpmvXruWenz59OoGBgeTl2fdLy9GjR1FK8e2335a2NWvWjP/8x6r8sZndu3ejlOK3336zb+DFFi1axLp1lgsa7HumoxQWFqKUYtGiRXXyPCHqhOX+11pM4HQur/zA7uDZTDJzrQOpsmJibdfhS7KjrnlMnPW1uZUEzNVlbwKq3IIijiVmVd6xijJsBKQJmbk2V14lZOaRYePvXVZpCdH47PthFbf0CiKiScPKpOsIhsJc8rSh3gaxWkOeNmAodOwEo6OSODmHn/l+pnCVCmgSMnNrZf+PqH8mTpzILbfcwoEDB+jUqZPZOaPRyOeff87YsWPx8Kj+zMuXX35JSEgVSm9UwaJFi+jduzfXXnutWXttPlOIC0JWgvmxX+3tfz2XX34Am19YxOnUnAqvj4lLxzxdRPnBq7FIYyizh3N/bLpVn+wKxlMTVQmM98el0y7cz6HPtzWjmpCZh7e79edNyMjFz9P6V5y6XKWVei4fV4PCz9Otzp4pxIUm/tQx/BN2cPXwAc4eilP4GFM4lwW5rp5AfdzfrzEUZuJjdOzWkoYdwHr4g5s3FJj2vniqAvzJJj4jTwLYC8SYMWPw9vbm008/5bnnnjM7t2nTJuLj45k4scKydpXq2bNnja5vKM8UolFIPATrH4PjP5u3V3EG9lhiFrO/OkBugZHHR3SgV3SQ2fkCYxGvbTzMH38n07JJzX7e7Lcxi2prZhXg1ve2kp1vxMfDQGZuIXtPWwewM9fGcDg+k6eu7oiriwuvfneILcdT8HB1Ia+wiOTi4DjAy42pA1szpoepul1yVh6zvzrAyZRs7ry8Nd7uBub/eJQQX3eeGd25SiWAHvpsDx9u/oe7BrbG28OV+T8cKc3AHJ+Zi4ergTHdI5l+ZVuSz+Uz+8sDnE41ZVF2c3VhwY9HCfX1YNa1nYkI8OSjP04wc22M1XPmbjhkc1nwY5/vpW/rJlbticWf/XB8Js99dYAirfnPiI7s/CeF1X/G0qN5IE+O7IiLC7z0zUF2/pPKqG5NGdA2lOe+OsCp1GwCvd2YNqgNo7pFAqZZ4JlrYog5k47W4OqiGNAuBC83A+/+epyWTbzpHBXAzX2i6d9WXkwK4SgF+XkcXPMm7993pbOH4jQuaPyMyXCBVTFr2AvFlZJ9sBc4Hx8fRo8ezWeffWZ1bvny5YSFhXHllaZvbLGxsUyePJlWrVrh5eVF+/bteeaZZygoqHh5n63lvPPnz6d58+b4+PgwZswYzp49a3Xd3Llz6d27N/7+/oSHhzNmzBj+/vt8EpYBAwawZ88e3nvvPZRSKKX4+OOPy33m8uXL6dKlCx4eHkRHRzNz5kyMxvPfsZYsWYJSipiYGK666ip8fHzo2LEja9eureRv0bY333yTtm3b4uHhQbt27XjzzTfNzp88eZIbb7yR0NBQvLy8aNu2LbNmzSo9v2/fPoYPH05QUBC+vr506tRJlimL2rfmHuvgFao8A/uf1fv46VAiW46lcP+nf1JoNJ99XL/vDAt/+pvdp9JYszuuJiPmQJz1nlHTrKy1zX8ns/tUGr8fTbYZvJb4eMtJPt7yD+v2xPHOL8fYcyqNbcdT2HMqjdOpOZxOzSEmLoOHV+zhbLrpZ+ZrGw+zdnccf55M455lu7j9/e3s/CeVDTHxzPn6L3Lyq/Yb0u5Tady9bBeTlm5jxz+pbD2ewo5/UjmVksPRhCxe3XiYX48k8cb3R1i3J45dJ9OY+r+dTC5+7rcxZ3nxm7/YcyrNZvAKFe9p/eNYslVbQoap/yMr9vDrkSR+P5rM6AW/MevLA+w9nc5Hf/zDp9tO8tn2U7z/+wn2nk7nhfUHufrNX/njWDKnU3PYH5vBw5/tKZ0lf3H9Qb6NOcupFNPf64nkbD7ecpJ3fz0OwInkbL7ee6b071kI4RhbPn2d5ydejJurwdlDEXWsYc/AgmkfbMqx0sNwlcpZCWCrb5bteoR1blb5v5hZmjhxIp999hk7d+7k4osvBqCgoIDVq1dzyy23YDCYvrElJiYSEhLCvHnzCAwM5ODBgzz77LMkJSXx1ltv2f28VatWcf/993PvvfcyevRoNm3axJ133mnV7/Tp09x///1ER0eTnp7OwoUL6d+/P0eOHMHPz4/Fixdz3XXX0bFjR5588kkA2rZta/OZ69evZ+LEiUyePJlXXnmF3bt3M3PmTFJSUliwYIHV38fUqVN5/PHHmTdvHjfddBPHjx+nadOmNu9ty8KFC3nwwQd55JFHGDp0KD/88AMPPvgg+fn5PProowD861//wmg0smTJEvz9/Tl27BhHjpiylGqtGTVqFN27d+eTTz7B3d2dgwcPkpFhe1ZJCIfIzYDYHbbPNbG/NqrWmm3Hzy93OuXTx94AACAASURBVJ2aw8GzmXSJOv/98T+r9lV7mJZyCowkZ+WZ1U4tb19sVbyw/mClfYxFmq3HkxnTI4plW0+W2+9ri7qBjvL730mlpXlsWbs7jrTsil8yVkViZh5FRZp9NpZel3jzxyNcbDHjbinfWMSOEymM6NKU344m2fXszlEX3v48IWrLX5u/YXQ7V1pGBDt7KMIJGn4Aa1HXL5xU4jMkScOFZOTIkQQGBrJ8+fLSAHbDhg2kpqaaLR/u0aMHPXr0KD3u378/Xl5eTJs2jTfeeANXV/v+OcyZM4dRo0aVBo7Dhw8nPj6eDz74wKzfG2+8Ufq10Whk6NChhIaG8uWXX3LzzTfTqVMnvL29CQ0N5bLLKq5ZNnPmTK666iqWLl0KwIgRIygqKmLmzJk8/fTTZsHpo48+ym233Vb6mSMiIvj666+ZMmWKXZ+vsLCQZ599ljvuuIO5c+cCMGzYMFJTU5kzZw73338/7u7ubNu2jS+++IKRI0cCMHjw4NJ7xMfHc/LkSb799ls6djTVgxwyZIhdzxei2s6WE1S26A+dr7P7Nrb2eh6ONw9gcwrKn43sHOlf7hLg8iRkmgew+8uZga0NMXEZDGofWqN7NAvyIj2ngMzcqu2/tSdQ3/VPanWHZSUhM5e8ShI9pmUX2PX3vz82g17RQXZlNvZwdaFtqK/d4xRClC85Pg6XI5sYd8cgZw9FOEnDXkIMtmvBygzsBcXd3Z2xY8eyYsUKdHEats8++4wWLVrQt2/f0n5FRUW8+uqrdOzYES8vL9zc3Jg0aRI5OTmcPn3armfl5+ezZ88exowZY9Y+duxYq76bN2/mqquuokmTJri6uuLj40N2djaHDx+u0ucrKChg9+7djBs3zqz9pptuwmg0smXLFrP2YcOGlX4dFhZGSEiI3Z8PTEuD4+PjbT4vLS2NmBjTUr4ePXrwxBNP8OGHH3Lq1CmzvqGhoURFRXHXXXexYsUKEhIsEuoIURvO7jU/bn4pPHIYJq8HD/sTCtnKXluVgLRdmC+B3lVL3FM2CMrILeCfMnVNa9v+2PQqB9yWfD1c6RxZ9RnG3afSKu2TWUGW56pKyMyr8OVDCXtehO+Ps//vrUNTf1wvuPIeQjiesbCQvSte4fl/9XP2UIQTNfzvphZ7YMNVKvGZEsBeaCZOnMjJkyf5448/yM3NZe3atUyYMAGlzmdke/XVV3niiScYN24c69atY9u2baX7OnNz7ftvJiEhgaKiIsLCwszaLY+PHz/O8OHDMRgMLF68mN9//53t27cTHBxs97PKPtNoNBIebrHaoPg4JcU8s1tgYKDZsbu7e5WeeebMGbP7l/e8zz//nB49evDAAw8QHR1Nr1692LRpEwAGg4HvvvuOkJAQJk+eTNOmTRk4cCB79uyxexzOoJQaoZQ6pJQ6qpSyWcdIKTVeKXVAKRWjlPqkTLtRKbW7+I91bSRR+85Y/PfV8dpqZR+2le3WVrbf8vh4uNIlsmrbMRLK/Nw6UMNgsqpi4jKq9Plsqc5nBshyYHBqj0Q7A1h7VOXvrUs1gnshhLWtK+fzf2O74ukh2b0vZA1/CbHVDGyqJEqoiSrsPa1PBg8eTHh4OMuXL+fMmTNkZmZaZR9euXIlEyZMYPbs2aVte/futbxVhcLCwnBxcbGaUbQ8/uabb8jLy2PNmjV4eXkBptnbtLTKZxtsPdNgMFg9Iz4+HoDgYMfu/yhZjlzZ85o1a8ZHH32E0Whk27ZtzJw5k2uvvZZTp04RGBhIp06dWL16Nfn5+fz66688/vjjjBo1ymq2tr5QShmAt4ChwGlgu1Jqndb6QJk+7YAngf5a61SlVNk3Fzla6x4I57EIYBP9OmBrYeza3bFsPppMmzAfjiedIzEzn6YBnkQGevFP8jmCfNytrtl6PIX1+85wddfK95L7eLjSOcrf7r2RYEoudCQ+kyW/HuezHXX7byQ9p4D3fz9Ro3t4uxvMlljXV9n5RpIcVAs2MTOvwn3DZXWuRnAvhDD3966fGRieQ8cW7Z09FOFkjSCANZ+BjVCyB/ZCZDAYGD9+PCtXriQ2NpaOHTvSvXt3sz45OTlW9WCXLVtWpee4u7vTrVs31q5da7andPXq1VbPMhgMZvtqly9fTlGR+d4re2ZH3dzc6NmzJytXrjRLFrVixQoMBkOl+2erqkWLFoSHh7Ny5UqGDh1q9rygoCA6d+5s1t9gMNC3b19mzpzJwIEDOXnypNkssLu7O0OGDOHBBx/ktttuIyMjA3//ejkb0Qc4qrU+BqCUWg6MAQ6U6XMn8JbWOhVAay1ro+uLghxTCZ0y7v2hgM+6aLOVGD8fTuSB5bur9Yh7lu3i82l96d2y4pdGPu6utA71qdK9Y9NyuGXJVhIcFFxVVU2TH1Z3CbEz/JPiuOXZ9v69dZEETkLUSEZKElm71jF52oVbMkec1/ADWP9Is8MIlUJWXiEZuQX4S/HwC8rEiROZP38+X3zxBc8++6zV+aFDh7Jw4UJ69+5N69at+eijjzhx4kSVn/PUU08xfvx4pk+fzrXXXsuPP/7I999/b9ZnyJAhPP7440yePJnJkyezb98+Xn/9davArUOHDmzatInvvvuO4OBgWrdubXNG9dlnn+Waa65hypQpjBs3jj179jBr1iymTZtWpezC9jAYDDzzzDPce++9BAUFMWTIEDZt2sS7777Lyy+/jLu7O8nJyYwePZpbb72V9u3bk5OTwyuvvEJkZCQXXXQRu3bt4sknn+Smm26iVatWpKSkMHfuXC6++OL6GrwCRAFlp75OA5da9GkPoJT6HTAAs7TW3xaf81RK7QAKgZe01mtsPUQpNRWYChAdHe240V/o4g+APr809J+iMLadLeJoQhbtws/vf527ofLMvBX5/q+EygNYDwMdm9q/57bkviVlWeqCq4ui0KJ0T014u7vSOtQXPw9Xh+5ZrQ1/namdJdruri60CfW1ur+ri6J9eNX+exBCnFdUVMSOT//Lu3f2d/ZQRD3R8PfAWgSw4aTiQhFxaTlOGpBwlr59+9KyZUu01lbLh8EUBI4fP56nnnqKiRMn4uPjw+uvv17l54wbN4558+bxxRdfcN1117F//37effddsz49evTgvffeY/PmzYwaNYoVK1awatUq/PzMf4mZOXMm7du3Z9y4cVxyySWsX7/e5jOvvvpqPvnkE7Zs2cLo0aN58803efzxx80yHTvS3Xffzeuvv87nn3/OqFGjWLlyJa+//nppCR1vb286derEvHnzGD16NJMnT8bf35/vvvsODw8PIiMjCQ0N5fnnn2fkyJFMnz6drl27smaNzZiuIXEF2gFXABOBd5VSJdPNLbTWvYGbgXlKqTa2bqC1Xqy17q217h0aWrPMr6KMM+azqvt1SwAOns00b69heZqYuHTyCiveQ+nt7koTH48K+1gqL3jt0zKYq7tG2DxXE9MGtalyoqmK+HgYMLgo7r3Sdimw+mTnCcdlNS5ryoBWNAvysmpvF+6Hp5vUqRSiurZ/sZjHRrbH17tq31dF49XwZ2DdvMC7CWSbCpa7qiLCSCUuLYcOEfV2pkfUkuPHj5d7zs/Pjw8//NCqvSRzMZjqsJY9Bmxm8H3ggQd44IEHyr0PwO23387tt99e4b3atm3LDz/8YHV/W8+cOHGizcC8xJQpU2yWyqksA7Grq6vV2MH2Zyzh5eXFkiVLyr1nREQEH3/8cYXPrYdigeZljpsVt5V1GtiqtS4AjiulDmMKaLdrrWMBtNbHlFI/AT2Bv2t91MLEYv9rTFFLAA6cyWB09/MvOg0uCmMNZh73x6bbTPJUlo+HAT/Pmv14vbhFEI8Nv4he0UEYXBRTLk8jKTOPiABPooO96TF7Y43u36N5IP8e0Io9p9IoMJq2Nmjgrv/ttOo7a3QnIgNNgdln20/xw0HrlfM+HqbPO21QG4Z0CGN/XDoPfVa7Sdv+e0NXIgO96BkdxN8JWQT7uKMUnEnPZeLiLeXOMG//J8WqrWUTb07Ymfl56e29UajSvzeAyEAvOkf6M2PNfqv+DWVptRD10Yn92+jhlUCv9hc7eyiiHmn4ASyAf1RpAAsQqZKJTZNETkKIKtkOtFNKtcIUuE7ANJta1hpMM6/vK6VCMC0pPqaUCgKytdZ5xe39gZfrbujCsoROjG5l+l+LjL7e7oYq1yotKzW7gEMWs7qWfNxdcTW44OvhWu0suw9d1Z7LWjcpPe4VHWR2PsTXo0ZLjv293Aj2cWdwB/MM6rbue32vZgR4mWZrs/IKbQew7udnGNuF+9EyxKfWA9jrezbD3dW0kKx78/P77psFedM+3I8D5SwVtnxfN7p7JO3CfHlto30lzjpE+JcG9JbC/Dyt2iQDsRDVcy4zncTfPuX5e6WOvDDX8JcQAwQ0MztsqlKITZUlxEII+2mtC4HpwAbgL2CF1jpGKTVbKXVtcbcNQLJS6gCwCXhMa50MdAR2KKX2FLe/VDZ7sahlJ7dA3J9mTSUzsDGx6WYrDHzca/7e9tb3tlV4vmQ20r8Gs7CVzdr5etRsSWpJQGop5Zx1UFy2b3m5JUo+cwk3gwuuLspmX4D24b72DLNUlI2AsSR4taVViP1JtLzcXAjzs7000dZHCPEtfxljmL/1uYaQnbmEUmqpUipBKWU9lWw6r5RSbxaXGturlOpV12MUFwatNVuX/Zf/3tbPLBGfENBYAlj/KLPDpipZ9sAKIapMa71ea91ea91Gaz2nuG2m1npd8ddaa/2w1rqT1rqr1np5cfvm4uPuxf/7njM/xwXl1HZYOtys6awOIglT0JB8Lt8sU6xPNQK/8oKb8pQ8w7+cILEyUYFeNkv5lOVdw0Dc38v29ZWtrg4oZ9+srRcDFf29Wc78VqZndGDlncpoFmx7htQWLzeDzcATTEu5LVUUOFsG8gAdmzaoGdgPgBEVnB+JadtEO0zJ6BbWwZjEBWj3+o+454pmBPl71/qzktKyuOE/i0hOP1frzxKO0TgC2ADzANa0hFgCWCGEaPT2rbBq2l88+1riSHxW6dfV2f3av21IlfqXBDHlzXJWxp49k742AqWqKG9s4y42X9F0y6XmmbIDy7nOVuA2rndzGz1NBl9UtQB2bK+oyjuV0b+N/f+febobiPC3DniVgjsGtDJrq+xlRqsm1jO/tv5u6iut9S+A9Sbh88YAHxW/zNsCBCqlHJsKX1zwYo/uJzr/KJd3aVEnz/vo682knj3Fh1/9XifPEzXXcL6rVsTfcgmxzMBWhdZalmcIp7OVSEqISp2x3me50niF2XHZ2qrZeRVnELblhl7N+OlQAqnZFSdvKlEyG1ndGVh7lpx613AJsVc5WXFvuawFX/wZS2GRxsvNwHSLrMLNg71tluCxNZ7J/VvyweYTVkmvRnePpE/LYDo29berpM3o7pEMviiMbs0C2Hs6HYAZ13Ss8JoBbUPoEuVfmnU6Otibk+XUf/VyM9Ahwo8OEX5mWauv6dqUYZ0i6NTUv3Q/7bRBNpOLl+oS5W/2uWaO6lTp52tgbJUbiwLOWHYsWzLsX488z8Bry09C2Ji9OH0iWVnW++Z9ff14csGnThhR1dXlZ8jNPseJDUtYel/d7HtNSsviq5+3s3BsCHd/tZ1Jo/rTJKBqdbxF3WscAWyA9RLi+IxcCoxFuBkaxyRzbXFzcyMnJwdv79pfoiFERXJycnBzk9rNogqKjHB2n1nT/fnT2VB0iVlbQub5JcTnqpFUKTrYm6/uv5wN+88y+6vKtzaXBHPVnYHtElX5DKw9s3pLb++Nh6uBW5ZstTpX3kvLHs0DWTd9ALtOpjKofShNA8xnJj3dDLQL97MKPG0tIQ70due7hway8UA8nSP9iUvLpbCoiGu6NsXFRbH8zsv4cm8cqefyedVGAqUFN/fEWKS5umtTlFIsn3oZX+09Q7i/J4PaV1yCysVF8dnUvny99wxh/h74erhy46I/bPb1cjOYxjP1Mr7ed4aUrHyaBnpxbfdIXFwUK6f15au9cYT7e3JFJTPHSpn6r997hvAATwa2q9rsfWOitV4MLAZ495djF+wbyqysTFpPmW/VfmzJfU4YTfWUfIazp45hNJ5/CXhq+Qyevn2UQwPZLcte5rVbL8XFpW5+f//o682MauvCRWEejGqby4df/c7Dtwyrk2eL6mscAay/5RLiFIo0nE3PpXmwBGYVCQsLIzY2lqioKLy8vGQmVtQ5rTU5OTnExsYSHh7u7OGIhiT5KBScn1XLdg1kXW5fq24JGaYZWK015/KrHsAGeLkR4O3Gvwe0wtPNwFNf7Kuwf+kMbDkJjyrTObLyGdiyWX9t8fNw5coOpn9P/ds24fejyRX2L6tTpD+dKljG3DnSeua0vL3F4f6e/Osy0zLAnuarkQnwdis9ZxnAuru6MKqbeZ13b3dXxlewLNmSj4cr4y8x9T+XV4hS1hmIgdIarYHe7txyqfWSRR8PV266JNqqvTy+ZZ7bCNlTbkw0UkajEY+Q8/8W3HyDaT1lvsOC8b3fr+TWS4IJD66bfeMls68rxvsBcFsvH8avkFnYhqCRBLCRgKJkd1MI6bhRSFxajgSwlfD3N32TiIuLo6DAvuVxQjiam5sb4eHhpf89ClGuvCz4ZzPkZ8Jp85qlpz3bQZb1S7jE4iXEu0+lVZqkyBbfMtmEK5sd9XRzwVCcurY6M7BuBmVX0qjKkjgZDLX3MrJLpD+fW5SLdUR257I8KkiUVB0+Hq60DvHh70TrJC3lLacWNq0DpiullgOXAulaa6vlw8Ka5exlalKCw2cvG7L4k0cJTtrFiBED6uyZJbOvIb6m718hvq6MautS4SxsUloWd730MYufvFWCXCey6yeOUmoE8AZgAJZorV+yOP86MLj40BsI01oHFp97GbgGU8KojcAD2tGb3Qxu4BsOWWcBcFGacJUiiZzs5O/vL4GDEKL+K8iBdwdDku16ncfd2tlsT8jM5d1fjjFn/V9VfqSfp2tpQArQPtyvwv5lkyuVl+m3Igpl10qYypI4udbi8jtbe3QdnajIsxaCys6RATYDWM9KZrMvJEqpT4ErgBCl1GngGcANQGu9CFgPXA0cBbKByc4ZacNT27OXjmS55zU1KYHYE0cwFtbOREdBXh4H1y3gg+lX1sr9y/PTrsPEJeTxyT7z2taR8YfLDWDLJnySpcbOU+lPHKWUAXgLGIpps/52pdS6sjUOtdYPlel/H9Cz+Ot+QH+gW/Hp34BBwE8OGv95AVGlASxAJJLISQghGpXD35YbvAIcVq1stidm5lUreAXrWdTKAquygaU9M7CXtAxi+4nU0uNR3e1L6FpZEqcezc+XnekY4W+2hLii+qz2sFUWpqZZkduEms+O9mkZXKP72dIlyp91e+Ks2mUG9jytdYWZloonIO6to+EIJ7Hct7t3wd14hESTffZYrTxvy6ev8sKEi3F1rdt/i+tenV6l/pLwqf6w5xVtH+Co1vqY1jofWI4pjXp5JgIlayE04Am4Ax6Y3uLFV3+4FbBRCzY2LbeczkIIIRqcuD/LP+fuy2bd1eapU6nVf5l5eTvrZEGPj7io3P79ypTcqSyAfWVcd+4ZbJ7l17JsS3kqCxjLjvHOga3Ngta547rZusRuPh6uXNXx/H71S1oG4VXDWcynrjbPKvzwsPY1up8tLWyUuAEJYEXt8vX149iS+zi7fAZxHzxY+sfg2XC2uBk8vYn74EHiV/yfwz/DX799zbUXeRAdUfOXVrVdz9U84ZOLVdkdqSdbd+x5ZWorZfqltjoqpVoArYAfAbTWfyilNmFKr66ABVrr6r0Gr0yAeSmdSJVCjMzACiFE42FZMie6H/iFg2cAXHw7ccvSMK1qNGesYOPrc9d14f/W7Ldqv6ZbUzqE+3HnwNZW5+68vDXebgZOJGfTPtyPvafTyMwrtOpvq4zOrNGdOJGcTedIf24orm264OaebDmWzNBOEXYlcALbe2BfvqEbB85kMKxTuNlS53B/Tz6/ux9r/oylS1QA1/WoWk1VW14Z142lvx2noEgz9XLrv6OqGtIxnAU392T78RRGdGlKm1DfGt/TUnl7i73cpVqBqD0l+1ufvn2UzWzEDUHnKa8C8Od/J5rlBIB8ji25D1/firdWlCf5zCkMx37mxn8PcsAoa3d5b2UJn5LSshh23zx8yJblxXXA0UmcJgCfa62NAEqptkBHTFnqADYqpS7XWv9a9qKytcKio+3P9GfGxgzsRglghRCicdDaOoC99k0IOb/vNT3nuyrd8vJ2Idx6WQurAHbaoDb8Z2SHcq9zM7hwe//zM6U3X2r755atGdg+rZqYXQswqlukVcbdynjbmPG84eJmjC9neXCP5oFmy4prKtDbnYeHlT8TXR3V+XuoijB/T5vttbHfVojGKKBJCHM++Moh9yosLGDvqtd5/56BDrlfbS7vTUrLYtj985jYyZTwqaCwiLS0VEa2disNVheu+gmVk8KADn589bMsL65t9gSwVUmZPgHzvRHXA1u01lkASqlvgL6AWQBbtlZY7969q5fgyUYt2Li0HLTWUhpGCCEaupRjkHN+ryjuvhDcpvRQa01GTtUSjNgKAh3JVhmdmi61LWErTjXUcG9rYxfi626zXZYQi7pQspTYVruz2UratHfB3Rg8vUtnXx1t64o3mXVDVzzcHVP/vTbruX709WYSk5J5d5sHn8Xkk3Eul5ycXLy8POmQeJjbrunHqo1/sOBqL2ZuymbwRe4yC1vL7AlgtwPtlFKtMAWuE4CbLTsppToAQUDZSuEngTuVUi9iWkI8CJhX00Hb5G+5hDiZ7HwjadkFBPnY/qElhBCiAYjbDYstlpiFd4EymXaz8gqrXCLH0ZlzLdmagZVgyXk8XA0EeruRlm3+osNRLxWEqEh9LpVjmbSppOTP2eUzzIJuRwXbR3dsYnBkAe2bhznkfrVZz7Xk3t9Pi+bur7JZNONOpj3/LgtHhXP3V9m8P3Myb3++iSHNC7i0mTej2hVxzlggs7C1rNKf3lrrQqXUdGADpjI6S7XWMUqp2cAOrfW64q4TgOUWJXI+B64E9mFK6PSt1vpLh36CElZ7YE0ZF2PTciSAFUKIhuyXudZtTbubHVoGJfYor3ZpkLdjZgQ83az3Vro6qD6rl4Prrl4owvw8rANYeakgBDFLHsGYa51DwNF1atOSE8jZ8zWT7hpcYb+q1FutTj1Xe59rObP7xIKVZsdvrdzE6u//YNm17ri5KG7r7s74z88x+KJAmYWtRXb9BNRar8dU+6ts20yL41k2rjMCd9VgfPbzDQMXVygqBCBIZeFJHrFpOTZr1gkhhGggTu+wbmtj/svPobOZ1n0qUTIDO21QGxb9/DcAbgbFuN7NK7rMbkop+rVpwua/TS9U24T60MRBL1Qvax1sNpt4fc+aJ2a6EIT5eXI4PsusTfbACgHG3GwibzdfJJmXdJKs79902DOKjEZ2ffoyS+7qV2nfqiRkqk49V3uee9s1/cxmdq+5yJO3f/ubhdNbAKaZ3svf2cw1rYpQypUDiabvx93D4f0dGXRJrfrzhX0azytcFwP4RUL6ydKmSJVMbA3KJwghhHCyzLNmNb4BuOIpaDfcrGl/XLrZcbswX44kmAcqlnyKl47eM7gN6TkFHE/K4o4BrQl24KqdF8d25cX1B8k3FvHY8IsclpPBw9XA4lt7M//HIzTxcefJq8tPOiXOs7UP1sNVshCLxs1yj2sJR8+uVmb7F+/wxKgO+HjZzgheoqoJmapSz7Wimd2yz71jzVY+WL+FcR0NpTO7X/+Vxc1dXKEgB3AjxNcVD/JZd9SVn86UDalc6dImpMp1ZoX9Gk8AC6ZlxGUC2GYqkdMSwAohRMN1Zq/5cdTFcMUTVt32x2aYHd90SXOe/7riqm3exTOw/p5uvDjWdg3ZmmrRxIdFt15cK/fu0yqY/91hs6qdKIefjcRakuhRNGYvTp/IqRN/4+ZrXmfV4OkNNoLa2vLPvi308k2mR9telfat7YRM5c3sln1uqFsS2RnZvL/DnbWHTDOrsUmZuFDEB3sTCQvKBcDV05cOYRKs1rXGFcAGtYCTm0sPm6tETqdar+cXQgjRQFiWzonoZrPbAYsZ2MtaN6F5sBenUsp/ienmoP2oouHw82xcv/YIUZmsrEwiJjyPR4h5ua+4Dx6E4n8Pvr5+pCb9TV7SSbM+BoNjltdnpaeSuPkznrtnSKV9LRMyXXORJ0MWb2T0wB60q2HSp4pmdss+NymrkJSsPOYM8eKlnd6sfvUhScZUzzSudTOBLcwOm8sMrBBCNDxaww+z4aUWsOl583MWyZsAkrPyiEvPLT12Myjah/vRJbLi/AfZ+UaHDFc0HLZmYIW40D254FOCQsKIatnO7E9E89Y1vrfWmm2fvMx/b+tn12oHy4RMX/+VRTNfI8Pue53k9HM1Gov5zK4pyZOt5360I50xF7nRs6krgyLzzfqJ+qFxvYoMMg9gm6kETskMrBBCNCxxf8Kv5dQetBHAHjhjvnz4ogg/3F1d6BIVwDf7z1r1L1Gkq1d2XDRctkobCSFqr07trq8+4L4hLQj087arf9mETIXGIjIys5g3zJ0Hv83h7c838X93jKrWOCortVPy3I92nyUjM4v/Xe9JSk4R17R14UkpiVPvNK4A1sYMbGZuIek5BfJDSwghGoqz+2y3ewRAWCer5viMPLPjNqG+AFzSMtiqb1mju0VWb3yiwRrZJYJZ62LINxaVHgtR39VFEqbaSOYUe3gvbYzH6dfJ/r36ZfeSvrbsO4yntnNRaC5TL9F8+O1m7rlxcLUCycpK7ZQ897Vl30HsTvp3Or+CZ9TZdCmJU880sgDWfH1/c2VKp306NZsALymlI4QQDUJWvHWbdwiM/C+4eVqdSs8xr+sZ5G3KNHtJyyAm92/Jp9tOkltQhHtxtlkfdwN3gnfMpgAAIABJREFUDmxN82D7ZgRE4xHk486sazvz2sZDhPl58vDQ9s4ekhCVysrKpPWU+VbttmZMbTEYDFb7WwuyUvANaeOQ8dkKsIuKjKhzycR/8X/lXmdPRuD5QyHATTGlpyfL92dVexbW3lI7jizJI2pP4wpg/SPBxQ2KTL/MBKssfMjhdGoOnSvZCyWEEEqpEcAbgAFYorV+yUaf8cAsQAN7tNY3F7dPAmYUd3tea/1hnQy6MbIMYIc+B/3ug3L2T2VYBLD+xYlJlFI8M7oz/3dNJ4q0xtXQuNI+iOq5+dJobr40uvKOQjQwtgLJ9OQk0j5+gsBQ89UGzVu2KXfWtaozvpYBttaaMxsWof7ZhotL+d93K8sIPLI1uBpzaRJgwM1FcUtXN5ZWcxbW3izBkk24YWhcAayLwVRKJ/V4aZOU0hFC2EMpZQDeAoYCp4HtSql1WusDZfq0A54E+mutU5VSYcXtwcAzQG9Mge3O4mtT6/pzNAqZFvtWA6LKDV7BegbW32LLiIuLwgXJOCyEaNwqmqmd88FXDrmPPVJ3f0dk+24knN5Zbp/Kar3+tOswB49n8u7mfPw9z3//9kDJcl7RyLIQg1Uip+YqkVMpkshJCFGpPsBRrfUxrXU+sBwYY9HnTuCtksBUa12yxmg4sFFrnVJ8biMwoo7G3fhYzsD62t6neC6vkGe/jOGDzSfM2i0DWCGEEHUjN+EEKiue0DZdKuxXUUZgMM2EdmjVDP8Af/DwK/3j6unLT7sO1+ZHEA1A45qBBRuJnBI4kVyztNtCiAtCFHCqzPFpwDLzRHsApdTvmJYZz9Jaf1vOtVG1N9RGLtMigPWzHcC+/dNR3v/9hFW7JO0TQoi6V1SQR8rWL+h6zaQK+yWlZbH6h60EuZxj0sW+VhmBS8hyXlGexhfA2piB/TlZZmCFEA7hCrQDrgCaAb8opbpW5QZKqanAVIDoaNmHZ0VryLJYQuxru3j9W5v+ttnuL7U+haiWyvIAKKVuB+YCscVNC7TWS+p0kBeg2ipx42jxP/+P9oPG4GIwVNjvo683E+qWS/q5Aj7cnsbDVzQxywgsRGUaXwBro5TOyZRsCo1FksBDCFGRWKB5meNmnP8lrcRpYKvWugA4rpQ6jCmgjcUU1Ja99idbD9FaLwYWA/Tu3VsKkVrKSQVj/vljNx/T0rEqkBlYIarOnjwAxT7TWsvUWB0qSZxUklwpLfEsWrmQmpTAPaP64KJcCGgSQnpyUq2NIWbJI+QmJfD07eYZgH19/fD19eOvN27DUxk5dmJL6bkQPw+b99qw9S+OxOUwf6QH932Tykd7C3A1uEimX2G3xhfABrU0O2ymEigs0sSl5RLdREomCCHKtR1op5RqhSkgnQDcbNFnDTAReF8pFYJpSfEx4G/gBaVUUHG/YZiSPYmqstz/6hde5VsEeEsAK0Q1lOYBAFBKleQBsAxghZOUJFfau+BuIm+fV9qel3SSqJbt2PXiOIfM1Nqa8c1NSiDqlheJaN7arP3Ykvt46MW3Sf9hAS/dPsiu+w+/tCPDm2VzTa8ADmWlQ9TFEriKKml8AaxVLdhEQHMi+ZwEsEKIcmmtC5VS04ENmJbPLdVaxyilZgM7tNbris8NU0odAIzAY1rrZACl1HOYgmCA2VrrlLr/FI2AZQbichI4VaSkjI4QokrsyQMAcINSaiBwGHhIa33KRh/hBIGhEVXKNlweW6Vynr59lFXwCqaSOftWvs770+0LXkuyD68Ybwqqbe1/rag+rCPV1XOE4zW+NbU+oeB2PlD1VbkEkSmJnIQQldJar9dat9dat9Fazylum1kcvKJNHtZad9Jad9X6/9m77/goq6yB47876Z0SAqF3aYJgwIKyLIgNBEVFUETdV3FR9F1li+66yqq7oq7u+iqrIsqqNBUbInZALIgUaaF3EhKSENJIn7nvH5My5ZmSZErK+X4++ZjnPmVuXDeZM+fec/Rym3vf0Fr3rvpaFKyfockrsm8e7yoDW15pMRw3KYiNkABWCD/5BOiutR6Mtdq6y37XSqmZSqnNSqnN61ca9xsVTV9pXg6PTxlCRLh3K1+qqw8nxlp/TyfGhjpVIbbtD+tPgXod4XvNL4BVyjALezRHCjkJIUSj51TAyTgDW1BaYTgeHxWGctMzVgjhksc6AFrr01rrsqrDhcD5rh6mtV6gtU7RWqeMmjjN55MVwVewfyNRYYrendt5fc+6rftZurOMlPlZNV9Ld5bVtMax7Q+76ttNnM73TwIqUK8j/KN5fkzdqhtk76057KKyOSYZWCGEaPwcW+i4qEBcUGIcwEoBJyHqzWMdAKVUstY6o+pwIrAnsFMUjUV5QQ5lx34hNrZuS289tcax7w9b6rfKxIF6HeEfzTOAdWqlk8WXEsAKIUTj55iBddEDNt9FABsn+1+FqBcv6wDcr5SaCFQCucDtQZtwC1RdXKmyMIdjL82oGTcpE2VtE/3aVse2sJPWmpLcDBJbJ5CUEOWz1/Bmf6wv7Dt2ildXfMW3szrX6XVkz2zj0Tz/0ju00umqsjiRW4zZogkxydIyIYRotJwysMZ7YF0FsBbjrbFCCC9orVcDqx3GHrX5/mGkwnrQGBVXCsZr//TeS/zvBVEM7ln3InvuuNsf68vs6EPzVzChF1BRAoR5/Tq2e2YlWxtcXu2BVUpdqZTap5Q6qJR6yOD8v5RS26q+9iul8mzOdVVKfamU2qOU2q2U6u676bvQxr5KWneVSYVZczKvxO8vLYQQogG8zMAWlFYajpdWmn09IyGEEFWObN9ASnyez4NX8Lw/1hdy8orYnHqEr49YGD7/FMNePOXV6zR0z2xOXhHXP/SK7LX1EY8ZWG8aW2utH7C5/j5gqM0j3gL+rrX+SikVC/j/8/G2ve0Oe5isb4iOnS6mSxtppSOEEHVRVmnmi9RTtIoK49I+if4tkuSUga3bEuKyCknBCiGEPxTm5ZL703v8/Z4xfnm+p/2xvvDWpz/ywK/a8uCoBJ5f730P2obumZXsrW95k4GtaWyttS4HqhtbuzINWAaglBoAhGqtvwLQWhdprf1fDrh1d1C1P1qyyiWKUo7IPlghhKizO9/czP3LfmHGGz/z0pqD/nuh8rNQXlh7bAqD6DaGl7oq4lQmGVghhPA5rTWblj7D07dd7PMPMQOVnazOos4YZt2/OmNYjFfZ1Pre53i/VDz2HW8CWKPG1p2MLlRKdQN6AGuqhvoCeUqpD5RSvyilnq3K6PpXaLhTK53u6hTHcuQ/GCGEqItD2UV8dyCn5viltQfRWvvnxYoM9r+6eKPkKoAd08+4arEQQjQFT82exl9un+D09dTs4LYi2rLyDf53XA8SYn1XtKlaIPu+eupB68v7HO+3Zm+9v0+45usiTlOBFVrr6o/AQ4FLsS4pPg68g7Vi3eu2NymlZgIzAbp2tQ88661tbzhztOawu8rk6GnpBSuEEHWxIy3P7ris0kJWYRnt4yN9/2JettAB4z6wYSGKu3/Vy9ezEkKIgCkqKqTnnS86jVdXAA6GE3u30Vcd58L+I3z+bNvs5KxVvq84bGvd1v2czCpj6c4su/GOp/a7XdbrzX2uKhTX/Hzjo7l+0QmeGp/Eb/38c7YE3gSwHhtb25gK3GtznAZs01ofBlBKfQRciEMAq7VeACwASElJ8c1H+217w8Gvaw57qAxppSOEEHW0N6PQaWxXer5/AlgvCziB8x7YQZ3ieeb6IfRqF+v7eQkhRAtVcraQtDX/5W/3XeaX5xvtLZ0x/mK/tKup7x5bb+5ztce1+uf7dE8RZ86Ws2p3ERN6h8pe2AbyJoD12NgaQCnVD2gNbHC4t5VSqp3WOhsYA2xu8Ky90cb+U/iepkyOn5ZWOkIIURepJwsMx8b2N25v0yBettAB5wD2D1f0Y0DHeN/PSQghGpGnZk+jqMj5g8XY2Dift9nRWvPT4qf5vxkX+aV4n6u+r2dLy5tUwSN3WeR1W/dzPKOEgsIiXrwqgvs+O0N8XCxdPWR9hXseA1gvG1uDNbBdrm02R2mtzUqp3wPfKOt/+VuA13z+Uxhpax/AdleZlJstnMgtpnuipOyFEMKTwtIKvj+Y4zS+Kz3fPy/oRQa2vNLCgaxCjufabwmJj2yebc2FEMJWIJcYb/9iGXeO7EBiK+eVLSNmzSensMxpPDEugp9fvtdp3IjR3tKresIbn//IR7e2a9CSYldLeht6rbufw6hC8crnZvP8ki8hfQvjhyWwr8j7ysfCNa/+4ntqbF11PNfFvV8Bg+s5v/pzbKWjMgA4kFUkAawQQnhwMq+Ei+etMTxnlJX1CQ8Z2AqzhakLNrD1uP2+XICEqDD/zEkIIVqgzKP76FCYypjzLjY8n1NYxsC7nnMaT31tjt2xu0C3Q7R22ltacLaU6JDKererqVaXtjUNaXHjKotcHXh7Oi/qp/l+ZJ3QGULCwVwOQFtVSDxFHMwqYtwAPyx9E0KIZuSdTSdcnkvPK6GgtIL4SB8HjQUO5RUcMrAbD+caBq8A8RLACiEaMW+X/sbGxhlmU2Nj4/w6P1tlpSUcWPUyi+4b2+BnuQt0f375Qftr84qY8scXGhzs1aUwVEOLSLmrUPzgLZd7PC/qp/kGsKYQaNMTsvfWDPVQmRzIcv7lIYQQwp5j9WFHp/JLfRvAag2ndtmPtelpd/jNXocMbZWY8BDaRIf7bi5CCOFj3i799fU+ViOegumNS//JvFuGExLiTbdNqx9ee4zy0hIqigroOf35mvGM7DMM9PIZvgr23C3pbci1RjxVKK5v5WPhXvMNYMG6jNghgD2UVRTECQkhRNOwy8My4azCMvq092FGoCAdik/XHofFOG0F6Zhg3H9wYMcETFKcTwghvOIumE5d9xE3nhtLp3at6vTM8tISutzxL0qy0xjYo3alY/pTd3n9DF8Ee3VZsuuL5b2eKhTXt/KxcK95B7AOn973MGXwVVYRWmu/VFMTQojmIKuglGybPUsRoSZGn9OOL1JrM6BZhaW+fdGM7fbHHQZZV9LYcPVrW6oPCyFaCn8uMTZXlBOdvoGJt41q8LPqwxfB3svvr+P81kW0ikoA3GdxZXlv09W8A1inQk6ZnC03k5FfSsdWxp/kCyFES7frZD6gSaQAhYX+7VuTHB+JCQsKjZkQsgqci3I0SMYO++PkIU6XlJSbDW8d1CnBt3MRQohGyl9LjC2VFZQV5DD3ZuOiTY4S4yLsCjZVFBVQkp1GaEhwE0Tvr93K6dMlfHwgjfiY2n7lRllcfy/vbWh1Y+FaCwtgaysRSwArhBDG0g9s57vw39HFlG0dOG39mhsJpTqMuZW3kV3Yw7cv6piBNQpgK1wFsJKBFUKIhsj6bimt42MJD/MuNHBsldNz+vMM7NGePcez2HmkdrWO2Wzhy6fuwmRSJLepzRInxkV4PTdvA8GcvCLaRIfwzpRuzFpVzHvP/s7t9f5e3mtU3ViCWt/wfnd2U2SQgQXNQdkHK4QQLvXb93Jt8OogUlXw19C3ycs/49sXdVpC7Nx9zVUA26udc49CIYRoTKqX/jp+BbK6sCv5+zbQJqk9YWENL8xXadZEtetc8xWZ0JbLH36N5DZxHF78IIcXP8jPL82kS0IIp/PPevVM20DQ03W1BZlMHq/3Vk5eEdc/9IrhfF2ds61uvOrbTTXnvf1ZhHvNOwMbmwQR8VBmLUYSq0rpyGkOSiViIYRwqVvxLrfnY1QZsbm7gZG+ecGibCg8WXscEg7t+jldVmoQwI4+px1hdaiUKYQQwRCI6sLest1Ha66soLIwh7atW9UpK+qoeklxRk4BYbGta8bDI51XPNal76q3bW782W/V3XxdnTOqbjxj/MUNatkjajXvAFYp65ugtJ9rhvqa0jiY1SeIkxJCiEasOJckS5bHy9oW7fPda2Y6ZF+TBkCoc1scoz2wc6/xtkGDEEK0DJ7a5FQH0+bKSta/8iden3UJURENa0VWvaS45/TnGXjXMy6vq2vfVW/b3PirIJO7+bo65yqYPltW3qCWPaJW8w5gAZLsA9g+Ko33pBKxEMKAUupK4AUgBFiotZ7ncP524FkgvWroJa31wqpzZmBn1fhxrfXEgEza1xyX8rrQpfSA/17TYP8rOC8h/s8tw+ieKJ9eCyGaJk+BZn1523P25/f/w58nDWhw8FoXdem7Wpesqr8KMrmbr6tzRsH06C7w/pcb+PrO9h5/FuFZ8w9g2/W3O+yr0sgrruD02XISY+u/VEII0bwopUKA+cA4IA3YpJRaqbXe7XDpO1pro8oPJVrr8/w9T7/L3OH5GqCvPkJJuZmo8BDPF3viVIHYef8rQGmFxe44KswHry2EsOPFB3kRwFvA+VhLvN2ktT4a6Hk2B94Gmt4GuoV5uSx/9g9YzJUeX/vI9h+4sE0Bg3r0qsfM66euy3zrklX1R0Emd/PVWrs8ZxRM5xaWcP05Slr2+EjzD2CT7PdR9TGlAXDgVJEEsEIIWyOAg1rrwwBKqeXAJMAxgG2+9q6Grx61G8rQbUhWuU6XDjAdo+Kl86BLCkx4HqJaO13jkdbw44uw+yP78WTjzwEcM7CREsAK4VNefpD3P8AZrXVvpdRU4GngpsDPtuXwNtDd9Nk7hJ7aiaXYfV2AwrzT5G1cwV2zxvp0nuDcXsd2vK7LfP3d5sYTd/MFXJ4zCqYnznmJtSdzSJkfnJ+luWn+AaxDBraPSkdhYf+pQi7q1TZIkxJCNEKdgBM2x2nABQbXXa+UGgXsBx7QWlffE6mU2gxUAvO01h8Z3Nt4lZ+FD+92Gv5U/Yo7+dDwlrCC45B6HNr2gjGP1P01T6XCV3+1H1Mh0N54X6tjESefZH+FELa8+SBvEjC36vsVwEtKKaW11oGcqLBXmJfLvvUfMv+6Ttz02j4qivMJi3bukW2xWNi05GlevXNkvbfSuWsF49hex9bEOS/VKSD1d5sbT9wF0ECT+lmam+YfwMZ1gMgEKM0HrNUzO6nT7M2USsRCiDr7BFimtS5TSt0NvAmMqTrXTWudrpTqCaxRSu3UWh9yfIBSaiYwE6Br166BmrdnGdtrKrZXK9YRfB49njsrPoPKUtf3rn+2fgFsxjbnseTBEGbcp9uxiJMsIRbC57z5IK/mGq11pVIqH2gL5NheZPu7bvqcJxk1cZq/5iywZl+v6QO9k6KY1C+Uz7auJvES53/nWz5+nQeu6E18jPHvWW/UpYqwrcxiRa527tttKm6cNWkk6Gy8mn8Aq5Q1C3vip5qhPiqNvZlSiVgIYScd6GJz3JnaYk0AaK1P2xwuBJ6xOZde9c/DSql1wFDAKYDVWi8AFgCkpKQ0noyFQfGmJyunUx6TDCOehC/+AuYy375mYabz2OV/d3m54xJiCWCFaLxsf9e9tv5w4/ld14xYzJW89pf/4ZrfPsK+9R/y2E3WjOuNg6L4eMViDqauxxRS+1Y/LAQGhKYzot/wer9mXasI291bWMbAu55zGk99bQ4jZs0np9D5b0xiXITbrK5omZp/AAvWfbA2AWxflcbbmYVYLBqTqXF+6iOECLhNQB+lVA+sgetU4GbbC5RSyVrrjKrDicCeqvHWQHFVZjYRa4NU130EGiOHAPbpiqksNY/lksgwGHEXDL+Tj95dxLV7HvDdaxadsj8e9wR0d91b1nEJcWS49H8Vwsc8fpBnc02aUioUSMBazEnUkW0/Vsdxb1iK8wg9lcsn/5nLNX2gbUwYAP3P6cUdo3LYnzyJMdNmAVBcWMCOxY/yv9emNGjOdakiXBfugltfkAC5eWkZAaxjJWJTGsXlZk6cKaZbWyldLYSoWQo3G/gCa/XNN7TWqUqpx4HNWuuVwP1KqYlY97nmArdX3d4feFUpZQFMWPfANq3iTw4B7DZtrUyZEGV9Q4RSmDsMrgrZDVSWG/ZudcsxAxuX7PZyxyXEUsRJCJ/z+EEesBK4DdgA3ACskf2v9eNtqxyjQNdiriReF/HcdX2YvGALyxJa8c6ONPv7Mn9gzLRZaK3ZuORpXpxxcYNaSNa1inAgeBuYugqQv356Jj2nP+/xftG4tIwA1rESsbL+H3xPRqEEsEKIGlrr1cBqh7FHbb5/GHjY4L4fgXP9PkF/0Bo2zIcs+3g71dIdgPjqABaIb9cFl4pOQSs3513dYyuuveFlZZVm/rP2EGdlD6wQfuXlB3mvA28rpQ5i/SBvavBm3DIYBbprlr1M34wP6Z0UxcxfdWR/8nU12VZH2z5fwsxLOzY4yKxrFeFAaGjm1mLRfs38Cv9oGQGsQwa2tzqJwsKejAKuHNQhSJMSQohGYO+n8OVf7IaOWZIowPpGJz6q9s9EUpyb1mP1CWAdM7Cxxr+PX/32MC98c8BuLNSkCAuRJcRC+JoXH+SVAjcGel6iVnXF4eo9r9OGJXDzOx8y4uqpaK1Z/uwfmPbHfxKb0JqMw3vodHYvo4dc1ODXDVZbG3dZVtEytYwANjbJ2qOw5AwA0aqMziqbnekSvAohWrgDXzgN7dA9a75PsMnAJsVH8HzFDTwYtsL5OY7ZVE+09joD+/xX+53GJPsqhGguCvNy7YJOT6orDlfveW0bE8Y1feDn1csBCD21k59XL2fktbdxaPWrvHGfb/q9NrQqr7sesUYBajV/748VTY9XAaxS6krgBazLSRZqrec5nP8X8Ouqw2ggSWvdyuZ8PNYeYh9prQNfk7q6EvHxH2uGzlFpbD3RBa11g/YDCCFEk5axw2loYeXVNd/HR9YGsImxESw1j2VK6Do6qxz7m4wqCrtTmm/fmic0CiKc2yu4Eik9YIUQzcSmz96pCTpdLQO2deCXH/glq9Rpz2tk2jpMJWeYf10n7l31IRVnTvDi9BGE+HC1irsesJ6421M6Ytb8egW3omXyGMAqpUKA+cA4rP3ANimlVtoWKNFaP2Bz/X1Y20fYegJY75MZ11eSfQDbXx3j67Pnk3amhC5tooM4MSGECJLKcqe9r2PK/slh3bHm2DYDGxZiwhLTjnFnn+GlsBcZG/JL7Y11zcA6Xh+bZP2w0UuSgRVCNAfVy4Grg84RV0/1mIW9+5nFhuO2+2J7RWWScPY4yYmuK7vXR317wHriLrg1KrJUV66yvyZtNrhaNHbeZGBHAAe11ocBlFLLgUlYM6pGpgGPVR8opc4H2gOfAw2r3d0QHezrqww0HQMz/HIiTwJYIUTLlL0XzOU1hyd1G7vgFeyLOIF1H+zes5F8axlsH8DWNQPrVIG4bls6JIAVQjQH1cuBeydFcU2fs15nYR3Z7os9nF1KzwQLm44c5nT+WZ9VCG5ID1h/cbcs2ZarANld5lc0Xt4EsJ2AEzbHacAFRhcqpboBPYA1Vccm4DlgOnBZg2baUMlD7A4HqqMAbD+Rx8QhHQ1uEEKIZqyyDFba7+iorjxsK8EhgG0XF8HezEKytEOGoC4ZWK1h4yv2Y7HG+18rzRbDcVlCLIRo6twVY/JmL6yt6kA4NiKEf395nBcnteXFHwp8min1Vw/YhmhoqxtpldM0+bqI01RghdY1+fh7gNVa6zR3+0yVUjOBmQBdu3b18ZSqJA0AFQJVU+tiyiaeIradyPPP6wkhRGO26kGn3q+purvTZfGR9n8mkuIiAciqLXNgVZcM7KaFsG+1/ZiLDGxBaaXheFSYVCAWQjRt7oox1TULW70v9uVv99A+LoSLXskGfFchOJg9YL3NsoqWw5sANh2w7Y3QuWrMyFTA9qOMi4BLlVL3ALFAuFKqSGv9kO1NWusFwAKAlJQU/zTDDouEdv0gK7VmaKDpGFvT46kwW6QdgxCi5bCYIfUDp+Fdlh5OY21j7N8gtI+3HmeTYH/h2WzvX3/vp85j8Z0MLy0oqTAclyXEQoimqrrqcHlxEb+ccS7GFJv5Q50D2LufWczeDZ9zgd7JlFEDfDldILg9YCVLKhx5E8BuAvoopXpgDVynAjc7XqSU6ge0BjZUj2mtb7E5fzuQ4hi8BlTyEPsAVh1lQ+VA9mUWMqhTgpsbhRCiGck5ABXFdkPHLEl8Z7GvFXD1uR1IiLZfQty3vfXT93wda//M0nzvX7/4tPPYgImGl+a7CGAjJYAVQjRR1VWHe429o177XY3kZp2Efd8w5c7RPnmeo2D1gBXCiMcAVmtdqZSaDXyBtY3OG1rrVKXU48BmrfXKqkunAsu11v7JoPpC8mDYvrTmcKDpaE0hJwlghRAtRqZz65xJ5U9QRnjN8fhzk3lh6nlO1w3qZG11U0gUFq0wqapf+eVFYK6AkDCne5w4Bru3fghtehpe6iqALa2QypFCiKanPlWHPTFXVrLtnX/yxj2X+miWzhraA9YXRsyab9hSJzEuQrK0LYxXe2C11quB1Q5jjzocz/XwjP8C/63T7Hytw2C7Q9tCTrde2C0IExJCiCBw2Ps6v3IiecTZjd1wfmdCDbZW9EiMJSoshJIKaxCbgE0mt7QAYtp6fv1Sh9oDHYYYXwcUlBoHsIUu9sYKIURj5quqw7Z+XvESf508iKiIcM8XN2E5hWUMvOs5p3Gj/bGieWtZGz8dWun0UieJpEwKOQkhWhbH4k0G1Ycd2+dUCzEpBnS0ZmHztUPhDsfA1IjFYg10bUXGu7zcVQZWAlghRFNTnX2dNqy26vC+9R9SlH+m3s88tPU7hsSc5q8vf8jp/LO+mqoQjZqvqxA3bpHx1mVquYcBCFGa/uo427IjKCitID7Si6VvQgjRlGkNGfZLiHdp5+JNCVGu/zwM7BjPlmNnyCcGsCneVOJFAFtWANjsNAmPdbvsuKDEOFAtdJGZFUKIxsqXVYcBCnJzKNr6Eea4Ss5knghoW5ucvCLunreYBQ/fGvResP4mS5cbn5YVwIJ1GXFVAAvWfbC/mPuwMy2fkb0TgzgxIYQIgDNHoax2D2qBjua4TnK6zFUGFmBQx4Sqe+uRgXXc/xq3K4cXAAAgAElEQVTZyvi6Kq4ysCnd23h+LSGEaESqW934ouqwxWJh87KneerGIfxm7iu8PDmRWasC09YGrFWJ/Rk0GwWN6TkFmI5n0b+r898sf5Kly41Pywtgk4fA7o9qDqv3wW47kScBrBCi+XNYPrxbdwOc+3S7W5GS3MraC9aagbXhVQDrcE2k+wJ6RntgTQru+XUvz68lhBCNyN3PLPbZszZ/9BpzrurLB2u3MKG3iXOSIpjQuzQgWdjqnrD+DJqNgsasF/9Ipbnx1ooVgdMCA1j7Qk6DTdZsrOyDFUK0CA4B7C6D/a/gvk1NdXBboKPtT3jTSsdxmXFU3TKwnVtH8a+bzqNfB9f7ZoUQojk7lrqJwZGZdE/qxx+/3cS7U6xF+GYMi2HKu/7Pwlb3hA1k0AwQHhlFxvJHMCXa//5PjItwcYdorlpeANtxmN3hOeoE0ZSy7UQeWmuUcs5ECCFEs+HQQmeXxXn/qycJVcuLnTKw3uyBdVpC7CED6xDAPnHtIIbL8mEhRAt1tjCfzPVLeGL2Zfxr6VdM6G0iMdb6dj4xNpQJvU1+DSirs6+BDpoBRt71N1Jfm8PhxQ/69Lmyx7XpaXkBbHQbaNsbTh8EIFRZGGI6xIbCgaTnldC5dbSHBwghRBNTnAu5R6zfn9xmd2qX7l7nx1Xvj61TFWKLBU4fgEPf2I972APrGMBKsT0hREultWbjkqeZf9vFKKVYt3U/J7PKWLozy+66jqf2+y2Arc6+BjJo9jfZ49r0tLwAFqDziJoAFmCoOsAGBrLl2BkJYIUQzcuOd+HDu0FbnE6VqwgO6451fmR8pPVPR4HTHlgXS4jNlfD2tXD0O+dzHjKwjkuIE9wUlxJCiOZs22dvc8/ozrSJt/7uXfnc7IDPIRhBsyuBypwmxkUYBrOydDl4WmYA22U4bF9aczjMdADM8PORXCad1ymIExNCCB9bN88weAU4HtYTS0nd24GHhpiIjQiloMLLJcSH1hgHr+B2D6zWmtyz5XZj8W7a+wgh6k8p1QZ4B+gOHAWmaK2dGpQqpczAzqrD41rriYGaY0t28lAqXUoPcOmgC+t1f3Xbm6fumczD//mg3u1vAhU0exM0BipzKsuIG5+W+U6g8wi7w6Gmg4Bm09Hc4MxHCCH8wWKGM0dcnl5bea7h+MNX9fP46PjIUAoqvCzilL7Z9YPcLCHOLCiloLS2D2xUWAhtY+QTbyH85CHgG631PKXUQ1XHfzK4rkRrfV5gp9aylRaf5cjnr/HGfWPr/Yzqtjd/euk98rNONvolvxI0Cnfq/tF7c5DUH8Ljag7bqkK6q0z2nyrijMOn/UII0WSdzbHPvppCrYXsOg+n+PxZ/LP4arvLR/Vtxz2je3Hbxd09Pjo+Ksz7PbAOlY/tuFlCvCu9wO64f3IcISYptCeEn0wC3qz6/k3g2iDORdj4aemzzJt+ASZT/d62Vxde+r9Jbdm59xD/uKo1q77dxOn8sz6eqRCB0TIzsKYQ6DQMjnxbMzRMHeCoTmbT0VwuH9ghiJMTQgSLUupK4AUgBFiotZ7ncP524FkgvWroJa31wqpztwGPVI0/qbV+k2AryrQ/btsbZq4FYOO+LMp+2FRzanDnBN76jf3qFHfio8LI8bYKccYO43Fwu4Q49aR9RndQJ/f7ZYUQDdJea51R9X0m0N7FdZFKqc1AJTBPa/1RQGbXQu38ZgXTz29Nh7b1bx1WU3gpvJybB4Xy45ESJvQObfRZ2ECRPa5NT8sMYAG6jLAPYE0H+MAyiu8P5kgAK0QLpJQKAeYD44A0YJNSaqXWerfDpe9orWc73NsGeAxIATSwpepep/1jAVV4yv44tvb96K40++BwYMe6BYcJUWEcdsrAGiwhLsqCwpOuH+QmA7vdoT/3oDrOUQhhTyn1NWD0Jucvtgdaa62U0i4e001rna6U6gmsUUrt1FofMnitmcBMgOlznmTUxGkNnH3Lc+rEIVplb+GqKy6p9zOqs69Lro8l/0wOs0ZEcsv7BbxyY0d+u8p9+5vqfbP13S/bVMhy5aan5QawDvtgh5msVYm/O5ATjNkIIYJvBHBQa30YQCm1HOuSOscA1sgVwFda69yqe78CrgSW+Wmu3nHMwFYFsMt+Ps5zX+23OzWoU90+3U+ICqMAgz2wWoNtP2132Vcw3AOrteaxlams3ZdtNz6wjnMUQtjTWl/m6pxS6pRSKllrnaGUSgayjK7TWqdX/fOwUmodMBRwCmC11guABQCvrT/sKhgWLlSUlbH3oxdZdN+YBj2nOvuqKktIiFR0iA1hQp9QVu0u8piFrd4321gztZI5bblacACbYnd4jjpODCUcyYETucV0aSPtdIRoYToBJ2yO04ALDK67Xik1CtgPPKC1PuHi3uCXNHfMwMa1p6C0grkrU50urWsGNj4yjHLCKNHhRKmq2gHaDGUF9lnVTDf7XwEinYPSTUfP8NaGY3ZjYSGKPklxTtcKIXxmJXAbMK/qnx87XqCUag0Ua63LlFKJwEjgmYDOsoX4afnz/H3a+YSFhjToOdVtb/69vhCzubYmgoVyOiXGuWx/U525fXlyIrM8ZGqDxVPmNFBtdrzRmObSHLTcADa6DST2hRxrFiJEac437We9ZQjrD2RzywXdgjxBIUQj9AmwrOrN291YC53U6eNx22V1Xbt29f0MbRU5LiHuwK60fMoq7dvqxEeG0q9D3YLD6n6smbo1PZTN62Tvt7Yqq+augFNMEsQ6r2Y0qgg/rGtrwkNbZt1BIQJkHvCuUup/gGPAFAClVArwW631nUB/4FWllAVrIdB5BtssRAPt+WE11/QJo1uHNg1+Vn3b3lRnbs9JimBC79JGm4V1J1BtdpraXJqDlhvAAnS7uCaABbjYtNsawO6XAFaIFigd6GJz3JnaYk0AaK1P2xwupDbzkA6Mdrh3ndGL2C6rS0lJ8e+yOsclxHEd2HXSeZ/qMzcMITKsbp/yV/djTdXd6YFNAJuxzX0Ae/U/4Ze3obwYrnwKQpz/DDkWbwKYO3FgneYnhKibqt9vTn1atNabgTurvv8RMO6/JXwiNzONkEPruPE3vwraHKqzr+9OsX6wOWNYDFPeDUwWtr6ZSqP70nMKyHvtMUbe9Tefz7MuRsyaT3pOAZYj9h8qh4ZIVf36atkBbI9RsOW/NYcXmqzL6n48eJpKs4XQEPm0X4gWZBPQRynVA2tAOhW42faC6v1hVYcTgT1V338B/KNqeR3A5cDD/p+yBwZFnHbtsm9N89g1A7hyUN0L11VnYHdbujMhZGPtiUybPa8leXDmaO2xCoGh02HEXW6f7dg+58N7LqZ/sux/FUI0b5WVFWxf8TxvzBoV1HnUVC2OtYYJibGhTOhtCkgWtr6ZSqP7LEdOkbPK+VmBllNYRlhsa6LadbYbL8lOa6H9TBuuZQew3S+1OzxXHSGOYgrLotl2Io+U7g1fuiGEaBq01pVKqdlYg9EQ4A2tdapS6nFgs9Z6JXC/Umoi1vYRucDtVffmKqWewBoEAzxeXdApqAwzsHZJ5Xq3pomPtAawu3R3+xO2GdfMnfbn2p0DYVFun5tfUsHx3OKa4xCTkuBVCNEi/Pzuizw6eTCREWFBnUf1vtmlO+3reLnaLytEoLXsADY2Cdr1h2xrEiVEaUaY9vCN5XzWH8iRAFaIFkZrvRpY7TD2qM33D+Mis6q1fgN4w68TrFaSB58/DGk/g7YpyqE1p8+WU1ZhQSnoaMnEdoHS+Df2cTi3dkQp6h0cJkRb32ClWrrbnzi1GyrLITTceflwh8Fun1lQWsHVL3xnN9a7XWydlzcLIURTc3DzWkYll9Gva7tgT6Xe+2aFCBSvAlil1JXAC1izEgu11vMczv8L+HXVYTSQpLVupZQ6D3gZiAfMwN+11u/4avI+0ePSmgAWrPtgv7Gcz7f7snhwXN8gTkwIIVxY/yxsX+o0bAJq3vo47K4t0eGkOuSEe7SNITaifp9jVi8hPk0CGboNyarq4ZYKyN4LyYPtlxMDJA9x+8x/f3WA9LwSu7GBHSX7KoRo3vJPZ1O8fRV33N2wljnCXmiIoqLojNPy42C02QmPjOLEogfsxiqKzjCkR/A/sGiKPL5zUUqFAPOBcVhbQ2xSSq20rTqntX7A5vr7sPYEAygGZmitDyilOgJblFJfaK3tu9MHU49R8POCmsOLTNYfa3taPtmFZbSTXlJCiMbm8Lq636KTAfuCEUO7tja+2AtxkbV/PnZZupMcYhMdZ2y3BrC5R+xvaj/A7TN3pjv/aRjarf5zFEKIxs5isbBl2dMsvHtk0OaQk1fE3fMWs+DhWxtdq5yG6N81CUtiPIcXPxjsqRgWkkp9bY600Kknbz56HwEc1FofBlBKLQcmAa7Kpk8DHgPQWteU+NVan1RKZWFNEDSeALbbSKxv6qzpigGmY7SmgDPEs3ZfFlNSuri9XQghAqqiFLL2eL7ORrGO4NnKKXZjHeIjmTW6Z72nEWOTuU3V3RnH1tqTGduBW53b+MS7b41bUFJpdxweauLa8zrWe45CCNHYbf7wFf40oR8xUcFLmLz16Y+cyTwRsFY57ioNJ8ZFGBZs8pQ1re99gdCY59ZUeRPAdgJO2BynARcYXaiU6gb0ANYYnBsBhAOH6j5NP4puAx3OtVvqdoFpL59bRrBmjwSwQohGJisVtLn2OKErzPgIgKteWE9JhdnplpM6kXLCGNMvib9OGECIUnRqHUWIqf4l/KNt9qXusvSwP5mxHbQ26EPb3u0z80sq7I7XzPkVcZHBLWYihBD+cnTXRs6LPs15vYfV+xkNzZ5Wt8x5eXIis1YFplWOu0rD9c2WNuZMZmOeW1Pl6+rNU4EVWmu7d1BKqWTgbeAOrW0qjtSen6mU2qyU2pydne3jKXmhh3258lEmazD77f5sissrje4QQojgcCyM1HEItO1FUWw39pQncVQnO32VYw0CU7q3pkdiDF3bRjcoeAUIDTERGWb9E+JcyGkXlJyBylKbG6IgIs7tMx0D2Op9tkII0dycLcgj+/tl3DNhqOeL3bDNnnqSk1fE9Q+9wun8s3b3T+ht4pykiJpWOUI0dt4EsOmAbRqyc9WYkanAMtsBpVQ88CnwF631T0Y3aa0XaK1TtNYp7doFYTNzz1/bHf46ZBugKakw80VqpvE9QggRCDtXwPJbar9+fMn+fFVhpKyCUoOb7Q3sWL+WOa7EhFsX8WTQhtPaJjitKIaj39tfHNfeWvbYhfJKi1322KRqny+EEM2J1pqNS57mmdtGotz8XvTENnu66ttNdoGp7TXVQatjsFt9/4xh1ozrjGExLp8jRGPiTQC7CeijlOqhlArHGqSudLxIKdUPaA1ssBkLBz4E3tJar/DNlP2g+yUQFl1zmKxyGaCOAfDBVlexuhBCBED2Pti7qvYr12EXRvJ5AGQZ7Cdy5OuKvtER1cuIlXMW9sAX9sexHdw+q6DUPvsaHxWGqYFZYiGEaIy2rnqT2WO60Sou2vPFbniTPa0OWv+zYq1TsFt9f2Ks9cPCxNhQycKKJsFjAKu1rgRmA18Ae4B3tdapSqnHlVITbS6dCizXWts2b5gCjAJuV0ptq/o6z4fz942wSKcs7BjTLwD8cDDHq8yGEEIERXUG1kMAm5wQSWKsbwtG2GZI9+iu9iePOyy4iXO//7XAYflwvOx9FUI0Q+n7d9LDfJiRAxtWY8Wb7Klthvb9rzbw667YBbvrtu5n6c4yUuZn1Xwt3VnGuq37Xb2sEI2CV+uztNargdUOY486HM81uG8xsLgB8wucvlfAvk9rDseG/MJL5uuwaFi5/SR3Xlr/ap1CCOEXQ6dDbBLgeQmxP/qp2lYiPq0dnn/6oP2xhwys7H8VQjR3pcVFHPvqdV6/b2yDn+Uue1pdSbj6mp5twhjbpQLM1t+zM4bFMOXdTbz37O/qVLDJV+12pCqvaCjZYFStj33Z8CHqEInkk0MCH2xNlwBWCBEcg663Vkp3FNseOg+vOcz2kIH19f5XsA9g84l1f7GnDGypfcE8CWCFEM2J1pqfFj/Dv2ZciMnU8Bqq67bu52RWGUt3ZtmNdzy1nwdvubwm+/rulDhO5xfxm6Hh3PfZWe65xGwY7BpxDFh91W5HqvKKhpIAtlp8snUvWcY2AExKMzpkGyvMv2J3RgH7Mgs5p4P7CppCCOFzSf2sXx54WkI8qJMfAtjw2lY6+drDp/F1zMDGR8mfJyFE87Hz6/eYcUEiSa19815y5XOz3Z63zdAeOFOKUjCkPQx/MY02cVFAbbDr7hnVAeuM8RcHvN2OEK7IOwRbfa+sCWDBug92hflXAHz4SzoPXeX5TaQQQgRSVkEpn6dmsmrHSbfX+XsJcQEeipFU9YC1WDSrd2VQUm5m0nmdCA+1ZiIc98BKBlYI0VxkHjtA29xfuOKqSwL2ms4Z2lAglEG9Ej0Gv+DcH/ZsWblNwajSBmdhhWgICWBt9b0Cvp1XczjKtIMIyikjnI+3pfPHK86RqphCiEajuLySq//ve3KKPFcgTk6I9Pnr1ykDW7WE+B+r97Dw+yMAfL4rk9dvty6DdsrAShEnIUQzUF5Wyv6V81l035iAvq43Qao7thWOR3cp5v0vN/D1ndbf49V7aCULK4JFAlhbyedBXDIUZgAQq0oZY/qFzywXkJFfyk+HT3Nx78QgT1IIIay+3pPlVfDaNia8Qb0GXYmuUwbWuoS4OngF+GZvFrlny2kTE+5chVgysEKIZmDj0uf4x80phIaGeL44SBz3utrunwVQlgrGdqmgVZR1xYy3e2ibihGz5pNjsA0nMS5C9us2UhLA2jKZYMC1sPHlmqFrQjbwmeUCAJZsPC4BrBCi0dhyNNdwPDzURHxkWE1w++S1g/zy+rG2RZzcZWBNoRDd1vDU2bJKawBr0AdWCCGast3rP+HaAVF0ad862FNxy7E4k+3+2ZyiShZuzCfUBJ8cSiM+pnY1j6c9tI1ddeCanlNA8tQna8ZDQxT9uyYZVkoWjYMEsI7OvcEugB1j+oVYiikims92ZXAit5gubRrWeFoIIXzBNgNqa3j31vzrpvP4IvUU57SPY0SPNv55fZslxIVEY9EKk9LOF8YkgcmE2WJwroq00RFCNCc5GccJP/49k28fFeypuOW41/W2CSPt9s/mFpbQNhryKsPp16Nzg5cmNyY5hWUMvOs5sl78I1HtOgNQUlZJcW46O4+cIiOngJ7TnwckG9vYSADrqNP50Kor5B0HIFJVMM60hQ8tl2LR8Pr3R5g7cWCQJymEEHDaxfLhQR0TSIqL5NYLu/n19W2LOGlMFBFFPMXOF1btfy2tMDudqjBbACgosW+jEx/puz9PBQUFZGVlUVFR4fliIfwoLCyMpKQk4uN9X1StoZRSNwJzgf7ACK31ZhfXXQm8AIQAC7XW84yua8kqKyvYteLfvHFv4w5ewX6va3VxpuogNSeviCl/fIGXJ0Qza1Uxix69I8izDQSNMoUQ1a4zYbGtGXjXMwCSjW1kJIB1pJS17+L3/6oZuiZkAx9aLgXg3c0neOCyviRES3ZACOF/lWYLh7LPsis9n9STBfx2dE+S4qxLuFy1zhngh4rDRmLC7f+E5OsY4pVBAFu1/7XEMIDVmC2a7w/m2I37KgNbUFDAqVOn6NSpE1FRUX7ZCyyEN7TWlJSUkJ6eDtAYg9hdwGTgVVcXKKVCgPnAOCAN2KSUWqm13h2YKTYNG995gbk3DiYivHG/V3Tc6+pYnMkouG3KS4ZF89HwTsrN0aAb7A5HheykFYUAFJebWfrz8WDMSgjRAt28cCNX/Hs9c97bzhs/HGHHifyac1kFLjKwfuj5aiQmwr4oictCTrFJAJSUG2dgf/fONqdxXwWwWVlZdOrUiejoaAleRVAppYiOjqZTp05kZWV5viHAtNZ7tNb7PFw2AjiotT6stS4HlgOT/D+7puPgpm8Y09lMn87tgj0Vj2z3uoJ9cabq4HbGMGt9gxnDYlj17SZO558N5pSFACQDa6z9QEg8B3Ksv8dDMTMx5EfeMl8BwH9/PML/XNKjpn+hEEL4yznt4/j5SG2xptSTBVw2wLok11UGtkfbwLQ1iIlwzsAairNmYI2WEKedKeGT7c49bH0VwFZUVBAVFeWTZwnhC1FRUU15OXsn4ITNcRpwgdGFSqmZwEyA6XOeZNTEaf6fXZDl5ZyiZMdqZtwd2JY59eXcK9aq46n9AC6D2+aWhQ2PjOLEogcAqKg0Yy4pID+uNeGR8rejsZIA1ohScO6NsLa2ItktoWt5y3w5oDhVUMaqHSeZPKxz8OYohGgRBnWyX2a466Q1A1tptnD6rHMAO3lYp4D1q3ZcQlyAiwA21hpwGy0hPnra+dP8fh3iaBsb0fAJVpHMq2hMgvnfo1Lqa6CDwam/aK0/9uVraa0XAAsAXlt/2HUFt2bCYjazdfmzLLx7ZLCn4jV3BZkmznnJZXDbXALYxLgIUl+bQyuAquLK6TkFxLfryMi7/hbMqQkPJIB1ZegtsO4p0NY3XOeo4wxTB9iq+wLw2ndHuG5oJ3ljJITwq4Ed7ZcDp6ZbA9jTZ8vRDm8J7x/bh5mjegZqak5LiD1lYI2WEKefKXEae+P24Q2fnBDCidb6sgY+Ih3oYnPcuWqsxdv0wcs8dE0/YqJ89+FbMDWnasOuGFUVtrbWKXIq2pQY1zz+d20uZA2sK/Edoe+VdkM3h66p+X5PRgE/Hjod6FkJIfxIKXWlUmqfUuqgUuohN9ddr5TSSqmUquPuSqkSpdS2qq9XfDWnPu1jCQup/aDsZH4puWfLyXZYPnxO+zgeHNfXrjerv0U7FnFymYF1XcQp7Yx90aebUrrQsZUs26qmlPL4tW7duga/TocOHXjkkUcaPmEbDz30EEopnnzySc8Xi6ZiE9BHKdVDKRUOTAVWBnlOQXd0x0+cH3eGIb2Sgz0V0UA/v3wvhxc/6PQlLXQaFwlg3Tn/drvDiaE/EU9RzfGC9YcDPCEhhL/YVNe8ChgATFNKDTC4Lg74X2Cjw6lDWuvzqr5+66t5RYSG0Ld9nN3Y2r1Z7ErPtxtLig/8p8OOwXKBdlHEyU0bndSTBXbHwfg5GrMNGzbUfK1ZY/0Q9ZFHHrEbHzZsWINfZ/Xq1fz2tz77zxatNcuXLwdg2bJlPnuu8B+l1HVKqTTgIuBTpdQXVeMdlVKrAbTWlcBs4AtgD/Cu1jo1WHNuDIryz5Cz4R1+O35osKciRIshS4jd6T0WErpAvrVeQbgu57qQH3izqpjTt/uz2ZmWz7mdA1PxUwjhVzXVNQGUUtXVNR3bQzwBPA38IVATG9gx3i7Qm/Pedqdr2gVheVNkmAmTAkvVUmaXGdiYqirEBgGsYyGqJFmmZefCCy+s+b6oyPoBaq9evezGXSktLSUyMtKr1/FFEGxrw4YNHDt2jLFjx/LNN9+wY8cOBg8e7NPXEL6ltf4Q+NBg/CRwtc3xamB1AKfWaGmt+XnJ07zym5GypUyIAJIMrDumEBh2m93Q3ZFfYcJSc/zwhzuoNFsc7xRCND1G1TU72V6glBoGdNFaf2pwfw+l1C9KqW+VUpf6cmLetMUJRgCrlLIr5GSYgY1qA6HhAJSUe/5d2S7Ou4BL2HvllVdQSrF161YuvfRSoqKiePHFF9FaM2fOHAYNGkRMTAxdunThtttuIzs72+5+xyXEU6dO5ZJLLmH16tUMHDiQ2NhYfvWrX7Fvn6cuK1bLli0jJiaGRYsWERYWZpiFrays5IknnqB3795ERETQuXNnZs6caXfNe++9R0pKClFRUSQmJjJhwoSaPqpCBNuWTxZx/7geJMTKtgchAkkCWE+G3Qqm2nYOHc0nGWfaXHO8K72A178/EoyZCSECSCllAp4H5hiczgC6aq2HAg8CS5VS8QbXoZSaqZTarJTa7BhEuHJxr0SP1wzt0sqrZ/naQJsqyTu1QQGpzik13xplYB3JEuKGuemmm7j++utZvXo1l19+ORaLhdzcXB555BFWr17Nc889x+7duxk3bhzasQqYg4MHD/LII48wd+5cFi9ezIkTJ7j55ps9zsFsNvPee+8xceJEunTpwrhx42qWE9u6/fbbefLJJ5k+fTqffvopzz77LIWFhTXnFy5cyJQpUxgwYADvvfcer7/+Oj169OD0aak/IYIvbd92+uhjXNRfOlIIEWiyhNiTuA4weApsW1Iz9HD853yRNxywLhd5/qv9XDGwA90TA9N7UQjhF56qa8YBg4B1VUvFOgArlVITtdabgTIArfUWpdQhoC+wGQe2rSVSUlK8ai3ROymWZ64fzNs/HaOorNLuXESoiSsHdeDyAUadMfzvmeuH8LdPUlmzL4vDuiN/qJjJ9JCvaRNSQpe+w+DqZ2quNdoD68jfS4i7P2SUPA+8o/PG++W5v//977n77rvtxhYtWlTzvdls5vzzz6d3795s2rSJESNGuHxWbm4uGzdupFu3boB1SfK0adM4evQo3bt3d3nfmjVrOHXqFFOnTgVg2rRp3HrrrWzYsIGLLroIgO3bt7NkyRJeffVVu6zrtGnWXqEVFRX8+c9/Ztq0abz11ls15ydNmuTlvwkh/KfkbCEnvlnEwtljgz0VIVokCWC9cfF9dgFs99K9jIk8wJpSa0udskoLf/5wJ0vuvED2QAjRdNVU18QauE4FatJNWut8oCYVqpRaB/xea71ZKdUOyNVam5VSPYE+gE+rvE0Z3oUpw7t4vjDAuraN5vXbh3Myr4SL563hPfNo3jOPpn18BBun2Xfs8CaADcZS6OZk/HjnwHjlypX84x//YM+ePRQU1O6l3r9/v9sAtm/fvjXBK8CAAdaaZmlpaW4D2GXLltGqVSuuvNJayX/SpElERUWxbNmymgB2zZo1mEwmbrvtNsNn7Nq1i+zsbO644w7XP6wQQaC1ZuOSZ4+8/GwAACAASURBVPj3rRdiMslCRiGCwav/53lqLaGU+pdN+4j9Sqk8m3O3KaUOVH0Z/6Vq7JL6O7XU+XvSGrvjHw+d5r3NaYGclRDCh1xV11RKPa6Umujh9lHADqXUNmAF8Futda5/Z9y4hIfa/zkpr3Te72rUB9ZRRGiIx2uEa+3bt7c7/uGHH7juuuvo1asXixcvZsOGDaxfvx6wZlTdadXKfll6eHi4x/vKysr44IMPuOqqqyguLiYvLw+z2czYsWN59913MZut/w2cPn2a1q1bExFh/IFF9TLh5GRpSyIalx1fLuc3F7WnXes4zxcLIfzCYwbWprXEOKxFTTYppVZqrWsqc2qtH7C5/j5gaNX3bYDHgBRAA1uq7j3j058iEEb+L+z/vOYwOWs9M7rewFvHa/emzf0klWHdWtE7SX6pCdEUGVXX1Fo/6uLa0Tbfvw+879fJNXKeAtiX1hxgodQL8DvHVUDvv/8+Xbt2ZcmS2lVE3hZiqo/PPvuM/Px8li1bZli4ae3atVx22WW0bduWM2fOUFZWZhjEtm3bFoCMjAwGDRrkt/kKURcZR/eRVLCTseNHBnsqQrRo3iwh9ra1RLVpWINWgCuAr6ozEUqpr4ArgabXFK7rRdB5OKRtqhn6c9hy3g27j9IK6za24nIzd7+9hY9nX+LUH1EIIZqz8BCHANamOvu+zEL++eX+QE/JkL/2njZWJSUlNZnTarbBrK8tW7aM9u3bGxZtmjx5MsuWLeOyyy5j7NixWCwW3n77be68806na88991ySkpJ48803GTdunN/mK4S3ykpLOLjqZRbdJ/tehQg2b5YQe2wtUU0p1Q3oAVSvr/Xq3vpU5Qw4pWDMI3ZDkek/8vIF9qsED2Wf5U/v7/BY3VEIIZqTCIcMbIVZY6lqELv4p2NePeOuS3v4fF4t3bhx49i/fz9/+MMf+Oabb3jssccMg0tfKCoq4pNPPmHatGmMHj3a6euGG27ggw8+oLy8nMGDBzNjxgxmz57N448/zjfffMO7777L9OnTAQgNDWXevHksWbKE22+/nU8//ZRVq1bxu9/9jh07dgDw5ZdfEhoaysaNG/3y8whha+PSf/LULcMJCZF9r0IEm6//XzgVWKG19rzRyYbWeoHWOkVrndKuXTsfT8mHeo6GXmPshkYfn8/1Q+2rf366I4NFPxwN2LSEECLYlFIus7DetM8xKbjzUoM2PKJBJk+ezBNPPMGSJUuYOHEiGzdu5KOPPvLLa3388ceUlJRw6623Gp6fPn06eXl5fPbZZwC8/vrrPPzwwyxatIirrrqKOXPmEBsbW3P9HXfcwfLly9m+fTuTJ0/m9ttv5/DhwyQmWrfuWCwWzGazfGAs/G73tx9zw6BYOrULTrsyIYQ95ekXv1LqImCu1vqKquOHAbTWTxlc+wtwr9b6x6rjacBorfXdVcevAuu01i6XEKekpOjNm506TzQeGTvg1UvthsqvfoGJP/Zkb2Zt/7pQk2L5zAtJ6d4m0DMUollSSm3RWqd4vrLpaPS/7+po0GNf2LX52f7Y5SREhfHIRztZ/NNxt/euuu8SBnVK8Pmc9uzZQ//+/X3+XCEawt1/l83xd91r6w832U8Zck4eo2DNf3jq9lHBnooQzcvF99W7dYs3Gdia1hJKqXCsWdaVjhcppfoBrYENNsNfAJcrpVorpVoDl1eNNV3Jg+HcKXZD4WvnsuD67sTZ7HuttGjuWbKVozlnAz1DIYQICleFnEK9aDURGSbL8oQQjUtlRTk73/8Xf7vl4mBPRQhhw+M7hjq0lpgKLNc2Kd2q4k1PYA2CNwGPN4vWEmP/CqFRtcclZ+i66e88N2WI3WVZhWWM/7/v+DI1M8ATFEKIwHO1hNg2K+uKtM8RQjQ2P73zAo/feB7hYVKYU4jGxKuPvLXWq7XWfbXWvbTWf68ae1RrvdLmmrlaa6cesVrrN7TWvau+Fvlu6kHUqiuMdvhRdyzn8sg9zBrdy274bLmZ+5b9wq70/ABOUAghAs9VBja/pMLjvY5FoIQQIpgObPyKy7ta6N25EddmEaKFkncM9XXRvdDeoTfdyvuZc2l7Lh9g30i+rNLCnW9uJj2vJIATFEKIwHIVwBZ4E8CGSQZWCNE4nMnOpGL3F9wyRnoQC9EYSQBbXyFhMOHfgM3+4/zjhK66n1duGcafruxnd3lmQSnXzf+BT3dkSMVEIUSz5LSEWDKwQogmxmI2s3X5s/z91pHBnooQwgV5x9AQXYbDhbPsx/asxLT1DWaN7sVvRtr3NMwqLOPepVv57eIt5Bd7fkMnhBBNiVMG1mxtn1NY6s0eWPlzJIQIvp/f/w9/mTSA6MjwYE9FCOGCvGNoqMvmQrJ98SY+/zOkbeYv4/tz9bkdnG75IvUU41/8jlU7TlJZVeRECCGaOscAtszLDGx4qAml6l1NXwghfOLwth+4oHU+5/Z0fu8mhGg8JIBtqNAIuGERhNc2X8dcBsumEVKQxr9vGsr/XNKDUJP9m7O0MyXMXvoLE178niPSakcI0Qw4ZlHLKy1Umi0eqxBHSvZVCBFkhXm55G16n7uuPC/YUxFCeCDvGnyhba+q/bA2zmbBsqmEm8/y1wkD+Px3lzKkc4LTrXszC7n6he9YsP6QZGOFEE2aUQDr1fJhKeAkRFAppW5USqUqpSxKqRQ31x1VSu1USm1TSm0O5Bz9yWKxsGnJPJ6ecbGsBhGiCZAA1lcG3wgjf2c/dmoXLL0JyoronRTHspkXcmmfRKdbSyrM/GP1Xq584Tue/3Ifvxw/I4WehBBNjtESYingJESTsAuYDKz34tpfa63P01q7DHSbmq0r3+B3l/ciPiYq2FMRQnhB3jX40tjHoN8E+7FjP8CSG6GsiOjwUN76zQgWzkhhZO+2TrcfzCri/9Yc5Lr//MgNr2xg1Y6T5BWXB2jyQgjRMEZViAtKPQewkZKBdemaa67h3HPPdXl+9uzZtGrVirKyMq+ed/DgQZRSfP755zVjnTt35qGHnNq429m2bRtKKb7//nvvJl7llVdeYeXKlU7j3rymP3z99dcopRg9enTAX7sx01rv0VrvC/Y8guHEnq2cE3KCC/p3DvZUhBBeCg32BJoVkwkmL4D/joeTv9SOH/8RFk+GactR0W24bEB7xvZP4t3NJ/j7p3soMFhit+XYGbYcO0NEqInLB3bg/K6tGNKlFf2T4+XNnhCiUXKuQiwZ2IaaNm0at9xyC7t372bAgAF258xmMytWrGDy5MlERETU+zU++eQTEhOdVwf5wiuvvEJKSgoTJ04M2Gu6s2zZMgC+++470tPT6dSpU8Dn0MRp4EullAZe1VovCPaEGqK4qJD0dW/xt9mXBXsqQog6kHcNvhYeA7d+CMkORQBObIQ3roC84wAopbhpeFe+mTOaSed1xNWWi7JKC59sP8ncT3Zz3X9+ZPDcL7nzzU0s/O4wGw6dxmyRpcZCiMbBKYA1WEJ8XpdWTvdJAOvapEmTiI6Orgm8bK1du5ZTp04xbdq0Br3G0KFD6dKlS4Oe0RRes7y8nA8++ICxY8disVh45513Avr6waaU+loptcvga1IdHnOJ1noYcBVwr1JqlJvXm6mU2qyU2rx+pfN/v8GmtWbjkqd5Rva9CtHkyLsGf4hqDTM+go5D7cdz9sPCy+DoDzVD7eIieGHqUDb+eSzP3TjEcI+srXKzha/3ZPHkp3uY9tpPDHviK65/+Ud+/9525q89yGc7M0jPK/HHTyWEEG6Fh9ivDvlmbxYrtqTZjSXGOmcKI0JlVYkrMTExXHPNNYbB1vLly0lKSmLMmDEApKenc8cdd9CjRw+ioqLo27cvjz32GBUV7rPgRst5X3zxRbp06UJMTAyTJk0iMzPT6b5nn32WlJQU4uPjad++PZMmTeLQoUM15y+55BK2b9/O66+/jlIKpRSLFy92+ZrLly9n0KBBRERE0LVrVx599FHMVb2EARYuXIhSitTUVC677DJiYmLo378/H3/8sYd/i1afffYZeXl5/PnPf2b48OGGHwoAvP/++wwfPpyoqCgSExMZP348J06cqDm/fft2xo8fT0JCAnFxcVx44YWsWbPGqzkEk9b6Mq31IIMv7/4FWp+RXvXPLOBDYISbaxdorVO01imjJjbsQxZ/2Pb5Eu4amUzbhJhgT0UIUUeyhNhfolrDrR/B8lvgmM2eoaJT8OYEGP0wXDoHTNY3bklxkVx/fmcmD+vEj4dO8/WeU3yZespjMJpfUlGz3NhWp1ZRRIWHEBFq4oIebRnQMZ64yFDMFk1YiIme7WI4W1ZJx1ZRhm8ohRCirhwzsOv3Zztd0y4u3GksMiyAn6XOda4GHxRz872+dNq0abzzzjts2bKF888/H4CKigo++OADbrnlFkKqPjjIzs4mMTGRf//737Rq1Yq9e/fyt7/9jZycHObPn+/1673//vvcf//93HvvvVxzzTWsXbuWu+66y+m6tLQ07r//frp27Up+fj4vv/wyI0eO5MCBA8TFxbFgwQKuvfZa+vfv///t3Xl8VOXZ8PHfNVsWSIAEEkAR5MUFsCKKPgLFBXdrtVoR0KqlUutrbX3ax/q6PEXEqo+0bq3L41JqtQouuFatu9W2gEUBFyhKARGIbAESss12vX+ckzAzmewzmUxyfT+f85mzzTnXPWdy59xzL4drr70WgBEjRiQ95yuvvML06dOZMWMGv/nNb1i+fDmzZs2ivLyce+65p9Hncemll3L11Vdz1113MXXqVNatW8egQYOaTdf8+fMZOHAgxx13HNOnT+fnP/85a9asiYvpkUceYcaMGVxwwQXccMMNRKNR3nrrLbZv386QIUP47LPPmDhxIqNGjeKBBx6gqKiIpUuXsmHDhlZ/vtlKRHoBHlWtdOdPBuZkOKx2KVv3LwZXreL4wyZkOhRjTDtYATad8vrChc/Ccz+Cz57bu16j8M7NsPoVOOPOuJpaEWHiiP5MHNGf//7WKD7asJPlG3ax/KtdLNuwk827a1t16tiC72ebK5rdN+D1oCj5AR8lBTkEI1EOKCng6OFF7KgKsrWiDhHYt18e4YjSN99PYZ6fSFQp6hWgsjbMntoQQ4t7cdDAAnZWB6kJRghFlMF9c6msDbOrOkR5dZDtlXX4vMLw/r05sLQ3Ho8gQF7Ay1flNfTr5WdA7xzKdtdSHYywb788tlTUEgxHGVCQQ588P3XhKFV1YYKRKEW9AnhFWFlWwcadNfg8wpHDiujXy7lJ3l0TYld1EI8IhXl+guEoffL8BHweolElFI021P7UhiLsrA7i83gI+DxsrahlUN88euc4fyaqmrSZUTSq1IYj5Ad8cfuoKhU1TpzFvQJ4PEJtKEJVXZioQu8cH7l+T8P+lbUhakIRcv1ePly/k3365XFgaUGT1602FGFbZR3lVUGG9e9Fnzx/3HZVZVd1iN7uDxfQ/GA5taEIlbVhCnJ95Pg8fF1RS1VdmKHFvQhHFI/H+a4s+2oX67dXMahPHmOG9GFPXZi6UJTeOT48IlTWhSgtzEWAqmCEHJ8n7rz1I2xbk63uJ7EAm0xxL6uBbavTTjuNvn37smDBgoYC7GuvvcbOnTvjmg8fdthhHHbY3u4rEydOJC8vj8suu4y7774bn691//JvvvlmzjjjjIaC4ymnnMKWLVt45JFH4va7++67G+YjkQgnnXQSAwYM4KWXXuL8889n1KhR5OfnM2DAAI4++uhmzzlr1ixOPPFE5s2bB8Cpp55KNBpl1qxZXH/99XGF06uuuoqLLrqoIc0DBw7k5ZdfZubMmU0ev6qqipdeeolLLrkEj8fD1KlTueqqq5g/fz6//OUvG9JwzTXXMGXKlIaaYiCu/+7s2bMpLi7mvffeIzc3F4CTTz652bRlAxE5G/gdMAB4WUSWq+opIjIYeFhVTwdKgefcvNsHPKGqf2nyoF1UXW0Na17+X/7wkxMyHYoxpp2sAJtuvhz47jwoGg7v3x6/bfMyeGgyHPlDmHw95MbXDHjdwtiRw4oA58b/ow27+Mea7fx72x7eXLWVPXUtP2OxJUH3+bO7a0IN/dW+3FHNm6u2dPjYqeYRiO32W18GSnzqUGlhDtV1ESqTfD4+j5Af8FJZF0bVqa3O9XvYUF5NKBJ/oIDXw9DifL6uqKWyNkyOz4MCKISjUfL8XiKq1Iai9Ap4qQlF8Hk9FOb6qA5GqA46zd/yA148Io2ul9cjeAQiUSVZd+b6wnYwHCUaVQYU5lATjLCjKkgwvPe5wR6BYrcmXdU5Vk0wQk0oEne8ESW9yfN72bizGsXZRwTyAz7Kq1I34rXHvS71aeqb76cuFMXnFaqDEaKqBLzODwUv/2QS+xXnp+zcJnNa05d1UN/cxu/rzBrYLBQIBDjnnHN46qmnmDt3LiLCk08+ydChQxk/fnzDftFolDvvvJOHH36Y9evXU1u79wfPjRs3MmzYsBbPFQwGWbFiBZdffnnc+nPOOadRAfYf//gHs2bNYtmyZZSXlzes//zzz9uUvlAoxPLly7nvvvvi1k+dOpXrr7+exYsXc/bZZzesjy0wlpSU0L9/fzZujG+qnuiFF16gurqaadOmATB48GAmTZoUV4BduXIlW7ZsYcaMGU0e5+2332bmzJkNhdfuQlWfw2kSnLh+M3C6O78WGNPJoaXc4sfnMveCo/B6Ld8xJltZAbYzeDxwwiwYOgGe/RFUb9+7TaPwwQPw2bNwzNVwxPfB17iJHTg1VkcM7ccRQ/sBTqFn864a1m2vYt32KtZu28PHm3azbMOuTkhUZiQW8pp6XO6WiqYfKRGOatzIz8010w5GonyxdU/Dcl1MoRGcGsbE+WA4yvY98YXB6mB8QbJeJKok3+JIHACnclvyHyyiCtsqW36MxpqYtMSqDaX2cU2J12lXtZuOmOTUhaPUhaN4vVYT2120pgA7sLDxjb/XY9+BlkyfPp158+axaNEiDj/8cF544QUuv/zyuJYMt99+O9deey3XXXcdkyZNom/fvixevJif/vSncYXZ5mzdupVoNEpJSUnc+sTldevWccoppzBhwgQefPBBBg0aRCAQ4JRTTmn1uWLPGYlEKC0tjVtfvxxbOAbo2zd+ILBAINDiOefPn8/gwYMZOXIku3Y5/yO//e1vc9VVV7FixQrGjBnDjh07AJpsiqyqlJeXt9hU2XRdn77zHNMO68PgAV2kK4Expl2sANuZRpwI//fv8OrVsDJhzISqbfDqL2DRPTD+xzBmOuQWNns4r0cYUpTPkKJ8jjlwQMP6HXucZqVRhc+3VPLhlzvZVR2ksjaMApt21lC2u4b8gI9te+psJGOTUYnPDs0kETkVuBvw4jSb+58m9vsu8AxwpKouddddC1wCRICfquprnRN119GaJsQlBY0LsJ7ObE7ehr6nXcnxxx9PaWkpCxYsoKysjMrKykajDz/99NNMmzaNOXP2dkv8+OOP23SekpISPB4PW7dujVufuPzqq69SV1fH888/T15eHuDU3tYXDtt6Tq/X2+gcW7Y4rYCKiorafMxY5eXlvPbaa4RCoaTHmj9/PmPGjKG42Hk+e1lZWVxT7HoiQlFREWVlZR2Kx2TGto3r6F22hDNOmpTpUIwxHWQF2M5WMBDOexS+eANe/i/Y9WX89l1fOgXct26Cw86HcTOgZGSbTlHcO6ehOelBAwv49pjBTe4biSrhaBRVKNtdy9aKWnbVhPh00252VAUpyPGxf/9e7K4J8e9te8jze9leFSQSUfICXnZVBynM81MTjLD8q11UByPs0zeP/Bwv0aiydnsVhbl+9ivKp1eOj0F9cqkORlhVVkHZ7hoUqAtFqQlF6N87h9pQpFEz2/69c+id42XTrhpCESXg85Af8OLzSENNZ//eORw0sDcrN1ews3pvNV/A66GkMIdoVNldE8Ln9cTVaorE1+IWuv1Fq5qoMW2rxKbDXo9QmOtDRKiqC8fV6Aa8HqKqhFv5g4LPI/TJ8yMibN/Tcu1rS+pjq6gNE4lqQ/PoYDiKzyMouIOAOX2Yq4JhNu6swe8VinvlUB0ME4ooitOkGmhoVt1cklpT6OkMIuIF7gVOAjYC/xSRF1V1ZcJ+BcCVwJKYdaOAacBoYDDwpogcqKqp+SJlidb8GFFS2LgPrNW/tszr9XLeeefx9NNPs2nTJkaOHMmYMfGtOWtqaho9D/bxxx9v03kCgQCHHnooL7zwQlyf0meffbbRubxeb1y/2gULFhCNxrdSaU3tqN/vZ+zYsTz99NNxg0U99dRTeL3eFvvPtmThwoWEQiH+9Kc/NXru669+9SsWLFjArbfeyqhRoxg4cCB//OMfOe2005Ie64QTTmDBggXMmTOnQ8/eNZ0rFKzjs+d/yyNXHJ/pUIwxKWAF2Ew54CT48RJ4/w6n1jVUHb89WOk0Lf7gAeh/EIw6C0adCaWH0ORDY9vB6xG87kjI+/fvxf79neHkTxk9MGXnaEk0qgQjUXL93oaBh/ICXgJeD3XhKHkBJz6nn6gzinK9UCSKR6ShCWI4EmVDeTVet3BXmOvHk9A8saI2RDiiFOb6CEeVtduq2LizmsF98xg92Kn1jqrTj3P9jmqq6sL0zfczqE8ewXC04eP3eoQ9blPkPnl+dteE6JXjFIAra0N4PEKxO5jUtj11BLyeRvGEIs6PB7F9YauCkYaCZEVNiIDPQ8DrIaLKV+XVFOT6G/rt1jcf3FkVpC4cxSNOLYFHwOfxUJDr46ud1QR8HrweYe22KnweYXDfPHL9XgI+D7WhCLtrQuzbL48cn/PDg7rpi0S14UcKn8cpiOf6vfi9HmeQKrdfcOwgTdGo8nVFLb0CPvrk+6kLO8fPD/iIRJQcvwe/1+nXGwxHKcztMtnQUcAat58XIrIAOAtYmbDfTcBtwC9i1p0FLFDVOmCdiKxxj7co7VF3IS39GCFCw99ErE6tgc1i06dP53e/+x3PPfccN954Y6PtJ510Evfffz/jxo1j+PDhPProo6xfv77N57nuuus477zzuOKKKzjzzDN5++23efPNN+P2OeGEE7j66quZMWMGM2bM4JNPPuHOO++ksDC+5dDBBx/MO++8w+uvv05RURHDhw9PWgt644038q1vfYuZM2cyZcoUVqxYwezZs7nssss63GR3/vz5HHLIIVxwwQWNtm3dupWpU6eyaNEiJkyYwG233cbFF19MIBBg6tSpALz11ltceOGFjB07lhtvvJGjjjqKY489lp/97GcUFxfz0UcfUVpaysUXX0wkEiEnJ4c5c+Zw3XXXdShukzpLnryLm84bi98GjDOmW+gyd449kj/PGbzpyJnw3q/hw0cgmuR5fdtXw3tznanXABj2TRg2CfY/BopHpLRAmwkej5DrFqJFpGEEYaCh8ApuYTuhrsafUOPj83oYPqB3s+crzN07Wq/PC6MGFzJqcPxNV323zPoCfbJ4gLhYm4obkjebTB6/0CfPWdcnz99oZOGmHnnUL0mhoN7Q4r1pSBZH7xxf3HFjC9hejzTU5gMUxHx2ItIovvr3D+6b17Cc4/NSUtD4piEv4G30OWXYPsBXMcsbgf+I3UFEDgeGqOrLIvKLhPcuTnhvfFVPD9DSaMLFvXLwJamlTfyRySQ3fvx4hg0bxvr16xs1HwanELhjxw6uu+46RIRzzz2XO++8k+985zttOs+UKVO46667mDt3LvPmzWPy5Mk89NBDcbWShx12GL///e+ZM2cOCxcuZOzYsSxcuLDRuWbNmsWmTZuYMmUKFRUVPPbYY3zve99rdM7TTz+dJ554gptvvplHH32UkpISrr76ambPnt2m2BOVlZXx17/+lVtvvTXp9jPPPJPCwkLmz5/PhAkTuOiii8jPz+eWW27hySefpKCggPHjxzNggNNNZ+TIkbz//vtcc801DSMajx49mltuuQVw+slGIpFGNdEmc1Yveo3ThwvDBxdnOhRjTIqINjUKToaMGzdOly5dmukwMqPya1j6B1g6D6q2trw/OAXagYfCwG8406AxzojHni5VMDCmw0TkQ1Udl8bjnwucqqoz3eULgf9Q1SvcZQ/wNvB9VV0vIu8CV6nqUhG5B1isqn9y9/098KqqPpPkPJcClwLst99+R3z55ZeJu2StZRt2cvZ9/2hy+6hBhbxy5SSGXfNy3PoL/mM/bj77G2mJadWqVYwc2bZuGMakW3Pfy3TndZnw0HtrM3KzWb51M1teuYM7ZlrTYWO6nAk/afev162qgW3NwCYich4wG1Bghaqe766fC3wL8ABvAFdqVys1dxUFA+H4a2HSz51BnlYsgHV/hWgzj8qp2gb/fsuZ6vnzYcBB0Hco9BsKffdz5vsOhT77QsAeWWJMEpuAITHL+7rr6hUAhwDvuk23BwIvisiZrXhvA1V9EHgQnB/sUhV8VzByUGFD0/NkBhQkb0FgTYiNMakWCYdZ/uRvmHe5DdpkTHfTYgG2NQObiMgBwLXARFXdKSIl7voJwETgUHfXvwHHAu+mMhHdji8HDj3PmarLYfWrsOpFWP83CCZ/DEqcULXzjNnNy5Jvz+0DBYOgdynk9YOcAmddTqEz8nFOobvOnc/t4yznFIK/ez37zpgY/wQOEJH9cQqf04Dz6zeq6m6gf/1yQg1sDfCEiNyBM4jTAcAHnRh7l5Dr9zJiQG9Wb6lMur2kyQJsOqMyxvREHyy8l/8++xDycpruYmOMyU6tqYFtzcAmPwTuVdWdAKpa3/5VgVwggDPQpB/YkprQe4j8Ihh7gTNFwlC2HNa95xRmNyyGUFXbj1m725m2/avt7/UGnBpef75TmPXlOX156ydvAMTjNGEWb/yrxwseX8zUwrJ43En2zhMzH7c9YX2j/YT2j3Xq1iY11XCg/tgNh5eYfskSf+6W5hu9L9kxoMm0xB0n5nNpSEpsGhLTE/s+T5J5EtbXHzsm1mgENOK+asJ2dgAAD5hJREFURp1XNP449fHULxfuC97Md8dX1bCIXAG8htPaZJ6qfiYic4ClqvpiM+/9TESewskXw8CPe9oIxPVGDy5ssgDbKyf5dRargTXGpNDaZe8zsXgPo4eNyHQoxpg0aM1dY4sDmwAHAojI33Fu/Gar6l9UdZGIvAOU4dxx36OqqxJPkNAnrM2J6DG8Pth3nDNN+rlToN2xBr7+BL7+2JnKPoaa8paP1V6RoDPVtv1Zf8Yk9bOV0KdrjHekqq8ArySsm9XEvsclLN8M3Jy24LLEyEGFsCxp6+kmWRNiY0yqVOzcTsXS5/jBZZMzHYoxJk1SVe3hw2kydxxO36/3ROQbOM3tRrrrAN4QkUmq+n7sm7tzn7C08vqg5GBnOnSKs04VKsugfJ3zTNmdX8KuDc78rg3Otub61BrT2WJriE3WSxy5O1a//ORN+fLTPBq1qlotr+kybBiQ9IlGo3z4xFwemDnR/uaN6cZaU4BtzeAkG4ElqhrCeQbi5+wt0C5W1T0AIvIqMB54H5MeIlA42JmY2Hh7NArVO5yC7J4tTlPiugqorXBe6yr3zjesi5m3wq9JNbvJ6FYmjChueC5yLI/AueOc3zIvPWY4D763FnAu/4Xjh6YtHr/fT01NDfn5Nnid6Rpqamrw+xs/gsx03IcvPMTPTh1BQS8br8OY7qw1BdhmBzZxPQ9MB/4gIv1xmhSvBYYDPxSRW3GaEB8L3JWi2E17eDzQe4AztZUqhGqcKVwDoVpnwKiw+xqqdZoXJ/aBrF+OhmNe3SluW7jxPqrOcVCn8I3uXRc7EbtOE17r92lTYonrZxrbHzVxP1Xi+8kmzMf+2t4wr0nmW3OMhPm4eGKOozHLGk0oJCZLF/GfdXPzDevq56N7Y2ro8+zZ2/cZSXKc6N5jeDLf/9WkTn7Ax11TD+M3r68mEnVqPiPRKJd8c3/2cZ8PfNmx/4eNO6tZu62KS765P6WF6bvZLCkpYdOmTeyzzz7k5eVZrYzJGFWlpqaGTZs2UVpamulwup0Nqz5ktL+MIw86MtOhGGPSrMU7x1YObPIacLKIrAQiwC9UdYeIPANMBj7BuaX+i6q+lK7EmDQTcR7BY4/hMcY04/iDSzj+4JImtxf1CnDfBUd0SiyFhYUAbN68mVAo1MLexqSX3++ntLS04XtpUqO6soKydx9jzhUnZjoUY0wnaFXVR0sDm7jPdf25O8XuEwF+1PEwjTHGmPYpLCy0AoMx3ZSqsuTx27jn4gnWwsKYHsJGTzHGGGOMMVlp+auPcdmx+1BU2PQAcsaY7sUKsMYYY4wxJutsXruSIbVfcMw30jcQnDGm67ECrDHGGGOMySq11VWsfeUB/t+5R2U6FGNMJ7PhP40xxhhjTFZZ/MSvuf3Co/F4rC7GmJ7G/uqNMcYYY0zW+OSthVxweD8GFtvgbMb0RFYDa4wxxhhj0qZ/QSBlx6qprqJ/1RpOP2dyyo5pjMku4jwBp+sQkW3Al214S39ge5rC6Yosvd2bpbdpQ1V1QDqD6WxtzO/su9G9WXq7tx6d13UFInKpqj7YU89vMVgMXTGG9upyBdi2EpGlqjou03F0Fktv92bpNU3paZ+Vpbd7s/Sazpbpa5Dp81sMFkNXjKG9rA+sMcYYY4wxxpisYAVYY4wxxhhjjDFZoTsUYLOy7XYHWHq7N0uvaUpP+6wsvd2bpdd0tkxfg0yfHyyGehaDoyvE0C5Z3wfWGGOMMcYYY0zP0B1qYI0xxhhjjDHG9ABZXYAVkVNFZLWIrBGRazIdTzqIyHoR+URElovIUnddkYi8ISJfuK/9Mh1ne4nIPBHZKiKfxqxLmj5x/Na93h+LyOGZi7x9mkjvbBHZ5F7j5SJyesy2a930rhaRUzITdfuJyBAReUdEVorIZyJypbu+217jdLC8zvK6zEXePpbXWV6XSSIyxb0OURFpcpTVZPlOBmJIW/7e2jxURCIxf5cvpujczaZLRHJE5El3+xIRGZaK87Yxhu+LyLaYtM9M8fkb5YMJ29OeD7QihuNEZHfMZzArDTEcKyKakOfv78b123YdVFWzcgK8wL+B4UAAWAGMynRcaUjneqB/wrq5wDXu/DXAbZmOswPpOwY4HPi0pfQBpwOvAgIcDSzJdPwpSu9s4Kok+45yv9c5wP7u992b6TS0Mb2DgMPd+QLgczdd3fYap+EztLxOLa/LdPwpSq/ldd3oGnflCRgJHAS8C4xrZr9G+U5nxpDu/L21eSiwJ8VpbzFdwOXA/7rz04AnMxDD94F70vg9bJQPJmxPez7QihiOA/6crs8g5jxvA3935/sAnwF/bm9en801sEcBa1R1raoGgQXAWRmOqbOcBfzRnf8j8J0MxtIhqvoeUJ6wuqn0nQU8qo7FQF8RGdQ5kaZGE+ltylnAAlWtU9V1wBqc733WUNUyVf3Ina8EVgH70I2vcRpYXuewvC6LWF5neV0mqeoqVV2dBTGkO3/PVB7amnTFxvYMcIKISCfHkFatyAfTng+0MS9OpxuACSJyMvAUEAKmqWqkPQfL5gLsPsBXMcsb3XXdjQKvi8iHInKpu65UVcvc+a+B0syEljZNpa87X/Mr3OYj82Ka+HSr9LrNg8YCS+iZ17i9espnYnldz/g7sLzO0a3SnMWS5TudKd3fg9bmobkislREFotIKgq5rUlXwz6qGgZ2A8UpOHdbYgD4rpsnPSMiQ1J4/tboKvnAeBFZISKvisjodJxAVd8H3gSeAw4BzlDVPfXbReR+t4tJq0YX9qUjSJNS31TVTSJSArwhIv+K3aiq2tqLnY26e/pc9wM34fwjvQm4HfhBRiNKMRHpDSwE/lNVK2J/ZO0h19i0zPK6bpw+l+V13f8adxoReRMYmGTT9ar6QisP0yjfcWusOjOGDmkuhtiFFr5/Q93PYTjwtoh8oqr/TnWsXdBLwHxVrRORH+HUCE/OcEyd7SOc67/H7aP6PHBAms61BjgRuFJVNyZsm4/TzeTr1hwomwuwm4DYX0r2ddd1K6q6yX3dKiLP4TSJ2CIig1S1zG1qsDWjQaZeU+nrltdcVbfUz4vIQzh9AqCbpFdE/Dg3dI+r6rPu6h51jTuoR3wmltd1/78Dy+u6/zXuTKp6YgqOkSzfaXUBNgUxdPh70FwMItKqPDTmc1grIu/itCDoSAG2Nemq32ejiPhw+kXu6MA52xyDqsae72GcPsOdKeP5gKpWxMy/IiL3iUh/Vd2eyvO4LRx+gNMX+RKczzs2jvfc/Vp1vGxuQvxP4AB3FKsATgfwlIyc1lWISC8RKaifB04GPsVJ58XubhcDnfIrXydqKn0vAhe5o7YdDeyOaRqTtRL6O5yNc43BSe80cUbq2x/nF7EPOju+jnD7s/weWKWqd8Rs6lHXuIMsr3NYXpflLK/r/tc4mzST73SmdOfvLeahItJPRHLc+f7ARGBlB8/bmnTFxnYu8LaqprKFQosxJORJZ+L0Xe9MGc8HRGSgm38hIkfhlA1T+UMCInIScC/wQ+Ay4GgROa1DB9U0jzqVzgln9K7PcX4luj7T8aQhfcNxfqlYgTNa1/Xu+mLgLeALnPbkRZmOtQNpnA+U4XTm3ojzq0zS9OGM0nave70/oZmRBbvq1ER6H3PT8zFOZjYoZv/r3fSuBk7LdPztSO83cZoLfgwsd6fTu/M1TtPnaHmd5XUZT0MK0mt5XTe6xl15wvmBZCNQB2wBXnPXDwZeceeT5judGYO7nLb8vZnv3zjgYXd+gvsdXOG+XpKiczdKFzAHONOdzwWexmlW+gEwPA3fg5ZiuNW99iuAd4CDU3z+ZPngZcBl7va05wOtiOGKmM9gMTAhxecfDewCfhWz7g2aGHEZp7V7i8cVd2djjDHGGGOMMabD3L7lS3Bqw6dqfald5BjgrzgDOb2c8B5V1RbbEVsB1hhjjDHGGGNMRrW2AJvNfWCNMcYYY4wxxmQxEXlYRDa68xtF5OFm97caWGOMMcYYY4wx2cBqYI0xxhhjjDHGZAUrwBpjjDHGGGOMyQpWgDXtIiKzRUSbmL6XgXhURK7o7PMaY7o3y+uMMcaYrsWX6QBMVtsNnJpk/ZrODsQYY9LI8jpjjDGmi7ACrOmIsKouznQQxhiTZpbXGWOMMV2ENSE2aSEiw9ymbueLyGMiUikiW0XkhiT7ThaRJSJSKyJbROQ+EemdsE+xiDwgImXufqtF5D8TDuUVkVtEZJt7rntFJCfmGH3dYbo3u8fYICIPpekjMMb0AJbXGWOMMZ3LamBNh4hIo++QqoZjFn8N/Bk4FzgGuEFEtqvqve77RwN/Ad4AvgsMAf4HGI7bZE9E8oB3gRLgRuBfwAh3ivVfwNvA94BDgVuBL4G57vY7gAnAz4Cv3XMd0960G2N6DsvrjDHGmK7BngNr2kVEZgONahhc+7uv64A3VPXkmPc9BJwODFHVqIgsAI4ADlbViLvPecCTwARVXSQiPwLuBw5X1eVNxKPA+6p6TMy654GBqnq0u/wp8ICq/q696TbG9CyW1xljjDFdi9XAmo7YDZyYZP1mYLA7/1zCtmeBmcC+wAbgKOCZ+hs610IgDHwTWARMBpY1dUMX4/WE5ZXAuJjl5cAvRCQCvKmqn7dwPGOMAcvrjDHGmC7D+sCajgir6tIkUzBmn60J76lfHhTzuiV2B/cGbwdQ5K4qBspaEc+uhOUgkBuzfAXwPDALWC0iX4jItFYc1xjTs1leZ4wxxnQRVoA16VbSxHJZzGvcPiLixbmRK3dX7WDvTWC7qeouVf2pqg4ExgBLgMdFZFRHj22M6fEsrzPGGGM6gRVgTbqdnbB8Ds6N3EZ3eQlwtnsjF7uPD/ibu/wWMFZEDk1VUKr6MfALnL+Bg1N1XGNMj2V5nTHGGNMJrA+s6QifiBydZP1XMfOjReQBnL5exwCXAFeqatTd/itgGfC8iNyP01/sNuA1VV3k7vMo8GPgdXdAldU4g6ccqKrXtDZYEfkbTj+1TwEFfghUAR+09hjGmB7J8jpjjDGmi7ACrOmIPjgDjyT6JfAnd/5q4Aycm7pa4CbgnvodVfUzETkNuAVn0JMKYL77vvp9akVkMs4jJ+YAhcB64L42xrsI+D4wDIjg3Eyepqobm3mPMcZYXmeMMcZ0EfYYHZMWIjIM59ES31bVP2c2GmOMSQ/L64wxxpjOZX1gjTHGGGOMMcZkBSvAGmOMMcYYY4zJCtaE2BhjjDHGGGNMVrAaWGOMMcYYY4wxWcEKsMYYY4wxxhhjsoIVYI0xxhhjjDHGZAUrwBpjjDHGGGOMyQpWgDXGGGOMMcYYkxWsAGuMMcYYY4wxJiv8f/SJvz9kVUNpAAAAAElFTkSuQmCC\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": [
+    "## Building complex models \n",
+    "\n",
+    "### Using Keras functional API\n",
+    "\n",
+    " * For building mroe complex models, with multiple inputs, multiple outputs,, fusion, etc."
+   ]
+  },
+  {
+   "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": [
+    "### Subclassing `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": [
+    "### Customizing Keras Layers\n",
+    "\n",
+    " * Define `__init__()`\n",
+    " * Define `build()` for late-variable creation\n",
+    " * Define `call()`\n",
+    " * Define `get_config()` for serialization"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "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=None):\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": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "WARNING: Logging before flag parsing goes to stderr.\n",
+      "W0711 10:30:12.170183 140034806978304 deprecation.py:323] From /home/vahid/anaconda3/envs/tf2.0-beta/lib/python3.7/site-packages/tensorflow/python/ops/math_grad.py:1250: add_dispatch_support.<locals>.wrapper (from tensorflow.python.ops.array_ops) is deprecated and will be removed in a future version.\n",
+      "Instructions for updating:\n",
+      "Use tf.where in 2.0, which has the same broadcast rule as np.where\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Model: \"sequential\"\n",
+      "_________________________________________________________________\n",
+      "Layer (type)                 Output Shape              Param #   \n",
+      "=================================================================\n",
+      "noisy_linear_1 (NoisyLinear) multiple                  12        \n",
+      "_________________________________________________________________\n",
+      "dense (Dense)                multiple                  20        \n",
+      "_________________________________________________________________\n",
+      "dense_1 (Dense)              multiple                  20        \n",
+      "_________________________________________________________________\n",
+      "dense_2 (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": [
+    "## Estimators\n",
+    "\n",
+    "### 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": [
+    "### 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": "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": [
+    "### Estimator -- MNIST dataset"
+   ]
+  },
+  {
+   "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": [
+    "### Converting a Keras model to an estimator"
+   ]
+  },
+  {
+   "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.3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}