Train a model.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Train a model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Limited tf.compat.v2.summary API due to missing TensorBoard installation\n",
      "Limited tf.summary API due to missing TensorBoard installation\n"
     ]
    }
   ],
   "source": [
    "import tensorflow as tf\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Be sure to used Tensorflow 2.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "assert hasattr(tf, \"function\") # Be sure to use tensorflow 2.0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Start by creating a simple model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Flatten\n",
    "model = tf.keras.models.Sequential()\n",
    "# Add layers\n",
    "model.add(tf.keras.layers.Dense(256, activation=\"relu\"))\n",
    "model.add(tf.keras.layers.Dense(128, activation=\"relu\"))\n",
    "model.add(tf.keras.layers.Dense(2, activation=\"softmax\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Setup the optimizer,  loss function and one metrics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# The loss method\n",
    "loss_object = tf.keras.losses.SparseCategoricalCrossentropy()\n",
    "# The optimize\n",
    "optimizer = tf.keras.optimizers.Adam()\n",
    "# This metrics is used to track the progress of the training loss during the training\n",
    "train_loss = tf.keras.metrics.Mean(name='train_loss')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Create a method which used autograph to train the model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "@tf.function\n",
    "def train_step(image, targets):\n",
    "    with tf.GradientTape() as tape:\n",
    "        # Make a prediction\n",
    "        predictions = model(image)\n",
    "        # Get the error/loss using the loss_object previously defined\n",
    "        loss = loss_object(targets, predictions)\n",
    "    # Compute the gradient which respect to the loss\n",
    "    gradients = tape.gradient(loss, model.trainable_variables)\n",
    "    # Change the weights of the model\n",
    "    optimizer.apply_gradients(zip(gradients, model.trainable_variables))\n",
    "    # The metrics are accumulate over time. You don't need to average it yourself.\n",
    "    train_loss(loss)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Train the model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loss: tf.Tensor(0.1528348, shape=(), dtype=float32)\n",
      "Loss: tf.Tensor(0.0039809044, shape=(), dtype=float32)\n",
      "Loss: tf.Tensor(0.0005385667, shape=(), dtype=float32)\n",
      "Loss: tf.Tensor(0.00018396397, shape=(), dtype=float32)\n",
      "Loss: tf.Tensor(0.000104101564, shape=(), dtype=float32)\n",
      "Loss: tf.Tensor(7.665776e-05, shape=(), dtype=float32)\n",
      "Loss: tf.Tensor(6.355264e-05, shape=(), dtype=float32)\n",
      "Loss: tf.Tensor(5.551449e-05, shape=(), dtype=float32)\n",
      "Loss: tf.Tensor(4.9656337e-05, shape=(), dtype=float32)\n",
      "Loss: tf.Tensor(4.493916e-05, shape=(), dtype=float32)\n"
     ]
    }
   ],
   "source": [
    "for epoch in range(0, 10):\n",
    "    for _ in range(0, 10):\n",
    "        # Create fake inputs with two class\n",
    "        # Create fake inputs\n",
    "        inputs = np.zeros((2, 30))\n",
    "        inputs[0] -= 1\n",
    "        inputs[1] = 1\n",
    "        # Create fake targets\n",
    "        targets = np.zeros((2, 1))\n",
    "        targets[0] = 0\n",
    "        targets[1] = 1\n",
    "        # Train the model\n",
    "        train_step(inputs, targets)\n",
    "    print(\"Loss: %s\" % train_loss.result())\n",
    "    train_loss.reset_states()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# IMPORTANT\n",
    "Because we used graph mode during the training we can't anymore used the model with model.predict but only in eager mode."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "error===> Unknown graph. Aborting.\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    input_ = np.zeros((1, 30)) + 1\n",
    "    model.predict(input_)\n",
    "except Exception as e:\n",
    "    print(\"error===>\", e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However, we can still used the eager mode!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: id=1312, shape=(1, 2), dtype=float64, numpy=array([[5.99319538e-05, 9.99940068e-01]])>"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "input_ = np.zeros((1, 30)) + 1\n",
    "model(input_)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}