Tensorflow for Beginners.ipynb

tensorflow-for-beginners.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Tensorflow for Beginners.ipynb",
      "version": "0.3.2",
      "provenance": [],
      "collapsed_sections": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/gist/shadab-entrepreneur/ae4be3dc7d4b081b61e15ba7d35216ad/tensorflow-for-beginners.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "fA93WUy1zzWf"
      },
      "source": [
        "## Step 1:  Import dependencies\n",
        "\n",
        "First, import TensorFlow. Here, we're calling it `tf` for ease of use. We also tell it to only display errors.\n",
        "\n",
        "Next, import [NumPy](http://www.numpy.org/) as `np`. Numpy helps us to represent our data as highly performant lists.<br>\n",
        "Also Import matplotlib.pyplot for creating visual plots"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "X9uIpOS2zx7k",
        "colab": {}
      },
      "source": [
        "import tensorflow as tf\n",
        "tf.logging.set_verbosity(tf.logging.ERROR)\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "AC3EQFi20buB"
      },
      "source": [
        "## Step 2: Set up training data\n",
        "\n",
        "As we saw before, supervised Machine Learning is all about figuring out an algorithm given a set of inputs and outputs. Since the task in this Codelab is to create a model that can give the tnumber of new subscribers gained when given the amount x is spent in marketing, we create two lists `mar_budget` and `subs_gained` that we can use to train our model."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_-5zlfROSaAC",
        "colab_type": "text"
      },
      "source": [
        "### 2*i+40\n",
        "### Machine Learning terminology\n",
        "\n",
        " - **Feature** — The input(s) to our model. In this case, a single value — the marketing Budget.\n",
        "\n",
        " - **Labels** — The output our model predicts. In this case, a single value — the number of new subscribers gained.\n",
        " \n",
        " - **Example** — A pair of inputs/outputs used during training. In our case a pair of values from `mar_budget` and `new_subs_gained` at a specific index, such as `(80,200)` at index 1 below.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "gg4pn6aI1vms",
        "outputId": "98818d38-fdf7-4fc4-8cb0-8dccc2ebb566",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 153
        }
      },
      "source": [
        "mar_budget    = np.array([60, 80,  100  , 30, 50, 20, 90,  10],  dtype=float)\n",
        "subs_gained = np.array([160, 200, 240, 100, 140, 80, 220, 60],  dtype=float)\n",
        "\n",
        "for i,c in enumerate(mar_budget):\n",
        "  print(\"{} Market budget = {} new subscribers gained\".format(c, subs_gained[i]))"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "60.0 Market budget = 160.0 new subscribers gained\n",
            "80.0 Market budget = 200.0 new subscribers gained\n",
            "100.0 Market budget = 240.0 new subscribers gained\n",
            "30.0 Market budget = 100.0 new subscribers gained\n",
            "50.0 Market budget = 140.0 new subscribers gained\n",
            "20.0 Market budget = 80.0 new subscribers gained\n",
            "90.0 Market budget = 220.0 new subscribers gained\n",
            "10.0 Market budget = 60.0 new subscribers gained\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MZzdBWJWYpOT",
        "colab_type": "text"
      },
      "source": [
        "**Let's plot all data that we have to visualise the relationship between Marketing Budget and Subscriptions:**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nhc7gEeMRBfi",
        "colab_type": "code",
        "outputId": "44101e9d-1666-44ff-f161-1150bb6776f5",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 283
        }
      },
      "source": [
        "plt.scatter(mar_budget, subs_gained)\n",
        "plt.xlim(0,120)\n",
        "plt.ylim(0,260)\n",
        "plt.xlabel('Marketing Budget(in thousand of Dollars)')\n",
        "plt.ylabel('Subscribers Gained(in thousand)')\n",
        "plt.show()"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAY4AAAEKCAYAAAAFJbKyAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nS/4/+dvEKH5hbzkAAAAASUVORK5CYII=\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "P030ODhCCMcl",
        "colab_type": "text"
      },
      "source": [
        "## Seperate data for training and testing"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "H8bK8raKY31V",
        "colab_type": "text"
      },
      "source": [
        "In the step given beolw, we will seperate the data into two parts : Training Data(6 pairs), Testing Data(2 pairs).<br>\n",
        "We will use training data for training our Model, while testing Data for verifying the prediction of our Model."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oRudLNocB82c",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "from sklearn.model_selection import train_test_split\n",
        "X_train,X_test,y_train,y_test=train_test_split(mar_budget,subs_gained,random_state=42,\n",
        "                                               train_size=0.8, test_size=0.2 )"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FR3kSCEiCuhj",
        "colab_type": "code",
        "outputId": "430a5bed-44c8-48ab-8e0e-5a55b20affe5",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 119
        }
      },
      "source": [
        "print('Training_features:',X_train)\n",
        "print('Training_label:' , y_train)\n",
        "print('\\n')\n",
        "print('Testing_features:', X_test)\n",
        "print('Testing_labels:',y_test)"
      ],
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Training_features: [ 60.  10. 100.  50.  30.  90.]\n",
            "Training_label: [160.  60. 240. 140. 100. 220.]\n",
            "\n",
            "\n",
            "Testing_features: [80. 20.]\n",
            "Testing_labels: [200.  80.]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "VM7_9Klvq7MO"
      },
      "source": [
        "## Create the model\n",
        "\n",
        "Next create the model. We will use simplest possible model we can, a Dense network. Since the problem is straightforward, this network will require only a single layer, with a single neuron. \n",
        "\n",
        "### Build a layer\n",
        "\n",
        "We'll call the layer `layer_0` and create it by instantiating `tf.keras.layers.Dense` with the following configuration:\n",
        "\n",
        "*   `input_shape=[1]` — This specifies that the input to 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 marketing_budget.\n",
        "\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 new subscribers gained. (In a multi-layered network, the size and shape of the layer would need to match the `input_shape` of the next layer.)\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SBID6tukET-c",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "layer_0 = tf.keras.layers.Dense(units=1, input_shape=[1])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "_F00_J9duLBD"
      },
      "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  arguments, specifying the calculation order from the input to the output.\n",
        "\n",
        "This model has just a single layer, layer_0."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WEQb-JDME67T",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "model = tf.keras.Sequential([layer_0])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "t7pfHfWxust0"
      },
      "source": [
        "**Note**\n",
        "\n",
        "You will often see the layers defined inside the model definition, rather than beforehand:\n",
        "\n",
        "```python\n",
        "model = tf.keras.Sequential([\n",
        "  tf.keras.layers.Dense(units=1, input_shape=[1])\n",
        "])\n",
        "```"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "kiZG7uhm8qCF"
      },
      "source": [
        "## Compile the model, with loss and optimizer functions\n",
        "\n",
        "Before training, the model has to be compiled. When compiled for training, the model is given:\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",
        "\n",
        "- **Optimizer function** — A way of adjusting internal values in order to reduce the loss.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "m8YQN1H41L-Y",
        "colab": {}
      },
      "source": [
        "model.compile(loss='mean_squared_error',\n",
        "              optimizer=tf.keras.optimizers.Adam(0.1))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "17M3Pqv4P52R"
      },
      "source": [
        "These are used during training (`model.fit()`, below) to first calculate the loss at each point, and then improve it. In fact, the act of calculating the current loss of a model and then improving it is precisely what training is.\n",
        "\n",
        "During training, the optimizer function is used to calculate adjustments to the model's internal variables. The goal is to adjust the internal variables until the model (which is really a math function) mirrors the actual equation for converting `budget_Spent to New Subs Gained`.\n",
        "\n",
        "TensorFlow uses numerical analysis to perform this tuning, and all this complexity is hidden from you so we will not go into the details here. What is useful to know about these parameters are:\n",
        "\n",
        "The loss function ([mean squared error](https://en.wikipedia.org/wiki/Mean_squared_error)) and the optimizer ([Adam](https://machinelearningmastery.com/adam-optimization-algorithm-for-deep-learning/)) used here are standard for simple models like this one, but many others are available. It is not important to know how these specific functions work at this point.\n",
        "\n",
        "One part of the Optimizer you may need to think about when building your own models is the learning rate (`0.1` in the code above). This is the step size taken when adjusting values in the model. If the value is too small, it will take too many iterations to train the model. Too large, and accuracy goes down. Finding a good value often involves some trial and error, but the range is usually within 0.001 (default), and 0.1"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "c-Jk4dG91dvD"
      },
      "source": [
        "## Train the model\n",
        "\n",
        "Train the model by calling the `fit` method. \n",
        "\n",
        "During training, the model takes in marketing budget values, performs a calculation using the current internal variables (called \"weights\") and outputs values which are meant to be the `New subs Gained`. Since the weights are initially 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",
        "\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."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZCJXbvnGFf9r",
        "colab_type": "code",
        "outputId": "4e8bfcdd-c8f2-427e-af24-f515feb79487",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "trained_model = model.fit(X_train, y_train, epochs=1000, verbose=False)\n",
        "print(\"Finished training the model\")"
      ],
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Finished training the model\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "0-QsNCLD4MJZ"
      },
      "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 value of `new subs gained` the model predicts, are far from the corresponding value of `actual subs gained`. \n",
        "\n",
        "We'll again use [Matplotlib](https://matplotlib.org/) to visualize this (you could use another tool). As you can see, our model improves very quickly at first, and then has a steady, slow improvement until it is very near \"perfect\" towards the end.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "IeK6BzfbdO6_",
        "outputId": "5322f7d0-7625-43ca-a617-5b2e5bb95e4d",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 283
        }
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "plt.xlabel('Epoch Number')\n",
        "plt.ylabel(\"Loss Magnitude\")\n",
        "plt.plot(trained_model.history['loss'])\n",
        "plt.show()"
      ],
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZUAAAEKCAYAAADaa8itAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n1jYOFTMza5v/D0Tj+AVFXmDJAAAAAElFTkSuQmCC\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "LtQGDMob5LOD"
      },
      "source": [
        "## Use the model to predict values\n",
        "\n",
        "Now you have a model that has been trained to learn the relationship between `marketing_Budget` and `new_subs_gained`. You can use the predict method to have it calculate the new_subs_gained for a previously known/unknown marketing_budget. \n",
        "\n",
        "So, for example, if the marketing_budget value is  80 thousand dollars, what do you think the new_subs_gained result will be? Take a guess before you run this code or refer to your train_data."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "oxNzL4lS2Gui",
        "outputId": "9cebd25b-4915-423e-9535-0f20d4320d07",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "print(model.predict([80.0]))"
      ],
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[200.9136]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "loOnF5mhKEdS",
        "colab_type": "text"
      },
      "source": [
        "\n",
        "The correct answer is $80 \\times 2 + 40 = 200$, so our model is doing really well."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MeGGzPDyHzYg",
        "colab_type": "code",
        "outputId": "c245144d-34b5-466b-da27-5e6490b43886",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        }
      },
      "source": [
        "# checking for all the test _values\n",
        "y_pred = model.predict(X_test)\n",
        "print('Actual Values\\tPredicted Values')\n",
        "print(y_test,'   ',y_pred.reshape(1,-1))"
      ],
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Actual Values\tPredicted Values\n",
            "[200.  80.]     [[200.9136   71.97034]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vu9PLnJsI9JV",
        "colab_type": "text"
      },
      "source": [
        "## Let's check the goodness of fit for model using r2_score(r-squared value)\n",
        "R2 is a statistic that will give some information about the goodness of fit of a model. In regression, the R2 coefficient of determination is a statistical measure of how well the regression predictions approximate the real data points. <br>An R2 of 1 indicates that the regression predictions perfectly fit the data."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5rdDjNF0IB3B",
        "colab_type": "code",
        "outputId": "72ce2f08-41b4-47c7-8ba0-ad687303eb0a",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "from sklearn.metrics import r2_score\n",
        "r2_score(y_test,y_pred)"
      ],
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0.9909291440433461"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 13
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QwZFB065JpJH",
        "colab_type": "text"
      },
      "source": [
        "As we can see our model's r2_score is nearly = 1 that means our model is predicting with a good accuracy"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "jApk6tZ1fBg1"
      },
      "source": [
        "\n",
        "\n",
        "### To review\n",
        "\n",
        "\n",
        "*   We created a model with a Dense layer\n",
        "*   We trained it with 3000 examples (6 pairs, over 500 epochs).\n",
        "\n",
        "Our model tuned the variables (weights) in the Dense layer until it was able to return the correct new_subs_gained value for any marketing_budget value.<br>\n",
        "And we verified this using our test Data(Remember, 80  was not part of our training data.)\n",
        "<br>\n",
        "We also measured the goodness of prediction for our model using r2_score\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "zRrOky5gm20Z"
      },
      "source": [
        "## Looking at the layer weights\n",
        "\n",
        "Finally, let's print the internal variables of the Dense layer. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "kmIkVdkbnZJI",
        "outputId": "a4ab2dfd-5688-44a8-c6cb-98664cf0b9cd",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "print(\"These are the layer variables: {}\".format(layer_0.get_weights()))"
      ],
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "These are the layer variables: [array([[2.1490543]], dtype=float32), array([28.989252], dtype=float32)]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "RSplSnMvnWC-"
      },
      "source": [
        "The first variable is close to ~2.0 and the second to ~40. These values (2.0 and 40) are the actual variables in the real conversion formula.\n",
        "\n",
        "This is really close to the values in the conversion formula. We'll explain this in an upcoming video where we show how a Dense layer works, but for a single neuron with a single input and a single output, the internal math looks the same as [the equation for a line](https://en.wikipedia.org/wiki/Linear_equation#Slope%E2%80%93intercept_form), $y = mx + b$, which has the same form as the conversion equation, $label = 2.0\\times feauture + 40$.\n",
        "\n",
        "Since the form is the same, the variables should converge on the standard values of 2.0 and 40, which is exactly what happened.\n",
        "\n",
        "With additional neurons, additional inputs, and additional outputs, the formula becomes much more complex, but the idea is the same. \n",
        "\n",
        "### A little Thought experiment\n",
        "\n",
        "Just for fun, what if we create a new model with 3 more Dense layers with different units, which therefore also has more variables?"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RAmatWUfL2DO",
        "colab_type": "code",
        "outputId": "eca3f728-be62-4c7a-d93d-88d79ebedae0",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        }
      },
      "source": [
        "l_0 = tf.keras.layers.Dense(units=4, input_shape=[1])\n",
        "l_1 = tf.keras.layers.Dense(units=5)\n",
        "l_2 = tf.keras.layers.Dense(units=1) \n",
        "model = tf.keras.Sequential([l_0, l_1, l_2])\n",
        "model.compile(loss='mean_squared_error', optimizer=tf.keras.optimizers.Adam(0.1))\n",
        "model.fit(X_train,y_train, epochs=2000,verbose=False)\n",
        "print('\\n Finished training Model')"
      ],
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Finished training Model\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LshKLYkpP79B",
        "colab_type": "code",
        "outputId": "fd2a9361-f4a1-45d1-a566-da2058e3bfd4",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        }
      },
      "source": [
        "print(model.predict([80]))\n",
        "y_pred=model.predict(X_test)\n",
        "print(r2_score(y_test,y_pred))"
      ],
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[199.99925]]\n",
            "0.99999999991188\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FAf67EMlXivl",
        "colab_type": "text"
      },
      "source": [
        "### As we can see the r2_score increased thus goodness of fit or prediction of our Model also increased by adding more layers"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "u_qOSObBO4H7",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "## TODO: print the wieght of each layer and think why are they so different from (2,40). "
      ],
      "execution_count": 0,
      "outputs": []
    }
  ]
}