SeminarWalkthrough.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyMhCEBAie2Ym/3FnUg5sMq7",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/walleford/bhp/blob/main/SeminarWalkthrough.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# TensorFlow Demo\n",
        "In this workbook we will go over an introduction of TensorFlow and how you can quickly import and implement the tool in your Python environment.\n",
        "\n",
        "## Setup\n",
        "If not already installed, you will need to pip install TensorFlow:"
      ],
      "metadata": {
        "id": "1VT47Q6kPP7S"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "pip install tensorflow"
      ],
      "metadata": {
        "id": "jRnTel5bPil5"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Once this is completed (or if the requirement is already satisfied), then you will need to import tensorflow into your Python script/environment."
      ],
      "metadata": {
        "id": "e8DdeV43PnXK"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import tensorflow as tf # import it as tf so you don't have to call it with the full name every time"
      ],
      "metadata": {
        "id": "Jz1euC3YPkS7"
      },
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Introduction to Tensors\n",
        "Tensors are multi-dimensional arrays with a uniform type (dtype). There are many types of tensors:\n",
        "* float32, int32, string, etc...\n",
        "\n",
        "Tensors are very similar to numpy arrays (np.arrays). They are the objects passed around and manipulated when creating and training models using TensorFlow."
      ],
      "metadata": {
        "id": "0DFaUF9MQCDe"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "string = tf.Variable(\"this is a string\", tf.string) # along with declaring the variable, you have to declare the type\n",
        "number = tf.Variable(42, tf.int16) # integer"
      ],
      "metadata": {
        "id": "fCZF3_4nP0WR"
      },
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Tensors have what is known as a rank: the number of dimensions of the tensor."
      ],
      "metadata": {
        "id": "EXNFy_oTQz8X"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "one_dimension_tensor = tf.Variable([\"one dimension\"], tf.string)\n",
        "print(tf.rank(one_dimension_tensor))\n",
        "two_dimension_tensor = tf.Variable([[\"one dimension\", \"one dimension\"], [\"two dimensions\", \"two dimensions\"]], tf.string)\n",
        "print(tf.rank(two_dimension_tensor))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7IhyArtQQx_m",
        "outputId": "ea82c8f0-6016-40c4-f6e7-f7d9700cd55f"
      },
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tf.Tensor(1, shape=(), dtype=int32)\n",
            "tf.Tensor(2, shape=(), dtype=int32)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Keras for Machine Learning\n",
        "Keras is the high level api utilized with TensorFlow in order to solve ML problems with a focus on modern deep learning. Keras covers every step from preprocessing to deployment.\n",
        "\n",
        "## Creating Your First Machine Learning Model\n",
        "To build the machine learning model with Keras we will use the MNIST dataset that contains a 28x28 pixel image with each pixel containing a value from 0 to 255 representing the gray-scale of the pixel. These images contain handwritten numbers and our model will classify the numbers."
      ],
      "metadata": {
        "id": "Z3VH6PACRlVs"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "mnist = tf.keras.datasets.mnist\n",
        "# next we will load the training/testing data with a built in function\n",
        "# x here stands for the images while y stands for the labels.\n",
        "(x_train, y_train), (x_test, y_test) = mnist.load_data()\n",
        "\n",
        "# To scale our data into the range of [0,1] we will divide everything by 255\n",
        "x_train, x_test = x_train / 255.0, x_test / 255.0"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "S5cnOt2ORPQl",
        "outputId": "6e72bcb3-fc70-4618-ce4a-c5d155165d82"
      },
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/mnist.npz\n",
            "11490434/11490434 [==============================] - 0s 0us/step\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Once these are loaded, we can visualize one image to make sure we have the correct data:"
      ],
      "metadata": {
        "id": "GNQMqNjWT1r9"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "plt.figure()\n",
        "plt.imshow(x_train[2])\n",
        "plt.colorbar()\n",
        "plt.show()\n",
        "print(f\"The label for this image is: {y_train[2]}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 453
        },
        "id": "KErPFslVT8UQ",
        "outputId": "ac9f6fc4-171c-4fe6-cced-d526e0ae6215"
      },
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The label for this image is: 4\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Now we will declare/build our keras model utilizing a sequential model. A sequential model is a type of feed-forward neural network. Our first layer will take the two-dimensional input of a 28x28 array into a single dimension vector of 784 input neurons for the network. The second layer is a dense layer (every neuron from the previous layer connects directly to every neuron from the last layer) and has 128 neurons. The third layer is a dense layer as well and has 10 output neurons."
      ],
      "metadata": {
        "id": "uYBpF5zcUjm0"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "model = tf.keras.Sequential()\n",
        "\n",
        "model.add(tf.keras.layers.Flatten(input_shape=(28,28)))\n",
        "model.add(tf.keras.layers.Dense(128, activation='relu'))\n",
        "model.add(tf.keras.layers.Dense(10))"
      ],
      "metadata": {
        "id": "QMFPeowoUHkk"
      },
      "execution_count": 12,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Now that the model is built, we must compile the model with a specified optimizer, loss function, and metric to be evaluated. The loss function we will use is the SparseCategoricalCrossentropy function. This function computes the crossentropy loss between labels and predictions and is used when there are more than 2 label classes to predict."
      ],
      "metadata": {
        "id": "o-vx2v1cWA5X"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "model.compile(\n",
        "    optimizer='adam',\n",
        "    loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),\n",
        "    metrics=['accuracy']\n",
        ")"
      ],
      "metadata": {
        "id": "MTWQjBBkVj3y"
      },
      "execution_count": 13,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Finally, we fit our model with our training data and labels to see its accuracy rate."
      ],
      "metadata": {
        "id": "4kIkKO1rXWMA"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "model.fit(\n",
        "    x_train, y_train,\n",
        "    epochs=5\n",
        ")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-bD89x_rXco_",
        "outputId": "e7dee82c-10c3-4b4a-89ee-1ac8114e1375"
      },
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/5\n",
            "1875/1875 [==============================] - 4s 2ms/step - loss: 0.2558 - accuracy: 0.9266\n",
            "Epoch 2/5\n",
            "1875/1875 [==============================] - 4s 2ms/step - loss: 0.1124 - accuracy: 0.9671\n",
            "Epoch 3/5\n",
            "1875/1875 [==============================] - 4s 2ms/step - loss: 0.0774 - accuracy: 0.9768\n",
            "Epoch 4/5\n",
            "1875/1875 [==============================] - 4s 2ms/step - loss: 0.0573 - accuracy: 0.9824\n",
            "Epoch 5/5\n",
            "1875/1875 [==============================] - 7s 4ms/step - loss: 0.0456 - accuracy: 0.9859\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<keras.src.callbacks.History at 0x7f0395162200>"
            ]
          },
          "metadata": {},
          "execution_count": 14
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Once the model is fitted we can run the tests throught the model to evaluate its actual accuracy."
      ],
      "metadata": {
        "id": "EUNRHhTIXo-3"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "model.evaluate(x_test, y_test, verbose=2)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ccBoJvYGXVMv",
        "outputId": "fbddb057-d6af-4fc9-8c55-2c6fb4b363cb"
      },
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "313/313 - 1s - loss: 0.0734 - accuracy: 0.9769 - 601ms/epoch - 2ms/step\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[0.07341305911540985, 0.9768999814987183]"
            ]
          },
          "metadata": {},
          "execution_count": 15
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "You can see the accuracy for this model is 97.69% accurate."
      ],
      "metadata": {
        "id": "oGIipTO-XvZf"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Conclusion\n",
        "In this demo we utilized TensorFlow and the keras API to build a feed-forward neural network to perform classification tasks on a dataset containing handwritten numbers."
      ],
      "metadata": {
        "id": "t8p78iVRX18V"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "References:\n",
        "\n",
        "https://www.tensorflow.org/tutorials/quickstart/beginner\n",
        "\n",
        "https://www.tensorflow.org/api_docs/python/tf/keras/optimizers/Adam\n",
        "\n",
        "https://developers.google.com/machine-learning/glossary"
      ],
      "metadata": {
        "id": "pgyfpVXfYRoJ"
      }
    }
  ]
}