Land_use_&_Land_cover_Classification.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "gpuType": "T4"
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "# **Preprocessing**"
      ],
      "metadata": {
        "id": "lsnvFF6EMm2j"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "cxtsbsynxusR"
      },
      "outputs": [],
      "source": [
        "from osgeo import gdal\n",
        "import numpy as np\n",
        "import os"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/drive')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GkZpYliblatD",
        "outputId": "9924b2ed-061f-4db8-8abd-5033d8d96a2b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mounted at /content/drive\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Specify the path to the main folder containing class folders in Google Drive\n",
        "folders_path = '/content/drive/MyDrive/Data/'\n",
        "\n",
        "# List the class folders within the main folder\n",
        "classes = os.listdir(folders_path)\n",
        "\n",
        "# Create an empty dictionary to store class names and their corresponding numerical labels\n",
        "dict_class = {}\n",
        "\n",
        "# Iterate through the classes and assign a numerical label to each class\n",
        "for i in range(len(classes)):\n",
        "    # The numerical label is assigned as i+1 to start from 1\n",
        "    dict_class.update({classes[i]: i + 1})\n",
        "\n",
        "# Display the resulting dictionary\n",
        "dict_class"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YJ0c__1f8Xbk",
        "outputId": "9f716f2f-bb57-4f1b-f34e-ff0456de5d7f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'PermanentCrop': 1,\n",
              " 'River': 2,\n",
              " 'Highway': 3,\n",
              " 'Residential': 4,\n",
              " 'SeaLake': 5,\n",
              " 'Pasture': 6,\n",
              " 'HerbaceousVegetation': 7,\n",
              " 'AnnualCrop': 8,\n",
              " 'Industrial': 9,\n",
              " 'Forest': 10}"
            ]
          },
          "metadata": {},
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Define the total number of classes in your dataset\n",
        "num_classes = 10\n",
        "\n",
        "# Specify the number of patches\n",
        "patch_numbers = 1000\n",
        "\n",
        "# Define the size of each image patch (assuming it's a square)\n",
        "patch_size = 64\n",
        "\n",
        "# Specify the number of spectral bands in your satellite imagery\n",
        "bands = 13\n",
        "\n",
        "# Create empty arrays to store your input images (X) and corresponding labels (Y)\n",
        "X = np.zeros((patch_numbers, patch_size, patch_size, bands), dtype='float32')\n",
        "Y = np.zeros((patch_numbers, num_classes), dtype='float32')"
      ],
      "metadata": {
        "id": "XbotiZAB82gj"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Initialize a counter to keep track of the total number of patches processed\n",
        "Counter = 0\n",
        "# Iterate through each class in your dataset\n",
        "for cls in classes:\n",
        "    # Get a list of images in the current class folder\n",
        "    image_list = os.listdir(folders_path + cls)\n",
        "\n",
        "    # Iterate through each image in the current class\n",
        "    for img in image_list:\n",
        "        # Read the image using GDAL (assuming it's a raster image)\n",
        "        image = gdal.Open(folders_path + cls + '/' + img).ReadAsArray()\n",
        "\n",
        "        # Create an empty array to store the reshaped image with the desired patch size and bands\n",
        "        new_image = np.zeros((patch_size, patch_size, bands), dtype='float32')\n",
        "\n",
        "        # Iterate through each band in the original image\n",
        "        for b in range(bands):\n",
        "            # Copy the band to the corresponding slice in the new image\n",
        "            new_image[:, :, b] = image[b, :, :]\n",
        "\n",
        "        # Store the reshaped image in the X array\n",
        "        X[Counter, :, :, :] = new_image\n",
        "\n",
        "        # Determine the column (class label) for the current image and update the Y array\n",
        "        column = dict_class[cls]\n",
        "        Y[Counter, column - 1] = 1\n",
        "\n",
        "        # Increment the counter\n",
        "        Counter = Counter + 1"
      ],
      "metadata": {
        "id": "c25AP-S3x23Q"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Print the shapes of the X and Y arrays for verification\n",
        "print('X shape: ', X.shape)\n",
        "print('Y shape: ', Y.shape)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "CYtUOXCYDoqT",
        "outputId": "f0ceb08f-45ba-49c6-ec5f-d6867822f19d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "X shape:  (1000, 64, 64, 13)\n",
            "Y shape:  (1000, 10)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Create an array of indices ranging from 0 to the total number of patches\n",
        "indexes = np.arange(X.shape[0])\n",
        "\n",
        "# Shuffle the indices randomly to ensure randomness in train/validation split\n",
        "np.random.shuffle(indexes)\n",
        "\n",
        "# Determine the index for the split between training and validation sets (90%/10%)\n",
        "train_index = indexes[: int(0.9 * X.shape[0])]\n",
        "val_index = indexes[int(0.9 * X.shape[0]):]\n",
        "\n",
        "# Use the indices to extract the corresponding patches for training and validation\n",
        "x_train = X[train_index]\n",
        "x_val = X[val_index]\n",
        "y_train = Y[train_index]\n",
        "y_val = Y[val_index]\n",
        "\n",
        "# Print the shapes of the training and validation sets for verification\n",
        "print('X Train shape: ', x_train.shape)\n",
        "print('Y Train shape: ', y_train.shape)\n",
        "print('X Validation shape: ', x_val.shape)\n",
        "print('Y Validation shape: ', y_val.shape)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "EIjNGIre628g",
        "outputId": "d6a6e6f4-37bb-4769-ec69-a68ff51b6d3e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "X Train shape:  (900, 64, 64, 13)\n",
            "Y Train shape:  (900, 10)\n",
            "X Validation shape:  (100, 64, 64, 13)\n",
            "Y Validation shape:  (100, 10)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Deep Learning Model**"
      ],
      "metadata": {
        "id": "qrXbWE4eMhCc"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import tensorflow as tf\n",
        "from tensorflow.keras import layers"
      ],
      "metadata": {
        "id": "vhrJ1LWTHCxM"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def cnn_model(input_shape, num_classes=10):\n",
        "    # Define the input layer with the specified shape\n",
        "    inputs = layers.Input(shape=input_shape)\n",
        "\n",
        "    # Convolutional and pooling layers to capture hierarchical features\n",
        "    conv1 = layers.Conv2D(32, (3, 3), activation='relu')(inputs)\n",
        "    pool1 = layers.MaxPooling2D(pool_size=(2, 2))(conv1)\n",
        "\n",
        "    conv2 = layers.Conv2D(64, (3, 3), activation='relu')(pool1)\n",
        "    pool2 = layers.MaxPooling2D(pool_size=(2, 2))(conv2)\n",
        "\n",
        "    conv3 = layers.Conv2D(128, (3, 3), activation='relu')(pool2)\n",
        "    pool3 = layers.MaxPooling2D(pool_size=(2, 2))(conv3)\n",
        "\n",
        "    # Flatten the output for feeding into dense layers\n",
        "    flat = layers.Flatten()(pool3)\n",
        "\n",
        "    # Dense layers for classification with ReLU activation\n",
        "    dense1 = layers.Dense(128, activation='relu')(flat)\n",
        "    dense2 = layers.Dense(256, activation='relu')(dense1)\n",
        "\n",
        "    # Output layer with softmax activation for multi-class classification\n",
        "    dense3 = layers.Dense(num_classes, activation='softmax')(dense2)\n",
        "\n",
        "    # Create the model with the defined inputs and outputs\n",
        "    model = tf.keras.Model(inputs=inputs, outputs=dense3)\n",
        "\n",
        "    return model"
      ],
      "metadata": {
        "id": "xoN8jYItA6ZG"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Define the input shape based on the shape of the training data (excluding the batch size)\n",
        "input_shape = x_train.shape[1:]\n",
        "\n",
        "# Create an instance of the CNN model using the defined input shape and specifying the number of classes\n",
        "model = cnn_model(input_shape, num_classes=10)\n",
        "\n",
        "# Display a summary of the model architecture, including the layers, parameters, and output shapes\n",
        "model.summary()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LfFLiPLmJG7r",
        "outputId": "ecf0462b-dd9d-4b5f-afcc-501a0210cfd7"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"model\"\n",
            "_________________________________________________________________\n",
            " Layer (type)                Output Shape              Param #   \n",
            "=================================================================\n",
            " input_1 (InputLayer)        [(None, 64, 64, 13)]      0         \n",
            "                                                                 \n",
            " conv2d (Conv2D)             (None, 62, 62, 32)        3776      \n",
            "                                                                 \n",
            " max_pooling2d (MaxPooling2  (None, 31, 31, 32)        0         \n",
            " D)                                                              \n",
            "                                                                 \n",
            " conv2d_1 (Conv2D)           (None, 29, 29, 64)        18496     \n",
            "                                                                 \n",
            " max_pooling2d_1 (MaxPoolin  (None, 14, 14, 64)        0         \n",
            " g2D)                                                            \n",
            "                                                                 \n",
            " conv2d_2 (Conv2D)           (None, 12, 12, 128)       73856     \n",
            "                                                                 \n",
            " max_pooling2d_2 (MaxPoolin  (None, 6, 6, 128)         0         \n",
            " g2D)                                                            \n",
            "                                                                 \n",
            " flatten (Flatten)           (None, 4608)              0         \n",
            "                                                                 \n",
            " dense (Dense)               (None, 128)               589952    \n",
            "                                                                 \n",
            " dense_1 (Dense)             (None, 256)               33024     \n",
            "                                                                 \n",
            " dense_2 (Dense)             (None, 10)                2570      \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 721674 (2.75 MB)\n",
            "Trainable params: 721674 (2.75 MB)\n",
            "Non-trainable params: 0 (0.00 Byte)\n",
            "_________________________________________________________________\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Compile the model with specified configuration for training\n",
        "model.compile(\n",
        "    # Use the Adam optimizer with a learning rate of 0.00001\n",
        "    optimizer=tf.keras.optimizers.Adam(learning_rate=0.00001),\n",
        "\n",
        "    # Use Binary Crossentropy as the loss function for binary classification\n",
        "    loss=tf.keras.losses.BinaryCrossentropy(),\n",
        "\n",
        "    # Track and display accuracy as a metric during training\n",
        "    metrics=['accuracy']\n",
        ")"
      ],
      "metadata": {
        "id": "Lg_gIr9LJkPg"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Train the model on the training data\n",
        "history = model.fit(\n",
        "    # Input features (training data)\n",
        "    x=x_train,\n",
        "\n",
        "    # Target labels (training labels)\n",
        "    y=y_train,\n",
        "\n",
        "    # Validation data for monitoring model performance on a separate dataset\n",
        "    validation_data=(x_val, y_val),\n",
        "\n",
        "    # Number of epochs for training\n",
        "    epochs=20\n",
        ")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zfPwZi8VJ95E",
        "outputId": "e89a2b92-d0ae-44b1-a048-abe68196a92f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/20\n",
            "29/29 [==============================] - 12s 29ms/step - loss: 66.8067 - accuracy: 0.1089 - val_loss: 17.4883 - val_accuracy: 0.1000\n",
            "Epoch 2/20\n",
            "29/29 [==============================] - 0s 12ms/step - loss: 13.3114 - accuracy: 0.1244 - val_loss: 9.0374 - val_accuracy: 0.1500\n",
            "Epoch 3/20\n",
            "29/29 [==============================] - 0s 13ms/step - loss: 7.6538 - accuracy: 0.1989 - val_loss: 6.3364 - val_accuracy: 0.1900\n",
            "Epoch 4/20\n",
            "29/29 [==============================] - 0s 13ms/step - loss: 5.9179 - accuracy: 0.3100 - val_loss: 5.3618 - val_accuracy: 0.3300\n",
            "Epoch 5/20\n",
            "29/29 [==============================] - 0s 11ms/step - loss: 5.0031 - accuracy: 0.3444 - val_loss: 4.7600 - val_accuracy: 0.3300\n",
            "Epoch 6/20\n",
            "29/29 [==============================] - 0s 11ms/step - loss: 4.3507 - accuracy: 0.3556 - val_loss: 4.6937 - val_accuracy: 0.3300\n",
            "Epoch 7/20\n",
            "29/29 [==============================] - 0s 11ms/step - loss: 4.0587 - accuracy: 0.3878 - val_loss: 3.9068 - val_accuracy: 0.3800\n",
            "Epoch 8/20\n",
            "29/29 [==============================] - 0s 12ms/step - loss: 3.7256 - accuracy: 0.4011 - val_loss: 4.0526 - val_accuracy: 0.4000\n",
            "Epoch 9/20\n",
            "29/29 [==============================] - 0s 11ms/step - loss: 3.4583 - accuracy: 0.4300 - val_loss: 3.8344 - val_accuracy: 0.4300\n",
            "Epoch 10/20\n",
            "29/29 [==============================] - 0s 11ms/step - loss: 3.2003 - accuracy: 0.4589 - val_loss: 3.5510 - val_accuracy: 0.4200\n",
            "Epoch 11/20\n",
            "29/29 [==============================] - 0s 12ms/step - loss: 3.0419 - accuracy: 0.4511 - val_loss: 3.5160 - val_accuracy: 0.4400\n",
            "Epoch 12/20\n",
            "29/29 [==============================] - 0s 11ms/step - loss: 2.9245 - accuracy: 0.4633 - val_loss: 3.1850 - val_accuracy: 0.4300\n",
            "Epoch 13/20\n",
            "29/29 [==============================] - 0s 13ms/step - loss: 2.8429 - accuracy: 0.4833 - val_loss: 3.1842 - val_accuracy: 0.4600\n",
            "Epoch 14/20\n",
            "29/29 [==============================] - 0s 15ms/step - loss: 2.7021 - accuracy: 0.4811 - val_loss: 3.1993 - val_accuracy: 0.4600\n",
            "Epoch 15/20\n",
            "29/29 [==============================] - 0s 15ms/step - loss: 2.5514 - accuracy: 0.4989 - val_loss: 2.9703 - val_accuracy: 0.4300\n",
            "Epoch 16/20\n",
            "29/29 [==============================] - 0s 13ms/step - loss: 2.6072 - accuracy: 0.4933 - val_loss: 2.7503 - val_accuracy: 0.4400\n",
            "Epoch 17/20\n",
            "29/29 [==============================] - 0s 15ms/step - loss: 2.3786 - accuracy: 0.5056 - val_loss: 2.8404 - val_accuracy: 0.5000\n",
            "Epoch 18/20\n",
            "29/29 [==============================] - 0s 15ms/step - loss: 2.3415 - accuracy: 0.5100 - val_loss: 2.9274 - val_accuracy: 0.5000\n",
            "Epoch 19/20\n",
            "29/29 [==============================] - 0s 15ms/step - loss: 2.1885 - accuracy: 0.5256 - val_loss: 2.6307 - val_accuracy: 0.4700\n",
            "Epoch 20/20\n",
            "29/29 [==============================] - 0s 14ms/step - loss: 2.0538 - accuracy: 0.5333 - val_loss: 2.5772 - val_accuracy: 0.4900\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Model Assesment**"
      ],
      "metadata": {
        "id": "1V0q_vAwJdIC"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Importing necessary libraries\n",
        "import matplotlib.pyplot as plt\n",
        "import seaborn as sns\n",
        "from sklearn.metrics import f1_score,accuracy_score, precision_score, recall_score,confusion_matrix"
      ],
      "metadata": {
        "id": "uLqviCDNKWDT"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Set the figure size and dpi for the plot\n",
        "plt.figure(figsize=(3, 2), dpi=100)\n",
        "\n",
        "# Plot the training loss over epochs\n",
        "plt.plot(np.array(history.history['loss']), label='Training Loss')\n",
        "\n",
        "# Plot the validation loss over epochs\n",
        "plt.plot(np.array(history.history['val_loss']), label='Validation Loss')\n",
        "\n",
        "# Set labels for the axes\n",
        "plt.ylabel('Loss Function')\n",
        "plt.xlabel('Epochs')\n",
        "\n",
        "# Add a legend to identify the lines in the plot\n",
        "plt.legend(['Train', 'Validation'], loc='best')\n",
        "\n",
        "# Display the plot\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "_8sc9zCWNBwb",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 234
        },
        "outputId": "480a96d0-1dc0-47a5-ccf4-bbef12818650"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 300x200 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Evaluate the model on the validation data\n",
        "evaluation_results = model.evaluate(x_val, y_val)\n",
        "\n",
        "# Print or use the evaluation results as needed\n",
        "print(\"Evaluation Results:\", evaluation_results)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZMAm9HjeKlMi",
        "outputId": "b73f11d5-3fb3-4cdc-e5c4-a8b44a1df110"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "4/4 [==============================] - 0s 6ms/step - loss: 2.5772 - accuracy: 0.4900\n",
            "Evaluation Results: [2.5772364139556885, 0.49000000953674316]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Make predictions using the trained model on the validation data\n",
        "y_pred = model.predict(x_val)\n",
        "\n",
        "# Display the shape of the predicted values\n",
        "print(\"Shape of Predicted Values:\", y_pred.shape)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "CcT3gqI2MuI6",
        "outputId": "9b6adf7c-ae1d-40dd-fb69-1ae01a823f5d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "4/4 [==============================] - 0s 5ms/step\n",
            "Shape of Predicted Values: (100, 10)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Get the indices of the maximum values along axis 1 for predicted values\n",
        "prediction = np.argmax(y_pred, axis=1)\n",
        "\n",
        "# Get the indices of the maximum values along axis 1 for actual values (ground truth)\n",
        "actual = np.argmax(y_val, axis=1)"
      ],
      "metadata": {
        "id": "EX7czQwmtoMh"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Calculating F1 Score using the macro average method\n",
        "f1 = f1_score(actual, prediction, average='macro')\n",
        "\n",
        "# Calculating accuracy score\n",
        "accuracy = accuracy_score(actual, prediction)\n",
        "\n",
        "# Calculating precision using the macro average method\n",
        "precision = precision_score(actual, prediction, average='macro')\n",
        "\n",
        "# Calculating recall using the macro average method\n",
        "recall = recall_score(actual, prediction, average='macro')\n",
        "\n",
        "# Printing the computed metrics\n",
        "print('F1 Score:', f1)\n",
        "print('Accuracy:', accuracy)\n",
        "print('Precision:', precision)\n",
        "print('Recall:', recall)\n"
      ],
      "metadata": {
        "id": "zdZqkQTYMuLy",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "49664654-aa64-4df3-c599-0188977e6d9c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "F1 Score: 0.43666591966834256\n",
            "Accuracy: 0.47\n",
            "Precision: 0.4483649683649684\n",
            "Recall: 0.44247835497835497\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Creating a confusion matrix using actual and predicted values\n",
        "cmat = confusion_matrix(actual, prediction)\n",
        "\n",
        "# Assuming 'classes' is a variable containing the class labels\n",
        "u = classes  # Class labels for y-axis\n",
        "v = classes  # Class labels for x-axis\n",
        "\n",
        "# Setting up the figure size and resolution for the heatmap\n",
        "plt.figure(figsize=(5, 3), dpi=150)\n",
        "\n",
        "# Creating a heatmap using seaborn with annotations, color map, and tick labels\n",
        "b = sns.heatmap(cmat, annot=True, cmap='RdYlGn', linewidths=.2, yticklabels=u, xticklabels=v)\n",
        "\n",
        "# Setting tick label sizes\n",
        "b.set_yticklabels(u, size=5)\n",
        "b.set_xticklabels(v, size=5)\n",
        "\n",
        "# Adding labels for y-axis and x-axis\n",
        "plt.ylabel('Actual', fontsize=10, fontweight='bold')\n",
        "plt.xlabel('Predicted', fontsize=10, fontweight='bold')\n",
        "\n",
        "# Displaying the heatmap\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 562
        },
        "id": "RleQ5IgRMfk8",
        "outputId": "105e4156-64b0-4a89-ddae-6962e11ff494"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 750x450 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    }
  ]
}