LSTM.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From c:\\Users\\PHC\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\site-packages\\keras\\src\\losses.py:2976: The name tf.losses.sparse_softmax_cross_entropy is deprecated. Please use tf.compat.v1.losses.sparse_softmax_cross_entropy instead.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Thư viện sử dụng\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.preprocessing import LabelEncoder\n",
    "import tensorflow as tf\n",
    "from tensorflow.keras.preprocessing.text import Tokenizer\n",
    "from tensorflow.keras.preprocessing.sequence import pad_sequences\n",
    "from tensorflow.keras.utils import to_categorical\n",
    "from tensorflow.keras.models import Sequential\n",
    "from tensorflow.keras.layers import Embedding, LSTM, Dense, Bidirectional\n",
    "import joblib\n",
    "from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score\n",
    "from pyvi import ViTokenizer\n",
    "import re\n",
    "from tensorflow.keras import backend as K\n",
    "\n",
    "import warnings\n",
    "warnings.filterwarnings(\"ignore\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Định nghĩa lớp Attention\n",
    "class Attention(tf.keras.layers.Layer):\n",
    "    def __init__(self, return_sequences=False):\n",
    "        self.return_sequences = return_sequences\n",
    "        super(Attention, self).__init__()\n",
    "\n",
    "    def build(self, input_shape):\n",
    "        self.W = self.add_weight(name=\"att_weight\", shape=(input_shape[-1], 1), initializer=\"normal\")\n",
    "        self.b = self.add_weight(name=\"att_bias\", shape=(input_shape[1], 1), initializer=\"zeros\")\n",
    "\n",
    "        super(Attention, self).build(input_shape)\n",
    "\n",
    "    def call(self, x):\n",
    "        e = K.tanh(K.dot(x, self.W) + self.b)\n",
    "        a = K.softmax(e, axis=1)\n",
    "\n",
    "        if self.return_sequences:\n",
    "            return a * x\n",
    "        else:\n",
    "            return K.sum(a * x, axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "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>tokenized_contents</th>\n",
       "      <th>Category</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>quý iii giao_dịch bất_động_sản thị_trường đà_n...</td>\n",
       "      <td>Bất động sản</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>tin_tưởng hùn vốn giám_đốc công_ty bất_động_sả...</td>\n",
       "      <td>Bất động sản</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>chủ_tịch ubnd tỉnh bắc ninh phê_duyệt quy_hoạc...</td>\n",
       "      <td>Bất động sản</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                  tokenized_contents      Category\n",
       "0  quý iii giao_dịch bất_động_sản thị_trường đà_n...  Bất động sản\n",
       "1  tin_tưởng hùn vốn giám_đốc công_ty bất_động_sả...  Bất động sản\n",
       "2  chủ_tịch ubnd tỉnh bắc ninh phê_duyệt quy_hoạc...  Bất động sản"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Tạo DataFrame mới chỉ chứa 2 cột \"Summary\" và \"Category\"\n",
    "data = pd.read_excel(\"data.xlsx\") #thay thế bằng dữ liệu sau tiền xử lý\n",
    "lstm_train_data = data.copy()\n",
    "lstm_train_data = lstm_train_data[[\"tokenized_contents\", \"Category\"]]\n",
    "lstm_train_data.head(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['Bất động sản', 'Công nghệ', 'Văn hóa - Giải trí',\n",
       "       'Gia đình - Hôn nhân', 'Giáo dục', 'Tấm Lòng Vàng', 'Pháp luật',\n",
       "       'Sức khỏe', 'Thông tin tiện ích', 'Thế giới', 'Thể thao',\n",
       "       'Tin tức việc làm', 'Xe +'], dtype=object)"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Chia thành cột tokenized_contents và cột Category\n",
    "sentences = lstm_train_data['tokenized_contents'].tolist()\n",
    "labels = lstm_train_data['Category'].tolist()\n",
    "lstm_train_data['Category'].unique()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  0,  0, ..., 12, 12, 12], dtype=int64)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Sử dụng LabelEncoder để mã hóa nhãn\n",
    "label_encoder = LabelEncoder()\n",
    "labels_encoded = label_encoder.fit_transform(labels)\n",
    "labels_encoded"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[501,\n",
       "  2623,\n",
       "  94,\n",
       "  47,\n",
       "  75,\n",
       "  2,\n",
       "  51,\n",
       "  34,\n",
       "  5,\n",
       "  364,\n",
       "  398,\n",
       "  1044,\n",
       "  1716,\n",
       "  14,\n",
       "  78,\n",
       "  14,\n",
       "  123,\n",
       "  793,\n",
       "  211,\n",
       "  953,\n",
       "  706,\n",
       "  588,\n",
       "  266,\n",
       "  208,\n",
       "  34,\n",
       "  5]]"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Xử lý dữ liệu văn bản\n",
    "tokenizer = Tokenizer()\n",
    "tokenizer.fit_on_texts(sentences)\n",
    "word_index = tokenizer.word_index\n",
    "vocab_size = len(word_index) + 1\n",
    "sequences = tokenizer.texts_to_sequences(sentences)\n",
    "sequences[:1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Chia thành tập huấn luyện và tập kiểm tra\n",
    "X_train, X_test, y_train, y_test = train_test_split(sequences, labels_encoded, test_size=0.2, random_state=42)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[   0,    0,    0, ...,  201,    8,    4],\n",
       "       [   0,    0,    0, ...,  996,  708,  340],\n",
       "       [   0,    0,    0, ..., 1102,  481,    5],\n",
       "       ...,\n",
       "       [   0,    0,    0, ..., 6316, 6317, 6318],\n",
       "       [   0,    0,    0, ...,  150,  928,   39],\n",
       "       [   0,    0,    0, ...,  159, 2924, 3395]])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Xử lý dữ liệu đầu vào\n",
    "max_length = max(len(seq) for seq in sequences)\n",
    "X_train = pad_sequences(X_train, maxlen=max_length)\n",
    "X_test = pad_sequences(X_test, maxlen=max_length)\n",
    "X_train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From c:\\Users\\PHC\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\site-packages\\keras\\src\\backend.py:873: The name tf.get_default_graph is deprecated. Please use tf.compat.v1.get_default_graph instead.\n",
      "\n",
      "WARNING:tensorflow:From c:\\Users\\PHC\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\site-packages\\keras\\src\\optimizers\\__init__.py:309: The name tf.train.Optimizer is deprecated. Please use tf.compat.v1.train.Optimizer instead.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Chuẩn bị nhãn & Mô hình\n",
    "num_classes = len(label_encoder.classes_)\n",
    "one_hot_labels_train = to_categorical(y_train, num_classes=num_classes)\n",
    "one_hot_labels_test = to_categorical(y_test, num_classes=num_classes)\n",
    "\n",
    "embedding_dim = 100\n",
    "\n",
    "model = Sequential()\n",
    "model.add(Embedding(vocab_size, embedding_dim, input_length=max_length))\n",
    "model.add(Bidirectional(LSTM(128, return_sequences=True)))\n",
    "model.add(Attention())\n",
    "# model.add(Dense(num_classes, activation='relu'))\n",
    "model.add(Dense(num_classes, activation='softmax'))\n",
    "\n",
    "model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From c:\\Users\\PHC\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\site-packages\\keras\\src\\utils\\tf_utils.py:492: The name tf.ragged.RaggedTensorValue is deprecated. Please use tf.compat.v1.ragged.RaggedTensorValue instead.\n",
      "\n",
      "WARNING:tensorflow:From c:\\Users\\PHC\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\site-packages\\keras\\src\\engine\\base_layer_utils.py:384: The name tf.executing_eagerly_outside_functions is deprecated. Please use tf.compat.v1.executing_eagerly_outside_functions instead.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "usemodel = model.fit(X_train, one_hot_labels_train, batch_size=16, epochs=5, validation_data=(X_test, one_hot_labels_test), verbose=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/5\n",
      "  Train Loss: 2.0124 - Train Accuracy: 0.2820\n",
      "  Val Loss: 1.6193 - Val Accuracy: 0.4399\n",
      "Epoch 2/5\n",
      "  Train Loss: 1.1894 - Train Accuracy: 0.6036\n",
      "  Val Loss: 1.0863 - Val Accuracy: 0.6496\n",
      "Epoch 3/5\n",
      "  Train Loss: 0.7394 - Train Accuracy: 0.7719\n",
      "  Val Loss: 0.8458 - Val Accuracy: 0.7431\n",
      "Epoch 4/5\n",
      "  Train Loss: 0.4588 - Train Accuracy: 0.8642\n",
      "  Val Loss: 0.8476 - Val Accuracy: 0.7461\n",
      "Epoch 5/5\n",
      "  Train Loss: 0.3280 - Train Accuracy: 0.9083\n",
      "  Val Loss: 0.7872 - Val Accuracy: 0.7697\n"
     ]
    }
   ],
   "source": [
    "epochs=5\n",
    "\n",
    "# Hiển thị loss và accuracy của từng epoch\n",
    "train_loss = usemodel.history['loss']\n",
    "train_accuracy = usemodel.history['accuracy']\n",
    "val_loss = usemodel.history['val_loss']\n",
    "val_accuracy = usemodel.history['val_accuracy']\n",
    "\n",
    "for epoch in range(epochs):\n",
    "    print(f\"Epoch {epoch+1}/{epochs}\")\n",
    "    print(f\"  Train Loss: {train_loss[epoch]:.4f} - Train Accuracy: {train_accuracy[epoch]:.4f}\")\n",
    "    print(f\"  Val Loss: {val_loss[epoch]:.4f} - Val Accuracy: {val_accuracy[epoch]:.4f}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "63/63 [==============================] - 4s 61ms/step - loss: 0.7872 - accuracy: 0.7697\n",
      "Loss: 0.7871654033660889\n",
      "Accuracy: 0.7697335481643677\n"
     ]
    }
   ],
   "source": [
    "# Đánh giá mô hình trên tập kiểm tra\n",
    "loss, accuracy = model.evaluate(X_test, one_hot_labels_test)\n",
    "print('Loss:', loss)\n",
    "print('Accuracy:', accuracy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['lstm_model.joblib']"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Lưu mô hình với encoding UTF-8\n",
    "joblib.dump(model, 'lstm_model.joblib')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1/1 [==============================] - 1s 1s/step\n",
      "Sentence: Sự phát triển của ngành công nghiệp điện ảnh đã tạo ra nhiều phim ảnh sáng tạo và hấp dẫn, mang đến cho khán giả trải nghiệm giải trí độc đáo.\n",
      "Predicted label: Văn hóa - Giải trí\n",
      "\n",
      "Sentence: Công nghệ AI đang thay đổi cách chúng ta tương tác với thế giới, từ việc giúp chúng ta tìm kiếm thông tin nhanh chóng đến việc tạo ra trợ lý ảo thông minh.\n",
      "Predicted label: Công nghệ\n",
      "\n",
      "Sentence: Thay đổi khí hậu đang là một vấn đề toàn cầu cấp bách, yêu cầu sự hợp tác và hành động quyết liệt từ tất cả các quốc gia trên thế giới.\n",
      "Predicted label: Thể thao\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array(['Văn hóa - Giải trí', 'Công nghệ', 'Thể thao'], dtype='<U19')"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#-------------------------------------------------------------------------------------------------------------------------------------------\n",
    "# Sử dụng mô hình (Mẫu)\n",
    "\n",
    "# Đường dẫn tới tệp stopword\n",
    "stopword_file = 'vietnamese.txt'\n",
    "\n",
    "# Đọc danh sách từ stopword từ tệp\n",
    "with open(stopword_file, 'r', encoding='utf-8') as f:\n",
    "    stopword_list = [word.strip() for word in f.readlines()]\n",
    "\n",
    "# Chuẩn bị câu mới\n",
    "new_sentences = [\n",
    "    \"Sự phát triển của ngành công nghiệp điện ảnh đã tạo ra nhiều phim ảnh sáng tạo và hấp dẫn, mang đến cho khán giả trải nghiệm giải trí độc đáo.\",\n",
    "    \"Công nghệ AI đang thay đổi cách chúng ta tương tác với thế giới, từ việc giúp chúng ta tìm kiếm thông tin nhanh chóng đến việc tạo ra trợ lý ảo thông minh.\",\n",
    "    \"Thay đổi khí hậu đang là một vấn đề toàn cầu cấp bách, yêu cầu sự hợp tác và hành động quyết liệt từ tất cả các quốc gia trên thế giới.\"\n",
    "]\n",
    "\n",
    "# Tiền xử lý câu mới\n",
    "preprocessed_sentences = []\n",
    "for sentence in new_sentences:\n",
    "    sentence = re.sub(r'[^\\w\\s]', '', sentence)\n",
    "    sentence = ViTokenizer.tokenize(sentence)\n",
    "    words = sentence.split()\n",
    "    words = [word for word in words if word.lower() not in stopword_list]\n",
    "    sentence = ' '.join(words)\n",
    "    preprocessed_sentences.append(sentence)\n",
    "\n",
    "# Chuyển đổi câu mới thành chuỗi số\n",
    "new_sequences = tokenizer.texts_to_sequences(preprocessed_sentences)\n",
    "new_sequences = pad_sequences(new_sequences, maxlen=max_length)\n",
    "\n",
    "# Dự đoán nhãn cho các câu mới\n",
    "predictions = model.predict(new_sequences)\n",
    "predicted_labels = label_encoder.inverse_transform(np.argmax(predictions, axis=1))\n",
    "\n",
    "# In kết quả dự đoán\n",
    "for sentence, label in zip(new_sentences, predicted_labels):\n",
    "    print(\"Sentence:\", sentence)\n",
    "    print(\"Predicted label:\", label)\n",
    "    print()\n",
    "\n",
    "predicted_labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Thư viện sử dụng\n",
    "import numpy as np\n",
    "import time\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "from sklearn.metrics import confusion_matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Completed training 1 time(s). Training time: 52.88s\n",
      "Completed training 2 time(s). Training time: 50.81s\n",
      "Completed training 3 time(s). Training time: 48.79s\n",
      "Completed training 4 time(s). Training time: 50.03s\n",
      "Completed training 5 time(s). Training time: 47.93s\n",
      "Completed training 6 time(s). Training time: 46.65s\n",
      "Completed training 7 time(s). Training time: 50.21s\n",
      "Completed training 8 time(s). Training time: 47.18s\n",
      "Completed training 9 time(s). Training time: 47.01s\n",
      "Completed training 10 time(s). Training time: 46.57s\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "63/63 [==============================] - 3s 49ms/step\n",
      "Accuracy: 0.78\n",
      "Precision: 0.80\n",
      "Recall: 0.76\n",
      "F1-score: 0.77\n"
     ]
    }
   ],
   "source": [
    "#-------------------------------------------------------------------------------------------------------------------------------------------\n",
    "# Đánh giá siêu tham số của mô hình\n",
    "\n",
    "# Huấn luyện mô hình - Timing - 6 tiếng\n",
    "batch_size = 32\n",
    "epochs = 1\n",
    "\n",
    "train_times = []  # Lưu trữ thời gian huấn luyện\n",
    "\n",
    "for i in range(10):\n",
    "    start_time = time.time()\n",
    "    history = model.fit(X_train, one_hot_labels_train, batch_size=batch_size, epochs=epochs, validation_data=(X_test, one_hot_labels_test), verbose=0)\n",
    "    end_time = time.time()\n",
    "    train_time = end_time - start_time\n",
    "    train_times.append(train_time)\n",
    "    print(f\"Completed training {i + 1} time(s). Training time: {train_time:.2f}s\")\n",
    "\n",
    "# Vẽ đồ thị thời gian huấn luyện\n",
    "plt.plot(range(1, 11), train_times, marker='o', linestyle='-', color='blue')\n",
    "plt.axhline(y=np.mean(train_times), color='red', linestyle='--')\n",
    "plt.xlabel('Training Iteration')\n",
    "plt.ylabel('Training Time (seconds)')\n",
    "plt.title('Training Time per Iteration')\n",
    "plt.grid(True)\n",
    "plt.show()\n",
    "\n",
    "# Đánh giá mô hình trên tập kiểm tra\n",
    "y_pred = model.predict(X_test)\n",
    "y_pred = np.argmax(y_pred, axis=1)\n",
    "y_test = np.argmax(one_hot_labels_test, axis=1)\n",
    "\n",
    "accuracy = np.mean(y_pred == y_test)\n",
    "precision = precision_score(y_test, y_pred, average='macro')\n",
    "recall = recall_score(y_test, y_pred, average='macro')\n",
    "f1 = f1_score(y_test, y_pred, average='macro')\n",
    "\n",
    "print(f'Accuracy: {accuracy:.2f}')\n",
    "print(f'Precision: {precision:.2f}')\n",
    "print(f'Recall: {recall:.2f}')\n",
    "print(f'F1-score: {f1:.2f}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "63/63 [==============================] - 3s 50ms/step\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1500x1200 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#-------------------------------------------------------------------------------------------------------------------------------------------\n",
    "# Biểu diễn trực quan mô hình (Dự đoán - Thực tế)\n",
    "\n",
    "# Dự đoán nhãn trên tập kiểm tra\n",
    "test_predictions = model.predict(X_test)\n",
    "test_predicted_labels = label_encoder.inverse_transform(np.argmax(test_predictions, axis=1))\n",
    "\n",
    "# Tính toán ma trận nhầm lẫn trên tập kiểm tra\n",
    "test_cm = confusion_matrix(label_encoder.inverse_transform(np.argmax(one_hot_labels_test, axis=1)), test_predicted_labels)\n",
    "\n",
    "# Trực quan hóa ma trận nhầm lẫn trên tập kiểm tra\n",
    "plt.figure(figsize=(15, 12))\n",
    "sns.heatmap(test_cm, annot=True, fmt='d', cmap='Blues', annot_kws={\"fontsize\": 6})\n",
    "plt.xlabel('Predicted Labels')\n",
    "plt.ylabel('True Labels')\n",
    "plt.title('Confusion Matrix - Test Data')\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.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}