diff --git a/lab2.ipynb b/lab2.ipynb
index 79d21ee..fbc4cd4 100644
--- a/lab2.ipynb
+++ b/lab2.ipynb
@@ -2010,7 +2010,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 29,
+   "execution_count": 26,
    "metadata": {},
    "outputs": [
     {
diff --git a/lab3.ipynb b/lab3.ipynb
new file mode 100644
index 0000000..737fd49
--- /dev/null
+++ b/lab3.ipynb
@@ -0,0 +1,1112 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Вариант 4. Данные по инсультам"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Index(['id', 'gender', 'age', 'hypertension', 'heart_disease', 'ever_married',\n",
+      "       'work_type', 'Residence_type', 'avg_glucose_level', 'bmi',\n",
+      "       'smoking_status', 'stroke'],\n",
+      "      dtype='object')\n"
+     ]
+    },
+    {
+     "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>id</th>\n",
+       "      <th>gender</th>\n",
+       "      <th>age</th>\n",
+       "      <th>hypertension</th>\n",
+       "      <th>heart_disease</th>\n",
+       "      <th>ever_married</th>\n",
+       "      <th>work_type</th>\n",
+       "      <th>Residence_type</th>\n",
+       "      <th>avg_glucose_level</th>\n",
+       "      <th>bmi</th>\n",
+       "      <th>smoking_status</th>\n",
+       "      <th>stroke</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>9046</td>\n",
+       "      <td>Male</td>\n",
+       "      <td>67.0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>Yes</td>\n",
+       "      <td>Private</td>\n",
+       "      <td>Urban</td>\n",
+       "      <td>228.69</td>\n",
+       "      <td>36.6</td>\n",
+       "      <td>formerly smoked</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>51676</td>\n",
+       "      <td>Female</td>\n",
+       "      <td>61.0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>Yes</td>\n",
+       "      <td>Self-employed</td>\n",
+       "      <td>Rural</td>\n",
+       "      <td>202.21</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>never smoked</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>31112</td>\n",
+       "      <td>Male</td>\n",
+       "      <td>80.0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>Yes</td>\n",
+       "      <td>Private</td>\n",
+       "      <td>Rural</td>\n",
+       "      <td>105.92</td>\n",
+       "      <td>32.5</td>\n",
+       "      <td>never smoked</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>60182</td>\n",
+       "      <td>Female</td>\n",
+       "      <td>49.0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>Yes</td>\n",
+       "      <td>Private</td>\n",
+       "      <td>Urban</td>\n",
+       "      <td>171.23</td>\n",
+       "      <td>34.4</td>\n",
+       "      <td>smokes</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>1665</td>\n",
+       "      <td>Female</td>\n",
+       "      <td>79.0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0</td>\n",
+       "      <td>Yes</td>\n",
+       "      <td>Self-employed</td>\n",
+       "      <td>Rural</td>\n",
+       "      <td>174.12</td>\n",
+       "      <td>24.0</td>\n",
+       "      <td>never smoked</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "      id  gender   age  hypertension  heart_disease ever_married  \\\n",
+       "0   9046    Male  67.0             0              1          Yes   \n",
+       "1  51676  Female  61.0             0              0          Yes   \n",
+       "2  31112    Male  80.0             0              1          Yes   \n",
+       "3  60182  Female  49.0             0              0          Yes   \n",
+       "4   1665  Female  79.0             1              0          Yes   \n",
+       "\n",
+       "       work_type Residence_type  avg_glucose_level   bmi   smoking_status  \\\n",
+       "0        Private          Urban             228.69  36.6  formerly smoked   \n",
+       "1  Self-employed          Rural             202.21   NaN     never smoked   \n",
+       "2        Private          Rural             105.92  32.5     never smoked   \n",
+       "3        Private          Urban             171.23  34.4           smokes   \n",
+       "4  Self-employed          Rural             174.12  24.0     never smoked   \n",
+       "\n",
+       "   stroke  \n",
+       "0       1  \n",
+       "1       1  \n",
+       "2       1  \n",
+       "3       1  \n",
+       "4       1  "
+      ]
+     },
+     "execution_count": 31,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "import pandas as pd\n",
+    "import matplotlib.pyplot as plt\n",
+    "import seaborn as sns\n",
+    "from sklearn.model_selection import train_test_split\n",
+    "from imblearn.over_sampling import RandomOverSampler\n",
+    "from sklearn.preprocessing import StandardScaler\n",
+    "import featuretools as ft\n",
+    "import time\n",
+    "from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, roc_auc_score\n",
+    "from sklearn.ensemble import RandomForestClassifier\n",
+    "from sklearn.model_selection import cross_val_score\n",
+    "\n",
+    "df = pd.read_csv(\"../data/healthcare-dataset-stroke-data.csv\")\n",
+    "\n",
+    "print(df.columns)\n",
+    "df.head()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Бизнес цели и цели технического проекта.\n",
+    "## Бизнес цели:\n",
+    "### 1. Предсказание инсульта: Разработать систему, которая сможет предсказать вероятность инсульта у пациентов на основе их медицинских и социальных данных. Это может помочь медицинским учреждениям и специалистам в более раннем выявлении пациентов с высоким риском.\n",
+    "### 2. Снижение затрат на лечение: Предупреждение инсультов у пациентов позволит снизить затраты на лечение и реабилитацию. Это также поможет улучшить качество медицинских услуг и повысить удовлетворенность пациентов.\n",
+    "### 3. Повышение эффективности профилактики: Выявление факторов риска инсульта на ранней стадии может способствовать более эффективному проведению профилактических мероприятий.\n",
+    "## Цели технического проекта:\n",
+    "### 1. Создание и обучение модели машинного обучения: Разработка модели, способной предсказать вероятность инсульта на основе данных о пациентах (например, возраст, уровень глюкозы, наличие сердечно-сосудистых заболеваний, тип работы, индекс массы тела и т.д.).\n",
+    "### 2. Анализ и обработка данных: Провести предобработку данных (очистка, заполнение пропущенных значений, кодирование категориальных признаков), чтобы улучшить качество и надежность модели.\n",
+    "### 3. Оценка модели: Использовать метрики, такие как точность, полнота и F1-мера, чтобы оценить эффективность модели и минимизировать риск ложных положительных и ложных отрицательных предсказаний."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "id                     0\n",
+      "gender                 0\n",
+      "age                    0\n",
+      "hypertension           0\n",
+      "heart_disease          0\n",
+      "ever_married           0\n",
+      "work_type              0\n",
+      "Residence_type         0\n",
+      "avg_glucose_level      0\n",
+      "bmi                  201\n",
+      "smoking_status         0\n",
+      "stroke                 0\n",
+      "dtype: int64\n",
+      "\n",
+      "id                   False\n",
+      "gender               False\n",
+      "age                  False\n",
+      "hypertension         False\n",
+      "heart_disease        False\n",
+      "ever_married         False\n",
+      "work_type            False\n",
+      "Residence_type       False\n",
+      "avg_glucose_level    False\n",
+      "bmi                   True\n",
+      "smoking_status       False\n",
+      "stroke               False\n",
+      "dtype: bool\n",
+      "\n",
+      "bmi процент пустых значений: %3.93\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(df.isnull().sum())\n",
+    "print()\n",
+    "\n",
+    "print(df.isnull().any())\n",
+    "print()\n",
+    "\n",
+    "for i in df.columns:\n",
+    "    null_rate = df[i].isnull().sum() / len(df) * 100\n",
+    "    if null_rate > 0:\n",
+    "        print(f\"{i} процент пустых значений: %{null_rate:.2f}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Видим пустые значения в bmi, заменяем их"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Количество пустых значений в каждом столбце после замены:\n",
+      "id                   0\n",
+      "gender               0\n",
+      "age                  0\n",
+      "hypertension         0\n",
+      "heart_disease        0\n",
+      "ever_married         0\n",
+      "work_type            0\n",
+      "Residence_type       0\n",
+      "avg_glucose_level    0\n",
+      "bmi                  0\n",
+      "smoking_status       0\n",
+      "stroke               0\n",
+      "dtype: int64\n"
+     ]
+    }
+   ],
+   "source": [
+    "df[\"bmi\"] = df[\"bmi\"].fillna(df[\"bmi\"].median())\n",
+    "\n",
+    "missing_values = df.isnull().sum()\n",
+    "\n",
+    "print(\"Количество пустых значений в каждом столбце после замены:\")\n",
+    "print(missing_values)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Index(['gender', 'age', 'hypertension', 'heart_disease', 'ever_married',\n",
+      "       'work_type', 'Residence_type', 'avg_glucose_level', 'bmi',\n",
+      "       'smoking_status', 'stroke'],\n",
+      "      dtype='object')\n"
+     ]
+    }
+   ],
+   "source": [
+    "df = df.drop('id', axis = 1)\n",
+    "print(df.columns)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Создаем выборки"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Размер обучающей выборки:  (2503, 10)\n",
+      "Размер контрольной выборки:  (1074, 10)\n",
+      "Размер тестовой выборки:  (1533, 10)\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Разделим данные на признак (X) и переменую (Y)\n",
+    "# Начнем со stroke\n",
+    "X = df.drop(columns=['stroke'])\n",
+    "y = df['stroke']\n",
+    "\n",
+    "# Разбиваем на обучающую и тестовую выборки\n",
+    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3)\n",
+    "\n",
+    "# Разбиваем на обучающую и контрольную выборки\n",
+    "X_train, X_val, y_train, y_val = train_test_split(X_train, y_train, test_size=0.3)\n",
+    "\n",
+    "print(\"Размер обучающей выборки: \", X_train.shape)\n",
+    "print(\"Размер контрольной выборки: \", X_val.shape)\n",
+    "print(\"Размер тестовой выборки: \", X_test.shape)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Оценим сбалансированность сборок"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Распределение классов в обучающей выборке:\n",
+      "stroke\n",
+      "0    0.94966\n",
+      "1    0.05034\n",
+      "Name: proportion, dtype: float64\n",
+      "\n",
+      "Распределение классов в контрольной выборке:\n",
+      "stroke\n",
+      "0    0.946927\n",
+      "1    0.053073\n",
+      "Name: proportion, dtype: float64\n",
+      "\n",
+      "Распределение классов в тестовой выборке:\n",
+      "stroke\n",
+      "0    0.956947\n",
+      "1    0.043053\n",
+      "Name: proportion, dtype: float64\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1800x500 with 3 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "from locale import normalize\n",
+    "\n",
+    "\n",
+    "def analyze_balance(y_train, y_val, y_test, y_name):\n",
+    "    print(\"Распределение классов в обучающей выборке:\")\n",
+    "    print(y_train.value_counts(normalize=True))\n",
+    "\n",
+    "    print(\"\\nРаспределение классов в контрольной выборке:\")\n",
+    "    print(y_val.value_counts(normalize=True))\n",
+    "\n",
+    "    print(\"\\nРаспределение классов в тестовой выборке:\")\n",
+    "    print(y_test.value_counts(normalize=True))\n",
+    "\n",
+    "    fig, axes = plt.subplots(1, 3, figsize=(18,5), sharey=True)\n",
+    "    fig.suptitle('Распределение в различных выборках')\n",
+    "\n",
+    "    sns.barplot(x=y_train.value_counts().index, y=y_train.value_counts(normalize=True), ax=axes[0])\n",
+    "    axes[0].set_title('Обучающая выборка')\n",
+    "    axes[0].set_xlabel(y_name)\n",
+    "    axes[0].set_ylabel('Доля')\n",
+    "\n",
+    "    sns.barplot(x=y_val.value_counts().index, y=y_val.value_counts(normalize=True), ax=axes[1])\n",
+    "    axes[1].set_title('Контрольная выборка')\n",
+    "    axes[1].set_xlabel(y_name)\n",
+    "\n",
+    "    sns.barplot(x=y_test.value_counts().index, y=y_test.value_counts(normalize=True), ax=axes[2])\n",
+    "    axes[2].set_title('Тестовая выборка')\n",
+    "    axes[2].set_xlabel(y_name)\n",
+    "\n",
+    "    plt.show()\n",
+    "\n",
+    "analyze_balance(y_train, y_val, y_test, 'stroke')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Заметим, что выборки не сбалансированы. Для балансировки будем использовать RandomOverSampler"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 37,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Распределение классов в обучающей выборке:\n",
+      "stroke\n",
+      "0    0.5\n",
+      "1    0.5\n",
+      "Name: proportion, dtype: float64\n",
+      "\n",
+      "Распределение классов в контрольной выборке:\n",
+      "stroke\n",
+      "0    0.5\n",
+      "1    0.5\n",
+      "Name: proportion, dtype: float64\n",
+      "\n",
+      "Распределение классов в тестовой выборке:\n",
+      "stroke\n",
+      "0    0.956947\n",
+      "1    0.043053\n",
+      "Name: proportion, dtype: float64\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1800x500 with 3 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "randoversamp = RandomOverSampler(random_state=42)\n",
+    "\n",
+    "# Применение RandomOverSampler для балансировки выборок\n",
+    "X_train_resampled, y_train_resampled = randoversamp.fit_resample(X_train, y_train)\n",
+    "X_val_resampled, y_val_resampled = randoversamp.fit_resample(X_val, y_val)\n",
+    "\n",
+    "# Проверка сбалансированности после RandomOverSampler\n",
+    "analyze_balance(y_train_resampled, y_val_resampled, y_test, \"stroke\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Выборки сбалансированы"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Применим унитарное кодирование категориальных признаков (one-hot encoding), переведя их в бинарные вектора."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 38,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "    age  hypertension  heart_disease  avg_glucose_level   bmi  gender_Male  \\\n",
+      "0  67.0             0              0             190.70  36.0         True   \n",
+      "1  72.0             0              0              99.73  36.7         True   \n",
+      "2  74.0             1              1              70.09  27.4         True   \n",
+      "3  42.0             0              0              59.43  25.4        False   \n",
+      "4  60.0             0              0              69.53  26.2         True   \n",
+      "\n",
+      "   ever_married_Yes  work_type_Never_worked  work_type_Private  \\\n",
+      "0              True                   False               True   \n",
+      "1              True                   False              False   \n",
+      "2              True                   False               True   \n",
+      "3              True                   False              False   \n",
+      "4              True                   False              False   \n",
+      "\n",
+      "   work_type_Self-employed  work_type_children  Residence_type_Urban  \\\n",
+      "0                    False               False                  True   \n",
+      "1                     True               False                 False   \n",
+      "2                    False               False                 False   \n",
+      "3                    False               False                  True   \n",
+      "4                     True               False                  True   \n",
+      "\n",
+      "   smoking_status_formerly smoked  smoking_status_never smoked  \\\n",
+      "0                            True                        False   \n",
+      "1                            True                        False   \n",
+      "2                           False                         True   \n",
+      "3                           False                         True   \n",
+      "4                           False                         True   \n",
+      "\n",
+      "   smoking_status_smokes  \n",
+      "0                  False  \n",
+      "1                  False  \n",
+      "2                  False  \n",
+      "3                  False  \n",
+      "4                  False  \n"
+     ]
+    }
+   ],
+   "source": [
+    "# Определение категориальных признаков\n",
+    "categorical_features = [\n",
+    "    \"gender\",\n",
+    "    \"ever_married\",\n",
+    "    \"work_type\",\n",
+    "    \"Residence_type\",\n",
+    "    \"smoking_status\",\n",
+    "]\n",
+    "\n",
+    "# Применение one-hot encoding к обучающей выборке\n",
+    "X_train_encoded = pd.get_dummies(\n",
+    "    X_train_resampled, columns=categorical_features, drop_first=True\n",
+    ")\n",
+    "\n",
+    "# Применение one-hot encoding к контрольной выборке\n",
+    "X_val_encoded = pd.get_dummies(\n",
+    "    X_val_resampled, columns=categorical_features, drop_first=True\n",
+    ")\n",
+    "\n",
+    "# Применение one-hot encoding к тестовой выборке\n",
+    "X_test_encoded = pd.get_dummies(X_test, columns=categorical_features, drop_first=True)\n",
+    "\n",
+    "print(X_train_encoded.head())"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Перейдем к числовым признакам, а именно к колонке age, применим дискретизацию (позволяет преобразовать данные из числового представления в категориальное):"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 39,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "   hypertension  heart_disease  avg_glucose_level   bmi  gender_Male  \\\n",
+      "0             0              0             190.70  36.0         True   \n",
+      "1             0              0              99.73  36.7         True   \n",
+      "2             1              1              70.09  27.4         True   \n",
+      "3             0              0              59.43  25.4        False   \n",
+      "4             0              0              69.53  26.2         True   \n",
+      "\n",
+      "   ever_married_Yes  work_type_Never_worked  work_type_Private  \\\n",
+      "0              True                   False               True   \n",
+      "1              True                   False              False   \n",
+      "2              True                   False               True   \n",
+      "3              True                   False              False   \n",
+      "4              True                   False              False   \n",
+      "\n",
+      "   work_type_Self-employed  work_type_children  Residence_type_Urban  \\\n",
+      "0                    False               False                  True   \n",
+      "1                     True               False                 False   \n",
+      "2                    False               False                 False   \n",
+      "3                    False               False                  True   \n",
+      "4                     True               False                  True   \n",
+      "\n",
+      "   smoking_status_formerly smoked  smoking_status_never smoked  \\\n",
+      "0                            True                        False   \n",
+      "1                            True                        False   \n",
+      "2                           False                         True   \n",
+      "3                           False                         True   \n",
+      "4                           False                         True   \n",
+      "\n",
+      "   smoking_status_smokes      age_bin  \n",
+      "0                  False          old  \n",
+      "1                  False          old  \n",
+      "2                  False          old  \n",
+      "3                  False  middle-aged  \n",
+      "4                  False          old  \n"
+     ]
+    }
+   ],
+   "source": [
+    "# Определение числовых признаков для дискретизации\n",
+    "numerical_features = [\"age\"]\n",
+    "\n",
+    "\n",
+    "# Функция для дискретизации числовых признаков\n",
+    "def discretize_features(df, features, bins, labels):\n",
+    "    for feature in features:\n",
+    "        df[f\"{feature}_bin\"] = pd.cut(df[feature], bins=bins, labels=labels)\n",
+    "        df.drop(columns=[feature], inplace=True)\n",
+    "    return df\n",
+    "\n",
+    "\n",
+    "# Заданные интервалы и метки\n",
+    "age_bins = [0, 25, 55, 100]\n",
+    "age_labels = [\"young\", \"middle-aged\", \"old\"]\n",
+    "\n",
+    "# Применение дискретизации к обучающей, контрольной и тестовой выборкам\n",
+    "X_train_encoded = discretize_features(\n",
+    "    X_train_encoded, numerical_features, bins=age_bins, labels=age_labels\n",
+    ")\n",
+    "X_val_encoded = discretize_features(\n",
+    "    X_val_encoded, numerical_features, bins=age_bins, labels=age_labels\n",
+    ")\n",
+    "X_test_encoded = discretize_features(\n",
+    "    X_test_encoded, numerical_features, bins=age_bins, labels=age_labels\n",
+    ")\n",
+    "\n",
+    "print(X_train_encoded.head())"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Применим ручной синтез признаков. Например, в этом случае создадим признак, в котором вычисляется отклонение уровня глюкозы от среднего для определенной возрастной группы. Вышеуказанный признак может быть полезен для определения пациентов с аномальными данными."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 40,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "   hypertension  heart_disease  avg_glucose_level   bmi  gender_Male  \\\n",
+      "0             0              0             190.70  36.0         True   \n",
+      "1             0              0              99.73  36.7         True   \n",
+      "2             1              1              70.09  27.4         True   \n",
+      "3             0              0              59.43  25.4        False   \n",
+      "4             0              0              69.53  26.2         True   \n",
+      "\n",
+      "   ever_married_Yes  work_type_Never_worked  work_type_Private  \\\n",
+      "0              True                   False               True   \n",
+      "1              True                   False              False   \n",
+      "2              True                   False               True   \n",
+      "3              True                   False              False   \n",
+      "4              True                   False              False   \n",
+      "\n",
+      "   work_type_Self-employed  work_type_children  Residence_type_Urban  \\\n",
+      "0                    False               False                  True   \n",
+      "1                     True               False                 False   \n",
+      "2                    False               False                 False   \n",
+      "3                    False               False                  True   \n",
+      "4                     True               False                  True   \n",
+      "\n",
+      "   smoking_status_formerly smoked  smoking_status_never smoked  \\\n",
+      "0                            True                        False   \n",
+      "1                            True                        False   \n",
+      "2                           False                         True   \n",
+      "3                           False                         True   \n",
+      "4                           False                         True   \n",
+      "\n",
+      "   smoking_status_smokes      age_bin  glucose_age_deviation  \n",
+      "0                  False          old              58.945260  \n",
+      "1                  False          old             -32.024740  \n",
+      "2                  False          old             -61.664740  \n",
+      "3                  False  middle-aged             -46.635693  \n",
+      "4                  False          old             -62.224740  \n"
+     ]
+    }
+   ],
+   "source": [
+    "age_glucose_mean = X_train_encoded.groupby(\"age_bin\", observed=False)[\n",
+    "    \"avg_glucose_level\"\n",
+    "].transform(\"mean\")\n",
+    "X_train_encoded[\"glucose_age_deviation\"] = (\n",
+    "    X_train_encoded[\"avg_glucose_level\"] - age_glucose_mean\n",
+    ")\n",
+    "\n",
+    "age_glucose_mean = X_val_encoded.groupby(\"age_bin\", observed=False)[\n",
+    "    \"avg_glucose_level\"\n",
+    "].transform(\"mean\")\n",
+    "X_val_encoded[\"glucose_age_deviation\"] = (\n",
+    "    X_val_encoded[\"avg_glucose_level\"] - age_glucose_mean\n",
+    ")\n",
+    "\n",
+    "age_glucose_mean = X_test_encoded.groupby(\"age_bin\", observed=False)[\n",
+    "    \"avg_glucose_level\"\n",
+    "].transform(\"mean\")\n",
+    "X_test_encoded[\"glucose_age_deviation\"] = (\n",
+    "    X_test_encoded[\"avg_glucose_level\"] - age_glucose_mean\n",
+    ")\n",
+    "\n",
+    "print(X_train_encoded.head())"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Используем масштабирование признаков, для приведения всех числовых признаков к одинаковым или очень похожим диапазонам значений/распределениям. \n",
+    "### Масштабирование признаков позволяет получить более качественную модель за счет снижения доминирования одних признаков над другими."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 41,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "   hypertension  heart_disease  avg_glucose_level       bmi  gender_Male  \\\n",
+      "0             0              0           1.274173  0.891831         True   \n",
+      "1             0              0          -0.349199  0.991754         True   \n",
+      "2             1              1          -0.878129 -0.335787         True   \n",
+      "3             0              0          -1.068358 -0.621280        False   \n",
+      "4             0              0          -0.888122 -0.507083         True   \n",
+      "\n",
+      "   ever_married_Yes  work_type_Never_worked  work_type_Private  \\\n",
+      "0              True                   False               True   \n",
+      "1              True                   False              False   \n",
+      "2              True                   False               True   \n",
+      "3              True                   False              False   \n",
+      "4              True                   False              False   \n",
+      "\n",
+      "   work_type_Self-employed  work_type_children  Residence_type_Urban  \\\n",
+      "0                    False               False                  True   \n",
+      "1                     True               False                 False   \n",
+      "2                    False               False                 False   \n",
+      "3                    False               False                  True   \n",
+      "4                     True               False                  True   \n",
+      "\n",
+      "   smoking_status_formerly smoked  smoking_status_never smoked  \\\n",
+      "0                            True                        False   \n",
+      "1                            True                        False   \n",
+      "2                           False                         True   \n",
+      "3                           False                         True   \n",
+      "4                           False                         True   \n",
+      "\n",
+      "   smoking_status_smokes      age_bin  glucose_age_deviation  \n",
+      "0                  False          old               1.092637  \n",
+      "1                  False          old              -0.593625  \n",
+      "2                  False          old              -1.143046  \n",
+      "3                  False  middle-aged              -0.864461  \n",
+      "4                  False          old              -1.153427  \n"
+     ]
+    }
+   ],
+   "source": [
+    "numerical_features = [\"avg_glucose_level\", \"bmi\", \"glucose_age_deviation\"]\n",
+    "\n",
+    "scaler = StandardScaler()\n",
+    "X_train_encoded[numerical_features] = scaler.fit_transform(\n",
+    "    X_train_encoded[numerical_features]\n",
+    ")\n",
+    "X_val_encoded[numerical_features] = scaler.transform(X_val_encoded[numerical_features])\n",
+    "X_test_encoded[numerical_features] = scaler.transform(\n",
+    "    X_test_encoded[numerical_features]\n",
+    ")\n",
+    "\n",
+    "print(X_train_encoded.head())"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Сконструируем признаки, используя фреймворк Featuretools:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 42,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "       hypertension  heart_disease  avg_glucose_level       bmi  gender_Male  \\\n",
+      "index                                                                          \n",
+      "0                 0              0           1.274173  0.891831         True   \n",
+      "1                 0              0          -0.349199  0.991754         True   \n",
+      "2                 1              1          -0.878129 -0.335787         True   \n",
+      "3                 0              0          -1.068358 -0.621280        False   \n",
+      "4                 0              0          -0.888122 -0.507083         True   \n",
+      "\n",
+      "       ever_married_Yes  work_type_Never_worked  work_type_Private  \\\n",
+      "index                                                                \n",
+      "0                  True                   False               True   \n",
+      "1                  True                   False              False   \n",
+      "2                  True                   False               True   \n",
+      "3                  True                   False              False   \n",
+      "4                  True                   False              False   \n",
+      "\n",
+      "       work_type_Self-employed  work_type_children  Residence_type_Urban  \\\n",
+      "index                                                                      \n",
+      "0                        False               False                  True   \n",
+      "1                         True               False                 False   \n",
+      "2                        False               False                 False   \n",
+      "3                        False               False                  True   \n",
+      "4                         True               False                  True   \n",
+      "\n",
+      "       smoking_status_formerly smoked  smoking_status_never smoked  \\\n",
+      "index                                                                \n",
+      "0                                True                        False   \n",
+      "1                                True                        False   \n",
+      "2                               False                         True   \n",
+      "3                               False                         True   \n",
+      "4                               False                         True   \n",
+      "\n",
+      "       smoking_status_smokes      age_bin  glucose_age_deviation  \n",
+      "index                                                             \n",
+      "0                      False          old               1.092637  \n",
+      "1                      False          old              -0.593625  \n",
+      "2                      False          old              -1.143046  \n",
+      "3                      False  middle-aged              -0.864461  \n",
+      "4                      False          old              -1.153427  \n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "d:\\Users\\Leo\\AppData\\Local\\pypoetry\\Cache\\virtualenvs\\mai-S9i2J6c7-py3.12\\Lib\\site-packages\\woodwork\\type_sys\\utils.py:33: UserWarning: Could not infer format, so each element will be parsed individually, falling back to `dateutil`. To ensure parsing is consistent and as-expected, please specify a format.\n",
+      "  pd.to_datetime(\n"
+     ]
+    }
+   ],
+   "source": [
+    "data = X_train_encoded.copy()  # Используем предобработанные данные\n",
+    "\n",
+    "es = ft.EntitySet(id=\"patients\")\n",
+    "\n",
+    "es = es.add_dataframe(\n",
+    "    dataframe_name=\"strokes_data\", dataframe=data, index=\"index\", make_index=True\n",
+    ")\n",
+    "\n",
+    "feature_matrix, feature_defs = ft.dfs(\n",
+    "    entityset=es, target_dataframe_name=\"strokes_data\", max_depth=1\n",
+    ")\n",
+    "\n",
+    "print(feature_matrix.head())"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Оценим качество набора признаков.\n",
+    "\n",
+    "1. Предсказательная способность (для задачи классификации)\n",
+    " - Метрики: Accuracy, Precision, Recall, F1-Score, ROC AUC\n",
+    " - Методы: Обучение модели на обучающей выборке и оценка на валидационной и тестовой выборках.\n",
+    "\n",
+    "2. Вычислительная эффективность\n",
+    " - Методы: Измерение времени, затраченного на генерацию признаков и обучение модели.\n",
+    "\n",
+    "3. Надежность\n",
+    " - Методы: Кросс-валидация и анализ чувствительности модели к изменениям в данных.\n",
+    "\n",
+    "4. Корреляция\n",
+    " - Методы: Анализ корреляционной матрицы признаков и исключение мультиколлинеарных признаков.\n",
+    "\n",
+    "5. Логическая согласованность\n",
+    " - Методы: Проверка логической связи признаков с целевой переменной и интерпретация результатов модели."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 43,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Время обучения модели: 0.55 секунд\n"
+     ]
+    }
+   ],
+   "source": [
+    "X_train_encoded = pd.get_dummies(X_train_encoded, drop_first=True)\n",
+    "X_val_encoded = pd.get_dummies(X_val_encoded, drop_first=True)\n",
+    "X_test_encoded = pd.get_dummies(X_test_encoded, drop_first=True)\n",
+    "\n",
+    "all_columns = X_train_encoded.columns\n",
+    "X_train_encoded = X_train_encoded.reindex(columns=all_columns, fill_value=0)\n",
+    "X_val_encoded = X_val_encoded.reindex(columns=all_columns, fill_value=0)\n",
+    "X_test_encoded = X_test_encoded.reindex(columns=all_columns, fill_value=0)\n",
+    "\n",
+    "# Выбор модели\n",
+    "model = RandomForestClassifier(n_estimators=100, random_state=42)\n",
+    "\n",
+    "# Начинаем отсчет времени\n",
+    "start_time = time.time()\n",
+    "model.fit(X_train_encoded, y_train_resampled)\n",
+    "\n",
+    "# Время обучения модели\n",
+    "train_time = time.time() - start_time\n",
+    "\n",
+    "print(f\"Время обучения модели: {train_time:.2f} секунд\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 44,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Feature Importance:\n",
+      "                           feature  importance\n",
+      "16                     age_bin_old    0.199473\n",
+      "3                              bmi    0.186638\n",
+      "14           glucose_age_deviation    0.172977\n",
+      "2                avg_glucose_level    0.171885\n",
+      "15             age_bin_middle-aged    0.037563\n",
+      "5                 ever_married_Yes    0.036580\n",
+      "4                      gender_Male    0.028419\n",
+      "0                     hypertension    0.025984\n",
+      "8          work_type_Self-employed    0.022772\n",
+      "10            Residence_type_Urban    0.022221\n",
+      "1                    heart_disease    0.020967\n",
+      "12     smoking_status_never smoked    0.017890\n",
+      "7                work_type_Private    0.016844\n",
+      "11  smoking_status_formerly smoked    0.015641\n",
+      "13           smoking_status_smokes    0.012366\n",
+      "9               work_type_children    0.011684\n",
+      "6           work_type_Never_worked    0.000096\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Получение важности признаков\n",
+    "importances = model.feature_importances_\n",
+    "feature_names = X_train_encoded.columns\n",
+    "\n",
+    "# Сортировка признаков по важности\n",
+    "feature_importance = pd.DataFrame({\"feature\": feature_names, \"importance\": importances})\n",
+    "feature_importance = feature_importance.sort_values(by=\"importance\", ascending=False)\n",
+    "\n",
+    "print(\"Feature Importance:\")\n",
+    "print(feature_importance)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 45,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Accuracy: 0.9465101108936725\n",
+      "Precision: 0.21428571428571427\n",
+      "Recall: 0.09090909090909091\n",
+      "F1 Score: 0.1276595744680851\n",
+      "ROC AUC: 0.5379562496126913\n",
+      "Cross-validated Accuracy: 0.988641983507665\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Train Accuracy: 1.0\n",
+      "Train Precision: 1.0\n",
+      "Train Recall: 1.0\n",
+      "Train F1 Score: 1.0\n",
+      "Train ROC AUC: 1.0\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Предсказание и оценка\n",
+    "y_pred = model.predict(X_test_encoded)\n",
+    "\n",
+    "accuracy = accuracy_score(y_test, y_pred)\n",
+    "precision = precision_score(y_test, y_pred)\n",
+    "recall = recall_score(y_test, y_pred)\n",
+    "f1 = f1_score(y_test, y_pred)\n",
+    "roc_auc = roc_auc_score(y_test, y_pred)\n",
+    "\n",
+    "print(f\"Accuracy: {accuracy}\")\n",
+    "print(f\"Precision: {precision}\")\n",
+    "print(f\"Recall: {recall}\")\n",
+    "print(f\"F1 Score: {f1}\")\n",
+    "print(f\"ROC AUC: {roc_auc}\")\n",
+    "\n",
+    "# Кросс-валидация\n",
+    "scores = cross_val_score(\n",
+    "    model, X_train_encoded, y_train_resampled, cv=5, scoring=\"accuracy\"\n",
+    ")\n",
+    "accuracy_cv = scores.mean()\n",
+    "print(f\"Cross-validated Accuracy: {accuracy_cv}\")\n",
+    "\n",
+    "# Анализ важности признаков\n",
+    "feature_importances = model.feature_importances_\n",
+    "feature_names = X_train_encoded.columns\n",
+    "\n",
+    "importance_df = pd.DataFrame(\n",
+    "    {\"Feature\": feature_names, \"Importance\": feature_importances}\n",
+    ")\n",
+    "importance_df = importance_df.sort_values(by=\"Importance\", ascending=False)\n",
+    "\n",
+    "plt.figure(figsize=(10, 6))\n",
+    "sns.barplot(x=\"Importance\", y=\"Feature\", data=importance_df)\n",
+    "plt.title(\"Feature Importance\")\n",
+    "plt.show()\n",
+    "\n",
+    "# Проверка на переобучение\n",
+    "y_train_pred = model.predict(X_train_encoded)\n",
+    "\n",
+    "accuracy_train = accuracy_score(y_train_resampled, y_train_pred)\n",
+    "precision_train = precision_score(y_train_resampled, y_train_pred)\n",
+    "recall_train = recall_score(y_train_resampled, y_train_pred)\n",
+    "f1_train = f1_score(y_train_resampled, y_train_pred)\n",
+    "roc_auc_train = roc_auc_score(y_train_resampled, y_train_pred)\n",
+    "\n",
+    "print(f\"Train Accuracy: {accuracy_train}\")\n",
+    "print(f\"Train Precision: {precision_train}\")\n",
+    "print(f\"Train Recall: {recall_train}\")\n",
+    "print(f\"Train F1 Score: {f1_train}\")\n",
+    "print(f\"Train ROC AUC: {roc_auc_train}\")"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": ".venv",
+   "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.12.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/poetry.lock b/poetry.lock
index 80c0e93..e52f093 100644
--- a/poetry.lock
+++ b/poetry.lock
@@ -22,13 +22,13 @@ trio = ["trio (>=0.26.1)"]
 
 [[package]]
 name = "apiflask"
-version = "2.2.1"
+version = "2.3.0"
 description = "A lightweight web API framework based on Flask and marshmallow-code projects."
 optional = false
 python-versions = "*"
 files = [
-    {file = "APIFlask-2.2.1-py3-none-any.whl", hash = "sha256:31619542dae6c7b86ca0cd0b1277ccaad68e99b69dfef201791b814432d26965"},
-    {file = "apiflask-2.2.1.tar.gz", hash = "sha256:9c7573fedbb75524396c5733d4b0c150d1839a5d52b905c15b6a36e030c44908"},
+    {file = "APIFlask-2.3.0-py3-none-any.whl", hash = "sha256:c3c44e90dae36deac6872056510452f99bfe86c4d79076a5805e225eb5d77f3b"},
+    {file = "apiflask-2.3.0.tar.gz", hash = "sha256:f57935dd33d718f553841297f1319affb7756d1ba521df4fd2342b6b4fd4178c"},
 ]
 
 [package.dependencies]
@@ -681,13 +681,13 @@ tests = ["asttokens (>=2.1.0)", "coverage", "coverage-enable-subprocess", "ipyth
 
 [[package]]
 name = "fastjsonschema"
-version = "2.20.0"
+version = "2.21.0"
 description = "Fastest Python implementation of JSON schema"
 optional = false
 python-versions = "*"
 files = [
-    {file = "fastjsonschema-2.20.0-py3-none-any.whl", hash = "sha256:5875f0b0fa7a0043a91e93a9b8f793bcbbba9691e7fd83dca95c28ba26d21f0a"},
-    {file = "fastjsonschema-2.20.0.tar.gz", hash = "sha256:3d48fc5300ee96f5d116f10fe6f28d938e6008f59a6a025c2649475b87f76a23"},
+    {file = "fastjsonschema-2.21.0-py3-none-any.whl", hash = "sha256:5b23b8e7c9c6adc0ecb91c03a0768cb48cd154d9159378a69c8318532e0b5cbf"},
+    {file = "fastjsonschema-2.21.0.tar.gz", hash = "sha256:a02026bbbedc83729da3bfff215564b71902757f33f60089f1abae193daa4771"},
 ]
 
 [package.extras]
@@ -931,13 +931,13 @@ trio = ["trio (>=0.22.0,<1.0)"]
 
 [[package]]
 name = "httpx"
-version = "0.27.2"
+version = "0.28.0"
 description = "The next generation HTTP client."
 optional = false
 python-versions = ">=3.8"
 files = [
-    {file = "httpx-0.27.2-py3-none-any.whl", hash = "sha256:7bb2708e112d8fdd7829cd4243970f0c223274051cb35ee80c03301ee29a3df0"},
-    {file = "httpx-0.27.2.tar.gz", hash = "sha256:f7c2be1d2f3c3c3160d441802406b206c2b76f5947b11115e6df10c6c65e66c2"},
+    {file = "httpx-0.28.0-py3-none-any.whl", hash = "sha256:dc0b419a0cfeb6e8b34e85167c0da2671206f5095f1baa9663d23bcfd6b535fc"},
+    {file = "httpx-0.28.0.tar.gz", hash = "sha256:0858d3bab51ba7e386637f22a61d8ccddaeec5f3fe4209da3a6168dbb91573e0"},
 ]
 
 [package.dependencies]
@@ -945,7 +945,6 @@ anyio = "*"
 certifi = "*"
 httpcore = "==1.*"
 idna = "*"
-sniffio = "*"
 
 [package.extras]
 brotli = ["brotli", "brotlicffi"]
@@ -1046,13 +1045,13 @@ test = ["flaky", "ipyparallel", "pre-commit", "pytest (>=7.0)", "pytest-asyncio
 
 [[package]]
 name = "ipython"
-version = "8.29.0"
+version = "8.30.0"
 description = "IPython: Productive Interactive Computing"
 optional = false
 python-versions = ">=3.10"
 files = [
-    {file = "ipython-8.29.0-py3-none-any.whl", hash = "sha256:0188a1bd83267192123ccea7f4a8ed0a78910535dbaa3f37671dca76ebd429c8"},
-    {file = "ipython-8.29.0.tar.gz", hash = "sha256:40b60e15b22591450eef73e40a027cf77bd652e757523eebc5bd7c7c498290eb"},
+    {file = "ipython-8.30.0-py3-none-any.whl", hash = "sha256:85ec56a7e20f6c38fce7727dcca699ae4ffc85985aa7b23635a8008f918ae321"},
+    {file = "ipython-8.30.0.tar.gz", hash = "sha256:cb0a405a306d2995a5cbb9901894d240784a9f341394c6ba3f4fe8c6eb89ff6e"},
 ]
 
 [package.dependencies]
@@ -1061,15 +1060,15 @@ decorator = "*"
 jedi = ">=0.16"
 matplotlib-inline = "*"
 pexpect = {version = ">4.3", markers = "sys_platform != \"win32\" and sys_platform != \"emscripten\""}
-prompt-toolkit = ">=3.0.41,<3.1.0"
+prompt_toolkit = ">=3.0.41,<3.1.0"
 pygments = ">=2.4.0"
-stack-data = "*"
+stack_data = "*"
 traitlets = ">=5.13.0"
 
 [package.extras]
 all = ["ipython[black,doc,kernel,matplotlib,nbconvert,nbformat,notebook,parallel,qtconsole]", "ipython[test,test-extra]"]
 black = ["black"]
-doc = ["docrepr", "exceptiongroup", "intersphinx-registry", "ipykernel", "ipython[test]", "matplotlib", "setuptools (>=18.5)", "sphinx (>=1.3)", "sphinx-rtd-theme", "sphinxcontrib-jquery", "tomli", "typing-extensions"]
+doc = ["docrepr", "exceptiongroup", "intersphinx_registry", "ipykernel", "ipython[test]", "matplotlib", "setuptools (>=18.5)", "sphinx (>=1.3)", "sphinx-rtd-theme", "sphinxcontrib-jquery", "tomli", "typing_extensions"]
 kernel = ["ipykernel"]
 matplotlib = ["matplotlib"]
 nbconvert = ["nbconvert"]
@@ -1175,13 +1174,13 @@ files = [
 
 [[package]]
 name = "json5"
-version = "0.9.28"
+version = "0.10.0"
 description = "A Python implementation of the JSON5 data format."
 optional = false
 python-versions = ">=3.8.0"
 files = [
-    {file = "json5-0.9.28-py3-none-any.whl", hash = "sha256:29c56f1accdd8bc2e037321237662034a7e07921e2b7223281a5ce2c46f0c4df"},
-    {file = "json5-0.9.28.tar.gz", hash = "sha256:1f82f36e615bc5b42f1bbd49dbc94b12563c56408c6ffa06414ea310890e9a6e"},
+    {file = "json5-0.10.0-py3-none-any.whl", hash = "sha256:19b23410220a7271e8377f81ba8aacba2fdd56947fbb137ee5977cbe1f5e8dfa"},
+    {file = "json5-0.10.0.tar.gz", hash = "sha256:e66941c8f0a02026943c52c2eb34ebeb2a6f819a0be05920a6f5243cd30fd559"},
 ]
 
 [package.extras]
@@ -1802,13 +1801,13 @@ files = [
 
 [[package]]
 name = "nbclient"
-version = "0.10.0"
+version = "0.10.1"
 description = "A client library for executing notebooks. Formerly nbconvert's ExecutePreprocessor."
 optional = false
 python-versions = ">=3.8.0"
 files = [
-    {file = "nbclient-0.10.0-py3-none-any.whl", hash = "sha256:f13e3529332a1f1f81d82a53210322476a168bb7090a0289c795fe9cc11c9d3f"},
-    {file = "nbclient-0.10.0.tar.gz", hash = "sha256:4b3f1b7dba531e498449c4db4f53da339c91d449dc11e9af3a43b4eb5c5abb09"},
+    {file = "nbclient-0.10.1-py3-none-any.whl", hash = "sha256:949019b9240d66897e442888cfb618f69ef23dc71c01cb5fced8499c2cfc084d"},
+    {file = "nbclient-0.10.1.tar.gz", hash = "sha256:3e93e348ab27e712acd46fccd809139e356eb9a31aab641d1a7991a6eb4e6f68"},
 ]
 
 [package.dependencies]
@@ -1819,7 +1818,7 @@ traitlets = ">=5.4"
 
 [package.extras]
 dev = ["pre-commit"]
-docs = ["autodoc-traits", "mock", "moto", "myst-parser", "nbclient[test]", "sphinx (>=1.7)", "sphinx-book-theme", "sphinxcontrib-spelling"]
+docs = ["autodoc-traits", "flaky", "ipykernel (>=6.19.3)", "ipython", "ipywidgets", "mock", "moto", "myst-parser", "nbconvert (>=7.0.0)", "pytest (>=7.0,<8)", "pytest-asyncio", "pytest-cov (>=4.0)", "sphinx (>=1.7)", "sphinx-book-theme", "sphinxcontrib-spelling", "testpath", "xmltodict"]
 test = ["flaky", "ipykernel (>=6.19.3)", "ipython", "ipywidgets", "nbconvert (>=7.0.0)", "pytest (>=7.0,<8)", "pytest-asyncio", "pytest-cov (>=4.0)", "testpath", "xmltodict"]
 
 [[package]]
@@ -3071,20 +3070,20 @@ files = [
 
 [[package]]
 name = "tqdm"
-version = "4.67.0"
+version = "4.67.1"
 description = "Fast, Extensible Progress Meter"
 optional = false
 python-versions = ">=3.7"
 files = [
-    {file = "tqdm-4.67.0-py3-none-any.whl", hash = "sha256:0cd8af9d56911acab92182e88d763100d4788bdf421d251616040cc4d44863be"},
-    {file = "tqdm-4.67.0.tar.gz", hash = "sha256:fe5a6f95e6fe0b9755e9469b77b9c3cf850048224ecaa8293d7d2d31f97d869a"},
+    {file = "tqdm-4.67.1-py3-none-any.whl", hash = "sha256:26445eca388f82e72884e0d580d5464cd801a3ea01e63e5601bdff9ba6a48de2"},
+    {file = "tqdm-4.67.1.tar.gz", hash = "sha256:f8aef9c52c08c13a65f30ea34f4e5aac3fd1a34959879d7e59e63027286627f2"},
 ]
 
 [package.dependencies]
 colorama = {version = "*", markers = "platform_system == \"Windows\""}
 
 [package.extras]
-dev = ["pytest (>=6)", "pytest-cov", "pytest-timeout", "pytest-xdist"]
+dev = ["nbval", "pytest (>=6)", "pytest-asyncio (>=0.24)", "pytest-cov", "pytest-timeout"]
 discord = ["requests"]
 notebook = ["ipywidgets (>=6)"]
 slack = ["slack-sdk"]