Introduction to Tensorflow 2.0 .ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import tensorflow \n",
    "\n",
    "import tensorflow as tf\n",
    "import warnings\n",
    "import matplotlib.pyplot as plt \n",
    "warnings.filterwarnings('ignore') \n",
    "import datetime, os\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'2.0.0'"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# check version of tensorflow \n",
    "\n",
    "tf.__version__ "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The first phase is data ingestion and transformation.\n",
    " Here, we take mnist dataset from tensorflow and then split it into training set and test set.\n",
    " Training set trains the model and test-set will test how accurate the model is.\n",
    " We divide them by 255 because the value of data ranges from 0 to 255.\n",
    " Now by dividing it, the range is between 0 to 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# load the dataset\n",
    "\n",
    "mnist = tf.keras.datasets.mnist\n",
    "\n",
    "# split into train and test\n",
    "(x_train, y_train), (x_test, y_test) = mnist.load_data()\n",
    "\n",
    "#set class names \n",
    "class_names = [\"0\",\"1\",\"2\",\"3\",\"4\",\"5\",\"6\",\"7\",\"8\",\"9\"]\n",
    "\n",
    "#normalize the images\n",
    "x_train, x_test = x_train / 255.0, x_test / 255.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.imshow(x_train[11])\n",
    "plt.show() "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The code written below describes the model building phase.\n",
    " Here we use a sequential layer in the model which means a sequence of the layer.\n",
    " Flatten reduces the dimension of the model and dense adds layer of the neuron.\n",
    " Each layer needs an activation function which is relu and softmax."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create teh model\n",
    "model = tf.keras.models.Sequential([\n",
    "  tf.keras.layers.Flatten(input_shape=(28, 28)),\n",
    "  tf.keras.layers.Dense(128, activation='relu'),\n",
    "  tf.keras.layers.Dropout(0.2),\n",
    "  tf.keras.layers.Dense(128, activation='relu'),\n",
    "  tf.keras.layers.Dropout(0.2),\n",
    "  tf.keras.layers.Dense(10, activation='softmax')])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then compile the model with an optimizer and a loss function.\n",
    " Then, we train the data so that our dataset gives accurate results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "#compile the model with optimizer and loss function\n",
    "model.compile(optimizer='adam',loss ='sparse_categorical_crossentropy',metrics=['accuracy'])\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train on 60000 samples, validate on 10000 samples\n",
      "Epoch 1/7\n",
      "60000/60000 [==============================] - 13s 214us/sample - loss: 0.3087 - accuracy: 0.9073 - val_loss: 0.1232 - val_accuracy: 0.9624\n",
      "Epoch 2/7\n",
      "60000/60000 [==============================] - 9s 147us/sample - loss: 0.1480 - accuracy: 0.9543 - val_loss: 0.0993 - val_accuracy: 0.9697\n",
      "Epoch 3/7\n",
      "60000/60000 [==============================] - 9s 143us/sample - loss: 0.1164 - accuracy: 0.9640 - val_loss: 0.0853 - val_accuracy: 0.9742\n",
      "Epoch 4/7\n",
      "60000/60000 [==============================] - 8s 141us/sample - loss: 0.0981 - accuracy: 0.9690 - val_loss: 0.0795 - val_accuracy: 0.9744\n",
      "Epoch 5/7\n",
      "60000/60000 [==============================] - 9s 149us/sample - loss: 0.0842 - accuracy: 0.9734 - val_loss: 0.0824 - val_accuracy: 0.9744\n",
      "Epoch 6/7\n",
      "60000/60000 [==============================] - 9s 142us/sample - loss: 0.0767 - accuracy: 0.9754 - val_loss: 0.0773 - val_accuracy: 0.9765\n",
      "Epoch 7/7\n",
      "60000/60000 [==============================] - 9s 144us/sample - loss: 0.0694 - accuracy: 0.9776 - val_loss: 0.0669 - val_accuracy: 0.9792\n"
     ]
    }
   ],
   "source": [
    "#train the model\n",
    "history = model.fit(x_train, y_train, validation_data = (x_test, y_test), epochs=7)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Some customization during Training the model "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train on 60000 samples\n",
      "Epoch 1/5\n",
      "   32/60000 [..............................] - ETA: 1:43 - loss: 0.0137 - accuracy: 1.0000WARNING:tensorflow:Method (on_train_batch_end) is slow compared to the batch update (0.165144). Check your callbacks.\n",
      "59744/60000 [============================>.] - ETA: 0s - loss: 0.0889 - accuracy: 0.9722WARNING:tensorflow:Early stopping conditioned on metric `val_loss` which is not available. Available metrics are: loss,accuracy\n",
      "WARNING:tensorflow:From C:\\ProgramData\\Anaconda3\\lib\\site-packages\\tensorflow_core\\python\\ops\\resource_variable_ops.py:1781: 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",
      "INFO:tensorflow:Assets written to: .\\assets\n",
      "60000/60000 [==============================] - 9s 143us/sample - loss: 0.0889 - accuracy: 0.9722\n",
      "Epoch 2/5\n",
      "59712/60000 [============================>.] - ETA: 0s - loss: 0.0764 - accuracy: 0.9758WARNING:tensorflow:Early stopping conditioned on metric `val_loss` which is not available. Available metrics are: loss,accuracy\n",
      "INFO:tensorflow:Assets written to: .\\assets\n",
      "60000/60000 [==============================] - 8s 138us/sample - loss: 0.0764 - accuracy: 0.9758\n",
      "Epoch 3/5\n",
      "59712/60000 [============================>.] - ETA: 0s - loss: 0.0667 - accuracy: 0.9785WARNING:tensorflow:Early stopping conditioned on metric `val_loss` which is not available. Available metrics are: loss,accuracy\n",
      "INFO:tensorflow:Assets written to: .\\assets\n",
      "60000/60000 [==============================] - 8s 132us/sample - loss: 0.0667 - accuracy: 0.9786\n",
      "Epoch 4/5\n",
      "59776/60000 [============================>.] - ETA: 0s - loss: 0.0602 - accuracy: 0.9811WARNING:tensorflow:Early stopping conditioned on metric `val_loss` which is not available. Available metrics are: loss,accuracy\n",
      "INFO:tensorflow:Assets written to: .\\assets\n",
      "60000/60000 [==============================] - 8s 126us/sample - loss: 0.0603 - accuracy: 0.9811\n",
      "Epoch 5/5\n",
      "59840/60000 [============================>.] - ETA: 0s - loss: 0.0533 - accuracy: 0.9824WARNING:tensorflow:Early stopping conditioned on metric `val_loss` which is not available. Available metrics are: loss,accuracy\n",
      "INFO:tensorflow:Assets written to: .\\assets\n",
      "60000/60000 [==============================] - 8s 129us/sample - loss: 0.0532 - accuracy: 0.9824\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<tensorflow.python.keras.callbacks.History at 0x1b505ee46d8>"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.fit(x_train,y_train, epochs=5, \n",
    "          callbacks=[tf.keras.callbacks.EarlyStopping(),\n",
    "                     tf.keras.callbacks.TensorBoard(), \n",
    "                     tf.keras.callbacks.ModelCheckpoint('.')])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, the callbacks are used in model.fit() method. Here, the class Earlystopping() is used so that the model stops training when the improvement in model is stopped. TensorBoard() class is used for providing a visualization of how the model is getting trained. ModelCheckpoint() is used to save the model after every epoch. Here the model will be saved 10 times."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This function gives us how much accurate is our model on the test set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0.09129859392177314, 0.9728]"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#test the model with the test set \n",
    "model.evaluate(x_test,  y_test, verbose=3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x1d5580060f0>"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#get stats from the history object\n",
    "acc = history.history['accuracy']\n",
    "val_acc = history.history['val_accuracy']\n",
    "epochs = range(len(acc))\n",
    "\n",
    "# plot accuracy vs epochs \n",
    "plt.title('Training and validation accuracy')\n",
    "plt.plot(epochs,acc, color='blue',label=\"Train\")\n",
    "plt.plot(epochs,val_acc, color='orange', label=\"Val\")\n",
    "plt.xlabel('Epochs')\n",
    "plt.ylabel('Accuracy')\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#save the model \n",
    "model.save(\"mnist.h5\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "# perform prediction \n",
    "\n",
    "predictions = model.predict(x_test)\n",
    "print(class_names[np.argmax(predictions[90])])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "hide_input": false,
  "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"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}