lab_day1/day1_code02_keras_basics_[EXERCISE].ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "gpuClass": "standard",
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "## Assessing the available GPU\n",
        "\n",
        "The following commands will tell you what GPU is available. Remember that if you want to actually use the GPU you must enable hardware acceleration under \"Runtime/Change runtime type\" otherwise you'll be using just the CPU (in this latter case you'll get something along the lines of \"NVIDIA-SMI has failed\").\n",
        "\n",
        "Also keep in mind that the (free) GPU runtime is limited!"
      ],
      "metadata": {
        "id": "S4o1EYcAQYXT"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "!/usr/local/cuda/bin/nvcc --version\n",
        "!nvidia-smi -L"
      ],
      "metadata": {
        "id": "YtpEkSioQX6p",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "7a4301dd-d681-4d7a-875a-3bfff1ef23d2"
      },
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "nvcc: NVIDIA (R) Cuda compiler driver\n",
            "Copyright (c) 2005-2022 NVIDIA Corporation\n",
            "Built on Wed_Sep_21_10:33:58_PDT_2022\n",
            "Cuda compilation tools, release 11.8, V11.8.89\n",
            "Build cuda_11.8.r11.8/compiler.31833905_0\n",
            "GPU 0: Tesla T4 (UUID: GPU-fad25e12-f839-584b-8e8a-7cb78730d793)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4DXwxt9r1bx_"
      },
      "source": [
        "## A first (actually second) encounter with Keras\n",
        "\n",
        "`Keras` is a high-level Python library for **deep learning**: Keras is an API wrapper for `TensorFlow`, which is the **backend engine** that performs low-level computations (e.g. tensor products, convolutions, etc.).\n",
        "\n",
        "[Don't worry if there are many terms that you don't fully understand now: we will go over these concepts repeatedly during the course, with increasing levels of detail]\n",
        "\n",
        "Keras allows easy and fast deployment of neural networks models: the code chunk below imports `Keras` functions that define a specific neural network architecture:\n",
        "\n",
        "- `Sequential()`: a network made up of a sequence of successive layers\n",
        "- `Dense()`: fully-connected (dense) layers\n",
        "- the type of **activation functions** to be used in each layer\n",
        "- the number of units in each layer\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-uUdGW-D1ayA"
      },
      "source": [
        "from keras.models import Sequential\n",
        "from keras.layers import Dense, Activation,Conv2D,MaxPooling2D,Flatten,Dropout"
      ],
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iV5ShyTb98uU"
      },
      "source": [
        "model = Sequential()\n",
        "model.add(Dense(64, activation='relu', input_dim=50)) #input shape of 50\n",
        "model.add(Dense(28, activation='relu')) #input shape of 64\n",
        "model.add(Dense(10, activation='softmax'))"
      ],
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6wsTLk6GEqNR"
      },
      "source": [
        "## Model definition\n",
        "\n",
        "As we saw above, the first step is to choose the neural network architecture and define the deep learning model.\n",
        "\n",
        "We first use the `Sequential()` function to select the Keras API for the construction of deep learning models. Sequential models are a stack of layers, each with one input and one output tensor.\n",
        "\n",
        "The function `add()` will then allow us to add subsequent layers to our deep learning model, by specifying the type of layer"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6AkjMRyaNK8Y"
      },
      "source": [
        "model = Sequential()"
      ],
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZuZ5apaYPhCM"
      },
      "source": [
        "### Dense layer\n",
        "\n",
        "The first very common type of layer is the **Fully Connected** (dense) layer: we can specify the number of units in the layer and the activation function to use."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_81JIwrxPgQX"
      },
      "source": [
        "model.add(Dense(units = 32, activation='relu', input_shape=(12,12,3))) ##input shape: tensor size e.g. 12 x 12 pixels x 3 channels (RGB)"
      ],
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4vjeG4RIPaK8"
      },
      "source": [
        "### Convolutional layer\n",
        "\n",
        "Another common type of layers is the **convolutional layer** where we specify the number of filters, the size of the filter (kernel) and the activation function.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CFQbEniLPYS7"
      },
      "source": [
        "model.add(Conv2D(filters = 8, kernel_size = (3, 3), activation='relu'))"
      ],
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mraG7PM1S0Ea"
      },
      "source": [
        "### MaxPooling layer\n",
        "\n",
        "MaxPooling layers downsample the input representation by taking the maximum value over the window defined by pool size for each dimension along the features axis ($\\rightarrow$ dimensionality reduction)\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pkJ0AGASSzHZ"
      },
      "source": [
        "model.add(MaxPooling2D(pool_size=(2, 2)))"
      ],
      "execution_count": 7,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gxsTd-EyVy24"
      },
      "source": [
        "### Dropout layer\n",
        "\n",
        "The **dropout layer** randomly sets input units to 0 with a specified frequency (`rate` argument) at each step during training, which helps prevent overfitting."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "d_Vtwu-3VcwA"
      },
      "source": [
        "model.add(Dropout(rate = 0.5))"
      ],
      "execution_count": 8,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hF2wo-KpeOhp"
      },
      "source": [
        "We can get an overview of the defined deep learning model by using the `model.summary()` function:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JJrocEIkZBPU",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "12f38ba1-c522-4390-dc90-5d726343f559"
      },
      "source": [
        "print(model.summary())"
      ],
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"sequential_1\"\n",
            "_________________________________________________________________\n",
            " Layer (type)                Output Shape              Param #   \n",
            "=================================================================\n",
            " dense_3 (Dense)             (None, 12, 12, 32)        128       \n",
            "                                                                 \n",
            " conv2d (Conv2D)             (None, 10, 10, 8)         2312      \n",
            "                                                                 \n",
            " max_pooling2d (MaxPooling2  (None, 5, 5, 8)           0         \n",
            " D)                                                              \n",
            "                                                                 \n",
            " dropout (Dropout)           (None, 5, 5, 8)           0         \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 2440 (9.53 KB)\n",
            "Trainable params: 2440 (9.53 KB)\n",
            "Non-trainable params: 0 (0.00 Byte)\n",
            "_________________________________________________________________\n",
            "None\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "u1jau0_BeY5B"
      },
      "source": [
        "We see that we have a large number of parameters to train in this model:\n",
        "\n",
        "- 4 parameters (3 channels + bias term) per 32 units in the Dense layer $\\rightarrow$ 128 parameters\n",
        "- for convolutional layer number of parameter is computed as:\n",
        "    - number_parameters = out_channels * (in_channels * kernel_h * kernel_w + 1)\n",
        "    - the \"+ 1\" is for bias term\n",
        "    - `out_channels` = number of units in current layers = 8\n",
        "    - `in_channels` = number of units in previous layer = 32\n",
        "    - `kernel_h` = `kernel_w` = 3\n",
        "    - 8 * (32 * 3 * 3 + 1) = 2312\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CmhJQx3OXs6d"
      },
      "source": [
        "## Compiling the model\n",
        "\n",
        "Once the model architecture has been defined, you go on compiling the model by setting up relevant configurations: **loss function**, **optimizer**, etc."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4h2t5ivJEI6J"
      },
      "source": [
        "model.compile(loss='mean_squared_error', optimizer='adam')"
      ],
      "execution_count": 10,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BoSoa-PphdjJ"
      },
      "source": [
        "The next steps would be to:\n",
        "\n",
        "- fit the built and compiled model\n",
        "- evaluate the model performance\n",
        "\n",
        "You can find the Keras code for these two steps below: since we currently haven't loaded any data to work on, we commented out these lines of code, for us to see and discuss the syntax"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ObGoYi48hqMa"
      },
      "source": [
        "# model.fit(x_train, y_train, batch_size=32, epochs=10, validation_data=(x_val, y_val))\n",
        "# score = model.evaluate(x_test, y_test, batch_size=32)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3y4cx-02hm6T"
      },
      "source": [
        "## An example with simple linear regression\n",
        "\n",
        "We now use Keras to fit a simple linear regression model:\n",
        "\n",
        "$$\n",
        "y = \\mu + \\beta x + e\n",
        "$$\n",
        "\n",
        "we start by generating data for the feature *x* and the target variable *y* (continuous)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MF_wy4MciQHA",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "59f644ef-fc51-4097-dbe9-46a38e55093a"
      },
      "source": [
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "x = np.linspace(1,2,200) ## generate 200 samples with values between 1 and 2\n",
        "print(x.shape)\n",
        "y = x*4 + np.random.randn(*x.shape) * 0.3 ## *x.shape is the number of random numbers to generate (* because x.shape is a tuple)"
      ],
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(200,)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "plt.plot(x,y)"
      ],
      "metadata": {
        "id": "dMK5fz8q8iC-",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 447
        },
        "outputId": "7e99775c-9782-4e47-a6b6-5c331e5b2cac"
      },
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[<matplotlib.lines.Line2D at 0x789420128490>]"
            ]
          },
          "metadata": {},
          "execution_count": 12
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WwVguveFkz4A"
      },
      "source": [
        "We now build the neural networks model by specifying one Dense layer with one single unit. The activation function is `linear` (identity function). the input dimension is 1 (one feature)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2IIPVkGMkuua"
      },
      "source": [
        "model = Sequential()\n",
        "model.add(Dense(1, input_dim=1, activation='linear'))"
      ],
      "execution_count": 13,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8NTEzG-SlTyi"
      },
      "source": [
        "We then compile the model, selecting *stochastic gradient descent* as optimizer and *mean square error* as loss function"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZarF5DOTkxKU"
      },
      "source": [
        "model.compile(optimizer='sgd', loss='mse', metrics=['mse'])"
      ],
      "execution_count": 14,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0ZxIjWMdlY63",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "89c4cdf4-f830-4855-ab7d-d6859d8a576c"
      },
      "source": [
        "print(model.summary())"
      ],
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"sequential_2\"\n",
            "_________________________________________________________________\n",
            " Layer (type)                Output Shape              Param #   \n",
            "=================================================================\n",
            " dense_4 (Dense)             (None, 1)                 2         \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 2 (8.00 Byte)\n",
            "Trainable params: 2 (8.00 Byte)\n",
            "Non-trainable params: 0 (0.00 Byte)\n",
            "_________________________________________________________________\n",
            "None\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_0LqhG-UlbsP"
      },
      "source": [
        "We here have two parameters to train: the intercept $\\mu$ and the slope $\\beta$"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-08cpPgbmrla"
      },
      "source": [
        "We are now ready to fit our simple linear regression model with Keras. We define epochs=30 (30 iterations of optimization)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SBYLRGn3lsNX",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a9e1a465-efb2-4b5e-bf6a-7b0396a5cebf"
      },
      "source": [
        "history = model.fit(x,y, epochs=30, shuffle=False)"
      ],
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/30\n",
            "7/7 [==============================] - 4s 4ms/step - loss: 17.6403 - mse: 17.6403\n",
            "Epoch 2/30\n",
            "7/7 [==============================] - 0s 3ms/step - loss: 6.4051 - mse: 6.4051\n",
            "Epoch 3/30\n",
            "7/7 [==============================] - 0s 3ms/step - loss: 2.3666 - mse: 2.3666\n",
            "Epoch 4/30\n",
            "7/7 [==============================] - 0s 3ms/step - loss: 0.9254 - mse: 0.9254\n",
            "Epoch 5/30\n",
            "7/7 [==============================] - 0s 3ms/step - loss: 0.4173 - mse: 0.4173\n",
            "Epoch 6/30\n",
            "7/7 [==============================] - 0s 3ms/step - loss: 0.2420 - mse: 0.2420\n",
            "Epoch 7/30\n",
            "7/7 [==============================] - 0s 3ms/step - loss: 0.1838 - mse: 0.1838\n",
            "Epoch 8/30\n",
            "7/7 [==============================] - 0s 3ms/step - loss: 0.1658 - mse: 0.1658\n",
            "Epoch 9/30\n",
            "7/7 [==============================] - 0s 3ms/step - loss: 0.1611 - mse: 0.1611\n",
            "Epoch 10/30\n",
            "7/7 [==============================] - 0s 3ms/step - loss: 0.1604 - mse: 0.1604\n",
            "Epoch 11/30\n",
            "7/7 [==============================] - 0s 3ms/step - loss: 0.1607 - mse: 0.1607\n",
            "Epoch 12/30\n",
            "7/7 [==============================] - 0s 3ms/step - loss: 0.1610 - mse: 0.1610\n",
            "Epoch 13/30\n",
            "7/7 [==============================] - 0s 3ms/step - loss: 0.1612 - mse: 0.1612\n",
            "Epoch 14/30\n",
            "7/7 [==============================] - 0s 4ms/step - loss: 0.1612 - mse: 0.1612\n",
            "Epoch 15/30\n",
            "7/7 [==============================] - 0s 3ms/step - loss: 0.1610 - mse: 0.1610\n",
            "Epoch 16/30\n",
            "7/7 [==============================] - 0s 3ms/step - loss: 0.1608 - mse: 0.1608\n",
            "Epoch 17/30\n",
            "7/7 [==============================] - 0s 3ms/step - loss: 0.1606 - mse: 0.1606\n",
            "Epoch 18/30\n",
            "7/7 [==============================] - 0s 3ms/step - loss: 0.1603 - mse: 0.1603\n",
            "Epoch 19/30\n",
            "7/7 [==============================] - 0s 3ms/step - loss: 0.1600 - mse: 0.1600\n",
            "Epoch 20/30\n",
            "7/7 [==============================] - 0s 3ms/step - loss: 0.1597 - mse: 0.1597\n",
            "Epoch 21/30\n",
            "7/7 [==============================] - 0s 3ms/step - loss: 0.1594 - mse: 0.1594\n",
            "Epoch 22/30\n",
            "7/7 [==============================] - 0s 3ms/step - loss: 0.1591 - mse: 0.1591\n",
            "Epoch 23/30\n",
            "7/7 [==============================] - 0s 3ms/step - loss: 0.1587 - mse: 0.1587\n",
            "Epoch 24/30\n",
            "7/7 [==============================] - 0s 3ms/step - loss: 0.1584 - mse: 0.1584\n",
            "Epoch 25/30\n",
            "7/7 [==============================] - 0s 3ms/step - loss: 0.1581 - mse: 0.1581\n",
            "Epoch 26/30\n",
            "7/7 [==============================] - 0s 3ms/step - loss: 0.1578 - mse: 0.1578\n",
            "Epoch 27/30\n",
            "7/7 [==============================] - 0s 3ms/step - loss: 0.1575 - mse: 0.1575\n",
            "Epoch 28/30\n",
            "7/7 [==============================] - 0s 3ms/step - loss: 0.1572 - mse: 0.1572\n",
            "Epoch 29/30\n",
            "7/7 [==============================] - 0s 3ms/step - loss: 0.1569 - mse: 0.1569\n",
            "Epoch 30/30\n",
            "7/7 [==============================] - 0s 3ms/step - loss: 0.1566 - mse: 0.1566\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XjqiaLe0pbEB"
      },
      "source": [
        "Finally, we are ready to evaluate the fitted deep learning model.\n",
        "First, we look at predicted vs observed values: using the fitted model, we predict values for our 200 generated samples"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9JCA-6JgoV8R",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "4d7a3c1b-7bcd-4811-91b2-97d530edc063"
      },
      "source": [
        "predict = model.predict(x)\n",
        "y_hat = predict.reshape(200,)\n",
        "print(y.shape)\n",
        "print(y_hat.shape)\n",
        "\n",
        "## correlation coefficient\n",
        "print(np.corrcoef(y,y_hat))\n",
        "print(\"The correlation between observed and predicted y's is: \", np.corrcoef(y,y_hat)[0,1])"
      ],
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "7/7 [==============================] - 0s 2ms/step\n",
            "(200,)\n",
            "(200,)\n",
            "[[1.         0.95410499]\n",
            " [0.95410499 1.        ]]\n",
            "The correlation between observed and predicted y's is:  0.9541049903352432\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "twrvpVMRzgw_"
      },
      "source": [
        "### Question\n",
        "\n",
        "Why do you think that we have such high predictive accuracy?"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "K1JchT4zhlFE"
      },
      "source": [
        "plt.scatter(y_hat, y)\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_Seiszuwq3A5"
      },
      "source": [
        "We can plot the decay of the loss over epochs, using results saved in the `history` object"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GvtM5m56mX3n",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 447
        },
        "outputId": "db298a21-90ae-4fcf-d744-34c21108ffdb"
      },
      "source": [
        "plt.plot(history.history['loss'])"
      ],
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[<matplotlib.lines.Line2D at 0x78940e980d60>]"
            ]
          },
          "metadata": {},
          "execution_count": 19
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RDdf-AQ5q-cT"
      },
      "source": [
        "We can also retrieve the weights (coefficients) estimated in the final layer:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MDY2BIpgoQdL",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a65894e0-2563-4a0e-8cc3-8088e31be96b"
      },
      "source": [
        "model.get_weights()"
      ],
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[array([[3.1575272]], dtype=float32), array([1.3616047], dtype=float32)]"
            ]
          },
          "metadata": {},
          "execution_count": 18
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "huMD0ZmkoygY"
      },
      "source": [
        "## Exercise 2.1 [optional]: do-it-together\n",
        "\n",
        "Using the `scikitlearn` dataset `diabetes`, you should fit a simple linear regression model with **Keras**:\n",
        "\n",
        "- select one feature from the data (age, sex, bmi etc.)\n",
        "- build your Keras model\n",
        "- compile the model\n",
        "- fit the model\n",
        "- evaluate the model\n",
        "\n",
        "We have prepared the data loading step for you:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CypetAKGrUwq"
      },
      "source": [
        "import pandas as pd\n",
        "import sklearn.datasets\n",
        "\n",
        "diabetes = sklearn.datasets.load_diabetes()\n",
        "diabetes.data = pd.DataFrame(diabetes.data, columns=diabetes.feature_names) #converting numpy array -> pandas DataFrame\n",
        "diabetes.target = pd.Series(diabetes.target)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bnUXPvVUryGn"
      },
      "source": [
        "print(diabetes.DESCR)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bi7iWJJTrqLd"
      },
      "source": [
        "diabetes.data ## features"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "L2OfxaI6ru_5"
      },
      "source": [
        "diabetes.target ## quantitative measure of disease progression"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lYSoICBFswA7"
      },
      "source": [
        "Now it's our turn to play a bit with basic Keras: let's enjoy it!"
      ]
    }
  ]
}