Celsius_to_Fahrenheit_Model_Training.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyPZZ7uEj5eaZlTpTLwOlkRZ",
      "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/lakhya-jyoti/tensorflow/blob/main/Celsius_to_Fahrenheit_Model_Training.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Convert from celcius to fahreneheit**\n",
        "\n",
        "where the approximate formula is\n",
        "f = c * 1.8 + 32\n",
        "\n",
        "we will give Tensorflow some sample *Celsius* Values and their corresponding output Farenheit Values. Then we will train a model that figures out the above formula through the training process.\n"
      ],
      "metadata": {
        "id": "FAOUgMyY1zPi"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Import dependencies**"
      ],
      "metadata": {
        "id": "WNxeN1F2j_no"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import tensorflow as tf\n",
        "tf.get_logger().setLevel('ERROR')\n",
        "\n",
        "import numpy as np\n"
      ],
      "metadata": {
        "id": "H3CJ94_QqAGl"
      },
      "execution_count": 29,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Set up training data**\n",
        "\n",
        "Here we create two lists celsius_q and fahrenheit_a that we can use to train our model\n"
      ],
      "metadata": {
        "id": "UsPyS1r3qQGz"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "celsius_q =  np.array([-40, -10, 0, 8, 15, 22, 38], dtype=float)\n",
        "fahrenheit_a = np.array([-40, 14, 32, 46, 59, 72, 100], dtype=float)\n",
        "\n",
        "for i,c in enumerate(celsius_q):\n",
        "  print(\"{} degrees Celsius = {} degrees Fahrenheit\".format(c, fahrenheit_a[i]))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "db1MgSETt9GJ",
        "outputId": "df844cf9-ab0b-4f9d-ff72-66ed36e24906"
      },
      "execution_count": 30,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "-40.0 degrees Celsius = -40.0 degrees Fahrenheit\n",
            "-10.0 degrees Celsius = 14.0 degrees Fahrenheit\n",
            "0.0 degrees Celsius = 32.0 degrees Fahrenheit\n",
            "8.0 degrees Celsius = 46.0 degrees Fahrenheit\n",
            "15.0 degrees Celsius = 59.0 degrees Fahrenheit\n",
            "22.0 degrees Celsius = 72.0 degrees Fahrenheit\n",
            "38.0 degrees Celsius = 100.0 degrees Fahrenheit\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Create our model**"
      ],
      "metadata": {
        "id": "GHkuyv4bu1H-"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Build a layer**\n",
        "\n",
        "We'll call the layer 10 and create it by instantiating tf. keras. layers. Dense with the following configuration:\n",
        "* input_ shape=[1] - This specifies that the input to\n",
        "this layer is a single value. That is, the shape is a one-dimensional array with one member. Since this is the first (and only) layer, that input shape is the input shape of the entire model. The single value is a floating point number, representing degrees Celcius.\n",
        "* units=1 - This specifies the number of neurons in the layer. The number of neurons defines how many internal variables the layer has to try to learn how to solve the problem (more later). Since this is the final layer, it is also the size of the model's output — a single float value representing degrees Fahrenheit. (In a multi-layered network, the size and shape of the later would need to match the input_shape of the next layer.)"
      ],
      "metadata": {
        "id": "tXe3jLoTwUHy"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "l0 = tf.keras.layers.Dense(units=1, input_shape=[1])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "u0CJH8P3u3fH",
        "outputId": "bc4f1106-8079-4563-b19b-c71ab5fd2120"
      },
      "execution_count": 31,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.10/dist-packages/keras/src/layers/core/dense.py:87: UserWarning: Do not pass an `input_shape`/`input_dim` argument to a layer. When using Sequential models, prefer using an `Input(shape)` object as the first layer in the model instead.\n",
            "  super().__init__(activity_regularizer=activity_regularizer, **kwargs)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Assemble layers into the model**\n",
        "\n",
        "Once layers are defined, they need to be assembled into a model. The Sequential model definition takes a list of layers as argument, specifying the calculation order from the input to the output.\n",
        "This model has just a single layer,\n",
        "l0.\n"
      ],
      "metadata": {
        "id": "sAS5kiyewJg1"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "model = tf.keras.Sequential([l0])"
      ],
      "metadata": {
        "id": "Zc24WuIGwQTP"
      },
      "execution_count": 32,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Compile the model, with loss and optimizer functions**\n",
        "\n",
        "* Loss function - A way of measuring how far off predictions are from the desired outcome. (The measured difference is called the \"loss\".\n",
        "* Optimizer function - A way of adjusting internal values in order to reduce the loss."
      ],
      "metadata": {
        "id": "kI9tHWfMw0G4"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "model.compile(loss='mean_squared_error',\n",
        "              optimizer=tf.keras.optimizers.Adam(0.1))"
      ],
      "metadata": {
        "id": "HgFLtIFww8Pd"
      },
      "execution_count": 33,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Train the Model**\n",
        "\n",
        "by using the fit model\n",
        "\n",
        "During training, the model takes in Celsius values, performs a calculation using the current internal variables (called \"weights\") and outputs values which are meant to be the Fahrenheit equivalent. Since the weights are intially set randomly, the output will not be close to the correct value. The difference between the actual output and the desired output is calculated using the loss function, and the optimizer function directs how the weights should be adjusted.\n",
        "This cycle of calculate, compare, adjust is controlled by the fit method. The first argument is the inputs, the second argument is the desired outputs. The epochs argument specifies how many times this cycle should be run, and the verbose argument controls how much output the method produces."
      ],
      "metadata": {
        "id": "-LK3oyeJxWG0"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "history = model.fit(celsius_q, fahrenheit_a, epochs = 500, verbose = False)\n",
        "print(\"Finished training the model\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5E4RDrgMxkRJ",
        "outputId": "8f54c68e-4e82-4b46-ebab-f2bdb174ec55"
      },
      "execution_count": 34,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Finished training the model\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Display Training Statistics**\n",
        "\n",
        "The fit method returns a history object. We can use this object to plot how the loss of our model goes down after each training epoch. A high loss means that the Fahrenheit degrees the model predicts is far from the corresponding value in fahrenheit_a.\n"
      ],
      "metadata": {
        "id": "eRxftQlRyDkA"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as plt\n",
        "plt.xlabel('Epoch Number')\n",
        "plt.ylabel(\"Loss Magnitude\")\n",
        "plt.plot(history.history['loss'])\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 467
        },
        "id": "f7ACch4hyLfT",
        "outputId": "8db6803d-c6cd-428a-db20-e216249e906d"
      },
      "execution_count": 35,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[<matplotlib.lines.Line2D at 0x7d15f82c2350>]"
            ]
          },
          "metadata": {},
          "execution_count": 35
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Use the model to predict values**\n",
        "\n",
        "if the Celsius value is 200, farhrenheit value will be 100 * 1.8 + 32 = 212"
      ],
      "metadata": {
        "id": "HiW1KsKqydxY"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(model.predict(np.array([100.0]))) # Convert the list [100.0] to a NumPy array"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OkVAMsy3yxT3",
        "outputId": "f2607137-590d-4ea2-d529-3149653eddc6"
      },
      "execution_count": 36,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 43ms/step\n",
            "[[211.27074]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Review**\n",
        "* We created a model with dense layer\n",
        "* Trained it with 3500 examples (7 pairs, over 500 epochs)\n",
        "\n",
        "Our model tuned the variables (weights) in the Dense layer until it was able to return the correct Fahrenheit value for any Celsius value.\n"
      ],
      "metadata": {
        "id": "LbkLi9_ozP5q"
      }
    }
  ]
}