notebooks/iris.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import warnings\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import torch\n",
    "\n",
    "from torchsom.core import TorchSOM\n",
    "from torchsom.plotting import SOMVisualizer, VisualizationConfig\n",
    "\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.neural_network import MLPClassifier\n",
    "from sklearn.metrics import (\n",
    "    f1_score, \n",
    "    accuracy_score, \n",
    "    recall_score, \n",
    "    precision_score, \n",
    "    confusion_matrix, \n",
    "    classification_report,\n",
    "    ConfusionMatrixDisplay\n",
    ")\n",
    "from sklearn.exceptions import ConvergenceWarning, DataConversionWarning\n",
    "\n",
    "warnings.filterwarnings(\"ignore\", category=ConvergenceWarning)\n",
    "warnings.filterwarnings(\"ignore\", category=DataConversionWarning)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "random_seed = 42\n",
    "torch.manual_seed(random_seed)\n",
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Preprocessing "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "iris_df = pd.read_csv(\n",
    "    filepath_or_buffer=\"../data/iris.csv\",\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "feature_columns = iris_df.columns[:-1]  \n",
    "scaler = StandardScaler()\n",
    "iris_df[feature_columns] = scaler.fit_transform(iris_df[feature_columns])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "iris_df['Species'] = iris_df['Species'].map({\n",
    "    'Iris-setosa': 1, \n",
    "    'Iris-versicolor': 2, \n",
    "    'Iris-virginica': 3}\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.microsoft.datawrangler.viewer.v0+json": {
       "columns": [
        {
         "name": "index",
         "rawType": "int64",
         "type": "integer"
        },
        {
         "name": "Sepal Length",
         "rawType": "float64",
         "type": "float"
        },
        {
         "name": "Sepal Width",
         "rawType": "float64",
         "type": "float"
        },
        {
         "name": "Petal Length",
         "rawType": "float64",
         "type": "float"
        },
        {
         "name": "Petal Width",
         "rawType": "float64",
         "type": "float"
        },
        {
         "name": "Species",
         "rawType": "int64",
         "type": "integer"
        }
       ],
       "conversionMethod": "pd.DataFrame",
       "ref": "6214df72-d361-45b1-b0b4-73fbb4dbb243",
       "rows": [
        [
         "0",
         "-0.9006811702978088",
         "1.0320572244889565",
         "-1.3412724047598314",
         "-1.3129767272601454",
         "1"
        ],
        [
         "1",
         "-1.1430169111851105",
         "-0.12495760117130933",
         "-1.3412724047598314",
         "-1.3129767272601454",
         "1"
        ],
        [
         "2",
         "-1.3853526520724133",
         "0.3378483290927974",
         "-1.3981381087490836",
         "-1.3129767272601454",
         "1"
        ],
        [
         "3",
         "-1.5065205225160652",
         "0.10644536396074403",
         "-1.284406700770579",
         "-1.3129767272601454",
         "1"
        ],
        [
         "4",
         "-1.0218490407414595",
         "1.2634601896210098",
         "-1.3412724047598314",
         "-1.3129767272601454",
         "1"
        ]
       ],
       "shape": {
        "columns": 5,
        "rows": 5
       }
      },
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Sepal Length</th>\n",
       "      <th>Sepal Width</th>\n",
       "      <th>Petal Length</th>\n",
       "      <th>Petal Width</th>\n",
       "      <th>Species</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>-0.900681</td>\n",
       "      <td>1.032057</td>\n",
       "      <td>-1.341272</td>\n",
       "      <td>-1.312977</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>-1.143017</td>\n",
       "      <td>-0.124958</td>\n",
       "      <td>-1.341272</td>\n",
       "      <td>-1.312977</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>-1.385353</td>\n",
       "      <td>0.337848</td>\n",
       "      <td>-1.398138</td>\n",
       "      <td>-1.312977</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>-1.506521</td>\n",
       "      <td>0.106445</td>\n",
       "      <td>-1.284407</td>\n",
       "      <td>-1.312977</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>-1.021849</td>\n",
       "      <td>1.263460</td>\n",
       "      <td>-1.341272</td>\n",
       "      <td>-1.312977</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   Sepal Length  Sepal Width  Petal Length  Petal Width  Species\n",
       "0     -0.900681     1.032057     -1.341272    -1.312977        1\n",
       "1     -1.143017    -0.124958     -1.341272    -1.312977        1\n",
       "2     -1.385353     0.337848     -1.398138    -1.312977        1\n",
       "3     -1.506521     0.106445     -1.284407    -1.312977        1\n",
       "4     -1.021849     1.263460     -1.341272    -1.312977        1"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "iris_df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.microsoft.datawrangler.viewer.v0+json": {
       "columns": [
        {
         "name": "index",
         "rawType": "object",
         "type": "string"
        },
        {
         "name": "Sepal Length",
         "rawType": "float64",
         "type": "float"
        },
        {
         "name": "Sepal Width",
         "rawType": "float64",
         "type": "float"
        },
        {
         "name": "Petal Length",
         "rawType": "float64",
         "type": "float"
        },
        {
         "name": "Petal Width",
         "rawType": "float64",
         "type": "float"
        },
        {
         "name": "Species",
         "rawType": "float64",
         "type": "float"
        }
       ],
       "conversionMethod": "pd.DataFrame",
       "ref": "ef5af901-e677-4bb2-823f-dab750e668ad",
       "rows": [
        [
         "count",
         "150.0",
         "150.0",
         "150.0",
         "150.0",
         "150.0"
        ],
        [
         "mean",
         "-4.736951571734001e-16",
         "-6.631732200427602e-16",
         "3.315866100213801e-16",
         "-2.842170943040401e-16",
         "2.0"
        ],
        [
         "std",
         "1.0033500931359767",
         "1.0033500931359767",
         "1.0033500931359765",
         "1.0033500931359767",
         "0.8192319205190405"
        ],
        [
         "min",
         "-1.870024133847019",
         "-2.438987252491841",
         "-1.5687352207168408",
         "-1.4444496972795189",
         "1.0"
        ],
        [
         "25%",
         "-0.9006811702978088",
         "-0.587763531435416",
         "-1.2275409967813267",
         "-1.1815037572407716",
         "1.0"
        ],
        [
         "50%",
         "-0.05250607719224957",
         "-0.12495760117130933",
         "0.33626586292311245",
         "0.13322594295296525",
         "2.0"
        ],
        [
         "75%",
         "0.6745011454696588",
         "0.5692512942248498",
         "0.7627586428425047",
         "0.7905907930498337",
         "3.0"
        ],
        [
         "max",
         "2.4920192021244283",
         "3.1146839106774356",
         "1.7863413146490472",
         "1.7109015831854495",
         "3.0"
        ]
       ],
       "shape": {
        "columns": 5,
        "rows": 8
       }
      },
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Sepal Length</th>\n",
       "      <th>Sepal Width</th>\n",
       "      <th>Petal Length</th>\n",
       "      <th>Petal Width</th>\n",
       "      <th>Species</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>count</th>\n",
       "      <td>1.500000e+02</td>\n",
       "      <td>1.500000e+02</td>\n",
       "      <td>1.500000e+02</td>\n",
       "      <td>1.500000e+02</td>\n",
       "      <td>150.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>mean</th>\n",
       "      <td>-4.736952e-16</td>\n",
       "      <td>-6.631732e-16</td>\n",
       "      <td>3.315866e-16</td>\n",
       "      <td>-2.842171e-16</td>\n",
       "      <td>2.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>std</th>\n",
       "      <td>1.003350e+00</td>\n",
       "      <td>1.003350e+00</td>\n",
       "      <td>1.003350e+00</td>\n",
       "      <td>1.003350e+00</td>\n",
       "      <td>0.819232</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>min</th>\n",
       "      <td>-1.870024e+00</td>\n",
       "      <td>-2.438987e+00</td>\n",
       "      <td>-1.568735e+00</td>\n",
       "      <td>-1.444450e+00</td>\n",
       "      <td>1.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>25%</th>\n",
       "      <td>-9.006812e-01</td>\n",
       "      <td>-5.877635e-01</td>\n",
       "      <td>-1.227541e+00</td>\n",
       "      <td>-1.181504e+00</td>\n",
       "      <td>1.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>50%</th>\n",
       "      <td>-5.250608e-02</td>\n",
       "      <td>-1.249576e-01</td>\n",
       "      <td>3.362659e-01</td>\n",
       "      <td>1.332259e-01</td>\n",
       "      <td>2.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>75%</th>\n",
       "      <td>6.745011e-01</td>\n",
       "      <td>5.692513e-01</td>\n",
       "      <td>7.627586e-01</td>\n",
       "      <td>7.905908e-01</td>\n",
       "      <td>3.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>max</th>\n",
       "      <td>2.492019e+00</td>\n",
       "      <td>3.114684e+00</td>\n",
       "      <td>1.786341e+00</td>\n",
       "      <td>1.710902e+00</td>\n",
       "      <td>3.000000</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "       Sepal Length   Sepal Width  Petal Length   Petal Width     Species\n",
       "count  1.500000e+02  1.500000e+02  1.500000e+02  1.500000e+02  150.000000\n",
       "mean  -4.736952e-16 -6.631732e-16  3.315866e-16 -2.842171e-16    2.000000\n",
       "std    1.003350e+00  1.003350e+00  1.003350e+00  1.003350e+00    0.819232\n",
       "min   -1.870024e+00 -2.438987e+00 -1.568735e+00 -1.444450e+00    1.000000\n",
       "25%   -9.006812e-01 -5.877635e-01 -1.227541e+00 -1.181504e+00    1.000000\n",
       "50%   -5.250608e-02 -1.249576e-01  3.362659e-01  1.332259e-01    2.000000\n",
       "75%    6.745011e-01  5.692513e-01  7.627586e-01  7.905908e-01    3.000000\n",
       "max    2.492019e+00  3.114684e+00  1.786341e+00  1.710902e+00    3.000000"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "iris_df.describe()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Sepal Length', 'Sepal Width', 'Petal Length', 'Petal Width']"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "feature_names = feature_columns.to_list()\n",
    "feature_names"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(150, 5)"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "iris_df.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([120, 4]) torch.Size([30, 4])\n",
      "torch.Size([120]) torch.Size([30])\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "1. Create a tensor from the iris df and separate the features and the target\n",
    "2. Randomly shuffle the data\n",
    "3. Split the data into training and testing sets\n",
    "\"\"\"\n",
    "iris_torch = torch.tensor(iris_df.to_numpy(dtype=np.float32))\n",
    "all_features, all_targets = iris_torch[:, :4], iris_torch[:, 4].long()\n",
    "\n",
    "\n",
    "shuffled_indices = torch.randperm(len(all_features))\n",
    "all_features, all_targets = all_features[shuffled_indices], all_targets[shuffled_indices]\n",
    "\n",
    "train_ratio = 0.8\n",
    "train_count = int(train_ratio * len(all_features))\n",
    "train_features, train_targets = all_features[:train_count], all_targets[:train_count]\n",
    "test_features, test_targets = all_features[train_count:], all_targets[train_count:]\n",
    "\n",
    "print(train_features.shape, test_features.shape)\n",
    "print(train_targets.shape, test_targets.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# TorchSOM"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "som = TorchSOM(\n",
    "    x=25,\n",
    "    y=15,\n",
    "    sigma=1.45,\n",
    "    learning_rate=0.95,\n",
    "    neighborhood_order=3,\n",
    "    epochs=100,\n",
    "    batch_size=16,\n",
    "    topology=\"rectangular\",\n",
    "    distance_function=\"euclidean\",\n",
    "    neighborhood_function=\"gaussian\",\n",
    "    num_features=all_features.shape[1],\n",
    "    lr_decay_function=\"asymptotic_decay\",\n",
    "    sigma_decay_function=\"asymptotic_decay\",\n",
    "    initialization_mode=\"pca\",\n",
    "    device=device,\n",
    "    random_seed=random_seed,\n",
    ") "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "som.initialize_weights(\n",
    "    data=train_features,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Training SOM: 100%|██████████| 100/100 [00:02<00:00, 39.84epoch/s]\n"
     ]
    }
   ],
   "source": [
    "QE, TE = som.fit(\n",
    "    data=train_features\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "visualizer = SOMVisualizer(som=som, config=None)\n",
    "save_path = \"results/iris\" # Set to None if you want a direct plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "visualizer.plot_training_errors(\n",
    "    quantization_errors=QE, \n",
    "    topographic_errors=TE, \n",
    "    save_path=save_path\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "visualizer.plot_distance_map(save_path=save_path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "visualizer.plot_hit_map(\n",
    "    data=train_features,\n",
    "    save_path=save_path\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "visualizer.plot_classification_map(\n",
    "    data=train_features,\n",
    "    target=train_targets,\n",
    "    save_path=save_path\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "visualizer.plot_component_planes(\n",
    "    component_names=feature_names,\n",
    "    save_path=save_path\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Prediction\n",
    "Here, we do not add the testing samples in the SOM BMUs map.  \n",
    "In forecasting or process control, it is interesting to add overtime the new elements in the SOM and potentially to update/refit it with a certain frequency."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "predictions = []\n",
    "bmus_idx_map = som.build_bmus_data_map(\n",
    "    data=train_features,\n",
    "    return_indices=True,  # False means we want the features of each sample and not the indices\n",
    ")\n",
    "for idx, (test_feature, test_target) in enumerate(zip(test_features, test_targets)):\n",
    "    \n",
    "    collected_features, collected_targets = som.collect_samples(\n",
    "        query_sample=test_feature,\n",
    "        historical_samples=train_features,\n",
    "        historical_outputs=train_targets,\n",
    "        min_buffer_threshold=30, # Collect 20 historical samples to train a model\n",
    "        bmus_idx_map=bmus_idx_map,\n",
    "    )\n",
    "    \n",
    "    X = collected_features.cpu().numpy()\n",
    "    y = collected_targets.cpu().numpy().ravel()\n",
    "    test_feature_np = test_feature.cpu().numpy().reshape(1, -1)  \n",
    "    \n",
    "    clf = MLPClassifier(\n",
    "        hidden_layer_sizes=(8),\n",
    "        max_iter=200,\n",
    "        learning_rate_init=0.008,\n",
    "        activation=\"relu\",\n",
    "        solver=\"adam\",\n",
    "        batch_size='auto', \n",
    "        random_state=random_seed,\n",
    "        shuffle=True,\n",
    "        verbose=False,\n",
    "    ).fit(X, y)\n",
    "    \n",
    "    # plt.plot(clf.loss_curve_)\n",
    "    # plt.xlabel(\"Iteration\")\n",
    "    # plt.ylabel(\"Loss\")\n",
    "    # plt.title(\"MLPClassifier Training Loss Curve\")\n",
    "    # plt.grid(True)\n",
    "    # plt.show()\n",
    "    \n",
    "    clf_prediction = clf.predict(test_feature_np)\n",
    "    predictions.append(clf_prediction[0]) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_pred = np.array(predictions)\n",
    "y_true = test_targets.numpy()\n",
    "\n",
    "# accuracy = accuracy_score(y_true, y_pred)\n",
    "# precision = precision_score(y_true, y_pred, average='macro') # or 'weighted' or 'micro'\n",
    "# recall = recall_score(y_true, y_pred, average='macro')\n",
    "# f1 = f1_score(y_true, y_pred, average='macro') # or 'weighted' or 'micro'\n",
    "\n",
    "# print(f\"Accuracy: {accuracy:.4f}\")\n",
    "# print(f\"Precision: {precision:.4f}\")\n",
    "# print(f\"Recall (Rappel): {recall:.4f}\")\n",
    "# print(f\"F1 Score: {f1:.4f}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\t\t\tClassification report:\n",
      "\n",
      "               precision    recall  f1-score   support\n",
      "\n",
      "           1       1.00      1.00      1.00         6\n",
      "           2       0.90      0.90      0.90        10\n",
      "           3       0.93      0.93      0.93        14\n",
      "\n",
      "    accuracy                           0.93        30\n",
      "   macro avg       0.94      0.94      0.94        30\n",
      "weighted avg       0.93      0.93      0.93        30\n",
      " \n",
      "\n"
     ]
    }
   ],
   "source": [
    "class_report = classification_report(y_true, y_pred)\n",
    "print('\\t\\t\\tClassification report:\\n\\n', class_report, '\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 600x600 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "cm = confusion_matrix(y_true, y_pred)\n",
    "disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=[1, 2, 3])\n",
    "fig, ax = plt.subplots(figsize=(6, 6))\n",
    "disp.plot(ax=ax, cmap='Blues', values_format='d')\n",
    "plt.title(\"Confusion Matrix\")\n",
    "plt.grid(False)\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}