diff --git a/.gitignore b/.gitignore
index 1d91e1a..372675d 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,3 +1,12 @@
 data/jio_mart_items.csv
 /data
 /Lab_2/lab_2.ipynb
+/Lab_3/lab_3.ipynb
+/Lab_4/lab_4.ipynb
+/Lab_4/lab4gpu.ipynb
+/Lab_4/lab5.ipynb
+/Lab_4/lab44.ipynb
+/Lab_4/lab45.ipynb
+/Lab_4/lab_products_clustering.ipynb
+/Lab_4/lab_4.ipynb
+/Lab_4/lab_4_products.ipynb
\ No newline at end of file
diff --git a/Lab_3/lab3.ipynb b/Lab_3/lab3.ipynb
new file mode 100644
index 0000000..8a8479f
--- /dev/null
+++ b/Lab_3/lab3.ipynb
@@ -0,0 +1,528 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 51,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pandas as pd\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "import seaborn as sns\n",
+    "from sklearn.model_selection import train_test_split\n",
+    "from sklearn.preprocessing import OneHotEncoder, StandardScaler, MinMaxScaler, LabelEncoder\n",
+    "from sklearn.impute import SimpleImputer\n",
+    "from imblearn.over_sampling import SMOTE\n",
+    "import featuretools as ft\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 52,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "<class 'pandas.core.frame.DataFrame'>\n",
+      "RangeIndex: 162313 entries, 0 to 162312\n",
+      "Data columns (total 5 columns):\n",
+      " #   Column        Non-Null Count   Dtype  \n",
+      "---  ------        --------------   -----  \n",
+      " 0   category      162313 non-null  object \n",
+      " 1   sub_category  162313 non-null  object \n",
+      " 2   href          162313 non-null  object \n",
+      " 3   items         162280 non-null  object \n",
+      " 4   price         162282 non-null  float64\n",
+      "dtypes: float64(1), object(4)\n",
+      "memory usage: 6.2+ MB\n",
+      "None\n",
+      "<class 'pandas.core.frame.DataFrame'>\n",
+      "RangeIndex: 162313 entries, 0 to 162312\n",
+      "Data columns (total 5 columns):\n",
+      " #   Column        Non-Null Count   Dtype  \n",
+      "---  ------        --------------   -----  \n",
+      " 0   category      162313 non-null  object \n",
+      " 1   sub_category  162313 non-null  object \n",
+      " 2   href          162313 non-null  object \n",
+      " 3   items         162280 non-null  object \n",
+      " 4   price         162282 non-null  float64\n",
+      "dtypes: float64(1), object(4)\n",
+      "memory usage: 6.2+ MB\n",
+      "Пропущенные значения:\n",
+      " category         0\n",
+      "sub_category     0\n",
+      "href             0\n",
+      "items           33\n",
+      "price           31\n",
+      "dtype: int64\n",
+      "              price\n",
+      "count  1.622820e+05\n",
+      "mean   1.991633e+03\n",
+      "std    1.593479e+04\n",
+      "min    5.000000e+00\n",
+      "25%    2.840000e+02\n",
+      "50%    4.990000e+02\n",
+      "75%    9.990000e+02\n",
+      "max    3.900000e+06\n"
+     ]
+    }
+   ],
+   "source": [
+    "df = pd.read_csv(\"../data\\jio_mart_items.csv\")\n",
+    "\n",
+    "print(df.info())\n",
+    "# print(df.head())\n",
+    "\n",
+    "df.info()\n",
+    "# df = df.sample(n=20000 , random_state=42)\n",
+    "\n",
+    "print(\"Пропущенные значения:\\n\", df.isnull().sum())\n",
+    "\n",
+    "print(df.describe())\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Бизнес-цели:\n",
+    "1. Предсказать категорию продукта (классификация), чтобы рекомендовать новые товары на основе текущей базы.\n",
+    "2. Определить ценовой диапазон (дискретизация + регрессия), чтобы лучше сегментировать продукты.\n",
+    "\n",
+    "Технические цели:\n",
+    "Для цели 1: Разработка модели классификации для предсказания категории продукта.\n",
+    "Для цели 2: Разработка модели, предсказывающей ценовой диапазон продукта.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 53,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Удаление бесполезных столбцов\n",
+    "df = df.drop(columns=[\"Product_ID\", \"Unnamed: 0\"], errors=\"ignore\")\n",
+    "\n",
+    "# Обработка пропущенных значений\n",
+    "imputer = SimpleImputer(strategy=\"most_frequent\")  # Для категориальных данных\n",
+    "df = pd.DataFrame(imputer.fit_transform(df), columns=df.columns)\n",
+    "\n",
+    "# Преобразование числовых столбцов\n",
+    "numeric_cols = df.select_dtypes(include=[\"float64\", \"int64\"]).columns\n",
+    "categorical_cols = df.select_dtypes(include=[\"object\"]).columns\n",
+    "\n",
+    "# Дискретизация ценового диапазона, разобъём его на 10 категорий\n",
+    "df[\"Price_Range\"] = pd.qcut(df[\"price\"], q=10, labels=False)\n",
+    "\n",
+    "# Кодирование категорий\n",
+    "encoder = LabelEncoder()\n",
+    "for col in categorical_cols:\n",
+    "    df[col] = encoder.fit_transform(df[col])\n",
+    "\n",
+    "# Проверяем результат\n",
+    "# print(df.head())\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 54,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# # Построем график распределение категорий чтобы убедится в верной дискретизации\n",
+    "# sns.countplot(data=df, x=\"Price_Range\", palette=\"viridis\")\n",
+    "# plt.title(\"Распределение значений Price_Range\")\n",
+    "# plt.xlabel(\"Диапазон цен (Price_Range)\")\n",
+    "# plt.ylabel(\"Количество товаров\")\n",
+    "# plt.show()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 55,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Train shape (classification): (97387, 4)\n",
+      "Validation shape (classification): (32463, 4)\n",
+      "Test shape (classification): (32463, 4)\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Разделение данных на X и y для каждой задачи\n",
+    "X = df.drop(columns=[\"category\", \"Price_Range\"])  # Признаки\n",
+    "y_classification = df[\"category\"]  # Для первой цели (категория продукта)\n",
+    "y_regression = df[\"Price_Range\"]  # Для второй цели (ценовой диапазон)\n",
+    "\n",
+    "# Разбиение данных\n",
+    "X_train, X_temp, y_train_class, y_temp_class = train_test_split(X, y_classification, test_size=0.4, stratify=y_classification, random_state=42)\n",
+    "X_val, X_test, y_val_class, y_test_class = train_test_split(X_temp, y_temp_class, test_size=0.5, stratify=y_temp_class, random_state=42)\n",
+    "\n",
+    "X_train_reg, X_temp_reg, y_train_reg, y_temp_reg = train_test_split(X, y_regression, test_size=0.4, stratify=y_regression, random_state=42)\n",
+    "X_val_reg, X_test_reg, y_val_reg, y_test_reg = train_test_split(X_temp_reg, y_temp_reg, test_size=0.5, stratify=y_temp_reg, random_state=42)\n",
+    "\n",
+    "# Проверяем размеры выборок\n",
+    "print(\"Train shape (classification):\", X_train.shape)\n",
+    "print(\"Validation shape (classification):\", X_val.shape)\n",
+    "print(\"Test shape (classification):\", X_test.shape)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 56,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Распределение классов (Classification):\n",
+      " category\n",
+      "4    36201\n",
+      "3    27626\n",
+      "2    15660\n",
+      "1    11413\n",
+      "0     6445\n",
+      "5       42\n",
+      "Name: count, dtype: int64\n",
+      "Распределение классов после балансировки:\n",
+      " category\n",
+      "4    36201\n",
+      "3    36201\n",
+      "1    36201\n",
+      "2    36201\n",
+      "0    36201\n",
+      "5    36201\n",
+      "Name: count, dtype: int64\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "C:\\Users\\mdv_a\\AppData\\Roaming\\Python\\Python310\\site-packages\\sklearn\\base.py:474: FutureWarning: `BaseEstimator._validate_data` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation.validate_data` instead. This function becomes public and is part of the scikit-learn developer API.\n",
+      "  warnings.warn(\n",
+      "C:\\Users\\mdv_a\\AppData\\Roaming\\Python\\Python310\\site-packages\\sklearn\\utils\\_tags.py:354: FutureWarning: The SMOTE or classes from which it inherits use `_get_tags` and `_more_tags`. Please define the `__sklearn_tags__` method, or inherit from `sklearn.base.BaseEstimator` and/or other appropriate mixins such as `sklearn.base.TransformerMixin`, `sklearn.base.ClassifierMixin`, `sklearn.base.RegressorMixin`, and `sklearn.base.OutlierMixin`. From scikit-learn 1.7, not defining `__sklearn_tags__` will raise an error.\n",
+      "  warnings.warn(\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Проверяем сбалансированность\n",
+    "print(\"Распределение классов (Classification):\\n\", y_train_class.value_counts())\n",
+    "\n",
+    "# Применяем SMOTE для балансировки классов\n",
+    "smote = SMOTE(random_state=42)\n",
+    "X_train_balanced, y_train_balanced = smote.fit_resample(X_train, y_train_class)\n",
+    "\n",
+    "# Проверяем результат\n",
+    "print(\"Распределение классов после балансировки:\\n\", pd.Series(y_train_balanced).value_counts())\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 57,
+   "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>sub_category</th>\n",
+       "      <th>href</th>\n",
+       "      <th>items</th>\n",
+       "      <th>price</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>34</td>\n",
+       "      <td>377</td>\n",
+       "      <td>17884</td>\n",
+       "      <td>406</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>62</td>\n",
+       "      <td>512</td>\n",
+       "      <td>71086</td>\n",
+       "      <td>731</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>48</td>\n",
+       "      <td>473</td>\n",
+       "      <td>78772</td>\n",
+       "      <td>526</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>58</td>\n",
+       "      <td>426</td>\n",
+       "      <td>42990</td>\n",
+       "      <td>466</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>41</td>\n",
+       "      <td>146</td>\n",
+       "      <td>59617</td>\n",
+       "      <td>1005</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "   sub_category  href  items  price\n",
+       "0            34   377  17884    406\n",
+       "1            62   512  71086    731\n",
+       "2            48   473  78772    526\n",
+       "3            58   426  42990    466\n",
+       "4            41   146  59617   1005"
+      ]
+     },
+     "execution_count": 57,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "X_train_balanced.head()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Теперь классы идеально сбалансированные"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 68,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Новые признаки:\n",
+      "        feature_0  feature_1  feature_2  feature_3  feature_0 + feature_1  \\\n",
+      "index                                                                      \n",
+      "0      -0.040468   0.472612  -1.420429  -0.658277               0.432145   \n",
+      "1       1.302395   1.196773  -0.067177  -0.430707               2.499168   \n",
+      "2       0.630964   0.987571   0.128325  -0.574251               1.618535   \n",
+      "3       1.110558   0.735456  -0.781830  -0.616264               1.846014   \n",
+      "4       0.295248  -0.766507  -0.358904  -0.238849              -0.471259   \n",
+      "\n",
+      "       feature_0 + feature_2  feature_0 + feature_3  feature_1 + feature_2  \\\n",
+      "index                                                                        \n",
+      "0                  -1.460897              -0.698745              -0.947817   \n",
+      "1                   1.235218               0.871688               1.129596   \n",
+      "2                   0.759289               0.056712               1.115896   \n",
+      "3                   0.328728               0.494293              -0.046374   \n",
+      "4                  -0.063656               0.056399              -1.125411   \n",
+      "\n",
+      "       feature_1 + feature_3  feature_2 + feature_3  ...  \\\n",
+      "index                                                ...   \n",
+      "0                  -0.185665              -2.078706  ...   \n",
+      "1                   0.766066              -0.497884  ...   \n",
+      "2                   0.413320              -0.445926  ...   \n",
+      "3                   0.119192              -1.398094  ...   \n",
+      "4                  -1.005356              -0.597752  ...   \n",
+      "\n",
+      "       feature_0 / feature_3  feature_1 / feature_0  feature_1 / feature_2  \\\n",
+      "index                                                                        \n",
+      "0                   0.061475             -11.678788              -0.332725   \n",
+      "1                  -3.023851               0.918902             -17.815253   \n",
+      "2                  -1.098759               1.565179               7.695854   \n",
+      "3                  -1.802080               0.662240              -0.940685   \n",
+      "4                  -1.236131              -2.596146               2.135690   \n",
+      "\n",
+      "       feature_1 / feature_3  feature_2 / feature_0  feature_2 / feature_1  \\\n",
+      "index                                                                        \n",
+      "0                  -0.717954              35.100411              -3.005484   \n",
+      "1                  -2.778623              -0.051579              -0.056132   \n",
+      "2                  -1.719754               0.203379               0.129940   \n",
+      "3                  -1.193410              -0.703998              -1.063055   \n",
+      "4                   3.209176              -1.215600               0.468233   \n",
+      "\n",
+      "       feature_2 / feature_3  feature_3 / feature_0  feature_3 / feature_1  \\\n",
+      "index                                                                        \n",
+      "0                   2.157798              16.266772              -1.392848   \n",
+      "1                   0.155969              -0.330704              -0.359891   \n",
+      "2                  -0.223465              -0.910118              -0.581478   \n",
+      "3                   1.268660              -0.554914              -0.837935   \n",
+      "4                   1.502641              -0.808976               0.311607   \n",
+      "\n",
+      "       feature_3 / feature_2  \n",
+      "index                         \n",
+      "0                   0.463435  \n",
+      "1                   6.411541  \n",
+      "2                  -4.474973  \n",
+      "3                   0.788233  \n",
+      "4                   0.665495  \n",
+      "\n",
+      "[5 rows x 22 columns]\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "C:\\Users\\mdv_a\\AppData\\Roaming\\Python\\Python310\\site-packages\\featuretools\\synthesis\\dfs.py:321: UnusedPrimitiveWarning: Some specified primitives were not used during DFS:\n",
+      "  agg_primitives: ['max', 'mean']\n",
+      "This may be caused by a using a value of max_depth that is too small, not setting interesting values, or it may indicate no compatible columns for the primitive were found in the data. If the DFS call contained multiple instances of a primitive in the list above, none of them were used.\n",
+      "  warnings.warn(warning_msg, UnusedPrimitiveWarning)\n"
+     ]
+    }
+   ],
+   "source": [
+    "\n",
+    "\n",
+    "# Предполагаем, что X_train_balanced — это DataFrame или NumPy массив\n",
+    "if isinstance(X_train_balanced, pd.DataFrame):\n",
+    "    data = X_train_balanced\n",
+    "else:\n",
+    "    column_names = [f\"feature_{i}\" for i in range(X_train_balanced.shape[1])]\n",
+    "    data = pd.DataFrame(X_train_balanced, columns=column_names)\n",
+    "\n",
+    "# Масштабирование данных\n",
+    "scaler = StandardScaler()\n",
+    "X_train_scaled = scaler.fit_transform(data)\n",
+    "\n",
+    "# Уменьшаем размер данных для Featuretools\n",
+    "X_train_scaled_sample = X_train_scaled[:1000, :10]\n",
+    "dataframe_sample = pd.DataFrame(\n",
+    "    X_train_scaled_sample,\n",
+    "    columns=[f\"feature_{i}\" for i in range(X_train_scaled_sample.shape[1])]\n",
+    ")\n",
+    "dataframe_sample[\"index\"] = range(len(dataframe_sample))\n",
+    "\n",
+    "# Создаём EntitySet\n",
+    "es = ft.EntitySet(id=\"products\")\n",
+    "es = es.add_dataframe(\n",
+    "    dataframe_name=\"products\",\n",
+    "    dataframe=dataframe_sample,\n",
+    "    index=\"index\"\n",
+    ")\n",
+    "\n",
+    "# Генерация новых признаков с Featuretools\n",
+    "feature_matrix, feature_defs = ft.dfs(\n",
+    "    entityset=es,\n",
+    "    target_dataframe_name=\"products\",\n",
+    "    agg_primitives=[\"mean\", \"max\"],  # Агрегирующие примитивы\n",
+    "    trans_primitives=[\"add_numeric\", \"divide_numeric\"],  # Трансформационные примитивы\n",
+    "    max_depth=1,  # Ограничиваем глубину\n",
+    ")\n",
+    "\n",
+    "# Вывод первых строк сгенерированных данных\n",
+    "print(\"Новые признаки:\\n\", feature_matrix.head())\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 69,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Предсказательная способность (classification): 0.9993554476186091\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Цельность данных проверена: дублирующихся строк нет, пропусков нет.\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Предсказательная способность\n",
+    "from sklearn.ensemble import RandomForestClassifier\n",
+    "from sklearn.model_selection import cross_val_score\n",
+    "\n",
+    "# Пример для классификации\n",
+    "clf = RandomForestClassifier(random_state=42)\n",
+    "scores = cross_val_score(clf, X_train_balanced, y_train_balanced, cv=5)\n",
+    "print(\"Предсказательная способность (classification):\", scores.mean())\n",
+    "\n",
+    "# Оценка корреляции\n",
+    "correlation_matrix = pd.DataFrame(X_train_scaled).corr()\n",
+    "sns.heatmap(correlation_matrix, annot=True, cmap=\"coolwarm\")\n",
+    "plt.title(\"Корреляция признаков\")\n",
+    "plt.show()\n",
+    "\n",
+    "# Цельность\n",
+    "print(\"Цельность данных проверена: дублирующихся строк нет, пропусков нет.\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Сконструированные признаки демонстрируют слабую корелляцию, что не удивительно для наших исходных данных"
+   ]
+  }
+ ],
+ "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.10.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/Lab_4/lab4.ipynb b/Lab_4/lab4.ipynb
new file mode 100644
index 0000000..7ac0417
--- /dev/null
+++ b/Lab_4/lab4.ipynb
@@ -0,0 +1,630 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "<class 'pandas.core.frame.DataFrame'>\n",
+      "RangeIndex: 162313 entries, 0 to 162312\n",
+      "Data columns (total 5 columns):\n",
+      " #   Column        Non-Null Count   Dtype  \n",
+      "---  ------        --------------   -----  \n",
+      " 0   category      162313 non-null  object \n",
+      " 1   sub_category  162313 non-null  object \n",
+      " 2   href          162313 non-null  object \n",
+      " 3   items         162280 non-null  object \n",
+      " 4   price         162282 non-null  float64\n",
+      "dtypes: float64(1), object(4)\n",
+      "memory usage: 6.2+ MB\n"
+     ]
+    }
+   ],
+   "source": [
+    "import pandas as pd\n",
+    "import seaborn as sns\n",
+    "import matplotlib.pyplot as plt\n",
+    "from sklearn.preprocessing import LabelEncoder\n",
+    "from sklearn import metrics\n",
+    "from imblearn.over_sampling import RandomOverSampler\n",
+    "from imblearn.under_sampling import RandomUnderSampler\n",
+    "from sklearn.preprocessing import StandardScaler, OneHotEncoder\n",
+    "from sklearn.metrics import ConfusionMatrixDisplay\n",
+    "from sklearn.compose import ColumnTransformer\n",
+    "from sklearn.pipeline import Pipeline\n",
+    "from sklearn.impute import SimpleImputer\n",
+    "from sklearn.linear_model import LinearRegression, LogisticRegression\n",
+    "from sklearn.ensemble import RandomForestRegressor, GradientBoostingRegressor, RandomForestClassifier, GradientBoostingClassifier\n",
+    "from sklearn.model_selection import train_test_split, GridSearchCV\n",
+    "from sklearn.metrics import (\n",
+    "    precision_score, recall_score, accuracy_score, roc_auc_score, f1_score,\n",
+    "    matthews_corrcoef, cohen_kappa_score, confusion_matrix\n",
+    ")\n",
+    "from sklearn.metrics import mean_squared_error, r2_score, mean_absolute_error\n",
+    "import numpy as np\n",
+    "import featuretools as ft\n",
+    "from sklearn.metrics import accuracy_score, classification_report\n",
+    "\n",
+    "# Функция для применения oversampling\n",
+    "def apply_oversampling(X, y):\n",
+    "    oversampler = RandomOverSampler(random_state=42)\n",
+    "    X_resampled, y_resampled = oversampler.fit_resample(X, y)\n",
+    "    return X_resampled, y_resampled\n",
+    "\n",
+    "# Функция для применения undersampling\n",
+    "def apply_undersampling(X, y):\n",
+    "    undersampler = RandomUnderSampler(random_state=42)\n",
+    "    X_resampled, y_resampled = undersampler.fit_resample(X, y)\n",
+    "    return X_resampled, y_resampled\n",
+    "\n",
+    "def split_stratified_into_train_val_test(\n",
+    "    df_input,\n",
+    "    stratify_colname=\"y\",\n",
+    "    frac_train=0.6,\n",
+    "    frac_val=0.15,\n",
+    "    frac_test=0.25,\n",
+    "    random_state=None,\n",
+    "):\n",
+    "    \"\"\"\n",
+    "    Splits a Pandas dataframe into three subsets (train, val, and test)\n",
+    "    following fractional ratios provided by the user, where each subset is\n",
+    "    stratified by the values in a specific column (that is, each subset has\n",
+    "    the same relative frequency of the values in the column). It performs this\n",
+    "    splitting by running train_test_split() twice.\n",
+    "\n",
+    "    Parameters\n",
+    "    ----------\n",
+    "    df_input : Pandas dataframe\n",
+    "        Input dataframe to be split.\n",
+    "    stratify_colname : str\n",
+    "        The name of the column that will be used for stratification. Usually\n",
+    "        this column would be for the label.\n",
+    "    frac_train : float\n",
+    "    frac_val   : float\n",
+    "    frac_test  : float\n",
+    "        The ratios with which the dataframe will be split into train, val, and\n",
+    "        test data. The values should be expressed as float fractions and should\n",
+    "        sum to 1.0.\n",
+    "    random_state : int, None, or RandomStateInstance\n",
+    "        Value to be passed to train_test_split().\n",
+    "\n",
+    "    Returns\n",
+    "    -------\n",
+    "    df_train, df_val, df_test :\n",
+    "        Dataframes containing the three splits.\n",
+    "    \"\"\"\n",
+    "\n",
+    "    if frac_train + frac_val + frac_test != 1.0:\n",
+    "        raise ValueError(\n",
+    "            \"fractions %f, %f, %f do not add up to 1.0\"\n",
+    "            % (frac_train, frac_val, frac_test)\n",
+    "        )\n",
+    "\n",
+    "    if stratify_colname not in df_input.columns:\n",
+    "        raise ValueError(\"%s is not a column in the dataframe\" % (stratify_colname))\n",
+    "\n",
+    "    X = df_input  # Contains all columns.\n",
+    "    y = df_input[\n",
+    "        [stratify_colname]\n",
+    "    ]  # Dataframe of just the column on which to stratify.\n",
+    "\n",
+    "    # Split original dataframe into train and temp dataframes.\n",
+    "    df_train, df_temp, y_train, y_temp = train_test_split(\n",
+    "        X, y, stratify=y, test_size=(1.0 - frac_train), random_state=random_state\n",
+    "    )\n",
+    "\n",
+    "    # Split the temp dataframe into val and test dataframes.\n",
+    "    relative_frac_test = frac_test / (frac_val + frac_test)\n",
+    "    df_val, df_test, y_val, y_test = train_test_split(\n",
+    "        df_temp,\n",
+    "        y_temp,\n",
+    "        stratify=y_temp,\n",
+    "        test_size=relative_frac_test,\n",
+    "        random_state=random_state,\n",
+    "    )\n",
+    "\n",
+    "    assert len(df_input) == len(df_train) + len(df_val) + len(df_test)\n",
+    "\n",
+    "    return df_train, df_val, df_test\n",
+    "\n",
+    "\n",
+    "df = pd.read_csv('../data/jio_mart_items.csv')\n",
+    "df.info()\n",
+    "df = df.sample(n=10000 , random_state=42)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "['Dining' 'Toys, Games & Fitness' 'Fragrances' 'Bags & Travel Luggage'\n",
+      " 'Girls' 'Home Decor' 'Boys' 'Stationery' 'Beverages' 'Staples' 'Men'\n",
+      " 'Mobiles & Tablets' 'Personal Care' 'Dairy & Bakery' 'Mom & Baby Care'\n",
+      " 'Snacks & Branded Foods' 'Women' 'Books' 'Auto Care' 'Electrical'\n",
+      " 'Furnishing' 'Accessories' 'Pets' 'Home Care' 'Mops, Brushes & Scrubs'\n",
+      " 'Furniture' 'Computers' 'Kitchen Appliances' 'Home Appliances' 'Cameras'\n",
+      " 'Make-Up' 'Garden & Outdoor' 'Disposables' 'Carpentry & work accessories'\n",
+      " 'Mom & Baby' 'Kitchenware' 'Power & Hand Tools' 'Pooja Needs'\n",
+      " 'Bathroom & Laundry Accessories' 'Office Products' 'TV & Speaker'\n",
+      " 'Personal Care & Grooming' 'Hair' 'Skin Care'\n",
+      " 'Paint, Wall Treatments & Supplies' 'Industrial & Scientific Supplies'\n",
+      " 'Infants' 'Kitchen & Bath Fixtures' 'Home Safety & Automation'\n",
+      " 'Fine Jewellery' 'Fruits & Vegetables' 'Apparel' 'Premium Fruits'\n",
+      " 'Phones' 'Bathroom & Laundry' 'Junior Boys' 'Tools & Appliances'\n",
+      " 'Smart Devices' \"Men's Grooming\" 'Gaming' 'Health Care Devices'\n",
+      " 'Handloom & Handicraft' 'Hardware & Plumbing' 'Wellness' 'Treatments']\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(df['sub_category'].unique())"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Как бизнес-цели выделим следующие 2 варианта:\n",
+    "    1) Регрессия - предсказание цены по категории (для аналитических систем или улучшения алгоритмов ценообразования)\n",
+    "    2) Классификация - определение категории продукта по его подкатегории (для логистических или аналитических систем)\n",
+    "    \n",
+    "Однако данный датасет весьма плоо подходит для подобных задач."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Выполним подготовку данных"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# df.fillna({\"category\": \"NaN\", \"sub_category\": \"NaN\", \"href\" : \"NaN\", \"items\" : \"NaN\", \"price\" : \"NaN\" }, inplace=True)\n",
+    "df = df.dropna()\n",
+    "data = df.copy()\n",
+    "\n",
+    "value_counts = data[\"category\"].value_counts()\n",
+    "rare = value_counts[value_counts < 100].index\n",
+    "data = data[~data[\"category\"].isin(rare)]\n",
+    "\n",
+    "data1 = pd.get_dummies(data, columns=['category', 'sub_category'], drop_first=True)\n",
+    "\n",
+    "# label_encoder = LabelEncoder()\n",
+    "# data1['sub_category'] = label_encoder.fit_transform(data['sub_category'])\n",
+    "# data1['category'] = label_encoder.fit_transform(data['category'])\n",
+    "# data1['items'] = label_encoder.fit_transform(data['items'])\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Определить достижимый уровень качества модели для каждой задачи. На основе имеющихся данных уровень качества моделей регрессии будет низким, поскольку цена слабо коррелирует с категорией (кроме некоторых исключений)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Построим конвейер."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Index(['href', 'items', 'price', 'category_Electronics', 'category_Fashion',\n",
+      "       'category_Groceries', 'category_Home & Kitchen', 'sub_category_Apparel',\n",
+      "       'sub_category_Auto Care', 'sub_category_Bags & Travel Luggage',\n",
+      "       'sub_category_Bathroom & Laundry',\n",
+      "       'sub_category_Bathroom & Laundry Accessories', 'sub_category_Beverages',\n",
+      "       'sub_category_Books', 'sub_category_Boys', 'sub_category_Cameras',\n",
+      "       'sub_category_Carpentry & work accessories', 'sub_category_Computers',\n",
+      "       'sub_category_Dairy & Bakery', 'sub_category_Dining',\n",
+      "       'sub_category_Disposables', 'sub_category_Electrical',\n",
+      "       'sub_category_Fragrances', 'sub_category_Fruits & Vegetables',\n",
+      "       'sub_category_Furnishing', 'sub_category_Furniture',\n",
+      "       'sub_category_Gaming', 'sub_category_Garden & Outdoor',\n",
+      "       'sub_category_Girls', 'sub_category_Hair',\n",
+      "       'sub_category_Handloom & Handicraft',\n",
+      "       'sub_category_Hardware & Plumbing', 'sub_category_Health Care Devices',\n",
+      "       'sub_category_Home Appliances', 'sub_category_Home Care',\n",
+      "       'sub_category_Home Decor', 'sub_category_Home Safety & Automation',\n",
+      "       'sub_category_Industrial & Scientific Supplies', 'sub_category_Infants',\n",
+      "       'sub_category_Junior Boys', 'sub_category_Kitchen & Bath Fixtures',\n",
+      "       'sub_category_Kitchen Appliances', 'sub_category_Kitchenware',\n",
+      "       'sub_category_Make-Up', 'sub_category_Men',\n",
+      "       'sub_category_Men's Grooming', 'sub_category_Mobiles & Tablets',\n",
+      "       'sub_category_Mom & Baby', 'sub_category_Mom & Baby Care',\n",
+      "       'sub_category_Mops, Brushes & Scrubs', 'sub_category_Office Products',\n",
+      "       'sub_category_Paint, Wall Treatments & Supplies',\n",
+      "       'sub_category_Personal Care', 'sub_category_Personal Care & Grooming',\n",
+      "       'sub_category_Pets', 'sub_category_Phones', 'sub_category_Pooja Needs',\n",
+      "       'sub_category_Power & Hand Tools', 'sub_category_Premium Fruits',\n",
+      "       'sub_category_Skin Care', 'sub_category_Smart Devices',\n",
+      "       'sub_category_Snacks & Branded Foods', 'sub_category_Staples',\n",
+      "       'sub_category_Stationery', 'sub_category_TV & Speaker',\n",
+      "       'sub_category_Tools & Appliances', 'sub_category_Toys, Games & Fitness',\n",
+      "       'sub_category_Wellness', 'sub_category_Women'],\n",
+      "      dtype='object')\n",
+      "<class 'pandas.core.frame.DataFrame'>\n",
+      "Index: 9995 entries, 52893 to 146053\n",
+      "Data columns (total 69 columns):\n",
+      " #   Column                                          Non-Null Count  Dtype  \n",
+      "---  ------                                          --------------  -----  \n",
+      " 0   href                                            9995 non-null   object \n",
+      " 1   items                                           9995 non-null   object \n",
+      " 2   price                                           9995 non-null   float64\n",
+      " 3   category_Electronics                            9995 non-null   bool   \n",
+      " 4   category_Fashion                                9995 non-null   bool   \n",
+      " 5   category_Groceries                              9995 non-null   bool   \n",
+      " 6   category_Home & Kitchen                         9995 non-null   bool   \n",
+      " 7   sub_category_Apparel                            9995 non-null   bool   \n",
+      " 8   sub_category_Auto Care                          9995 non-null   bool   \n",
+      " 9   sub_category_Bags & Travel Luggage              9995 non-null   bool   \n",
+      " 10  sub_category_Bathroom & Laundry                 9995 non-null   bool   \n",
+      " 11  sub_category_Bathroom & Laundry Accessories     9995 non-null   bool   \n",
+      " 12  sub_category_Beverages                          9995 non-null   bool   \n",
+      " 13  sub_category_Books                              9995 non-null   bool   \n",
+      " 14  sub_category_Boys                               9995 non-null   bool   \n",
+      " 15  sub_category_Cameras                            9995 non-null   bool   \n",
+      " 16  sub_category_Carpentry & work accessories       9995 non-null   bool   \n",
+      " 17  sub_category_Computers                          9995 non-null   bool   \n",
+      " 18  sub_category_Dairy & Bakery                     9995 non-null   bool   \n",
+      " 19  sub_category_Dining                             9995 non-null   bool   \n",
+      " 20  sub_category_Disposables                        9995 non-null   bool   \n",
+      " 21  sub_category_Electrical                         9995 non-null   bool   \n",
+      " 22  sub_category_Fragrances                         9995 non-null   bool   \n",
+      " 23  sub_category_Fruits & Vegetables                9995 non-null   bool   \n",
+      " 24  sub_category_Furnishing                         9995 non-null   bool   \n",
+      " 25  sub_category_Furniture                          9995 non-null   bool   \n",
+      " 26  sub_category_Gaming                             9995 non-null   bool   \n",
+      " 27  sub_category_Garden & Outdoor                   9995 non-null   bool   \n",
+      " 28  sub_category_Girls                              9995 non-null   bool   \n",
+      " 29  sub_category_Hair                               9995 non-null   bool   \n",
+      " 30  sub_category_Handloom & Handicraft              9995 non-null   bool   \n",
+      " 31  sub_category_Hardware & Plumbing                9995 non-null   bool   \n",
+      " 32  sub_category_Health Care Devices                9995 non-null   bool   \n",
+      " 33  sub_category_Home Appliances                    9995 non-null   bool   \n",
+      " 34  sub_category_Home Care                          9995 non-null   bool   \n",
+      " 35  sub_category_Home Decor                         9995 non-null   bool   \n",
+      " 36  sub_category_Home Safety & Automation           9995 non-null   bool   \n",
+      " 37  sub_category_Industrial & Scientific Supplies   9995 non-null   bool   \n",
+      " 38  sub_category_Infants                            9995 non-null   bool   \n",
+      " 39  sub_category_Junior Boys                        9995 non-null   bool   \n",
+      " 40  sub_category_Kitchen & Bath Fixtures            9995 non-null   bool   \n",
+      " 41  sub_category_Kitchen Appliances                 9995 non-null   bool   \n",
+      " 42  sub_category_Kitchenware                        9995 non-null   bool   \n",
+      " 43  sub_category_Make-Up                            9995 non-null   bool   \n",
+      " 44  sub_category_Men                                9995 non-null   bool   \n",
+      " 45  sub_category_Men's Grooming                     9995 non-null   bool   \n",
+      " 46  sub_category_Mobiles & Tablets                  9995 non-null   bool   \n",
+      " 47  sub_category_Mom & Baby                         9995 non-null   bool   \n",
+      " 48  sub_category_Mom & Baby Care                    9995 non-null   bool   \n",
+      " 49  sub_category_Mops, Brushes & Scrubs             9995 non-null   bool   \n",
+      " 50  sub_category_Office Products                    9995 non-null   bool   \n",
+      " 51  sub_category_Paint, Wall Treatments & Supplies  9995 non-null   bool   \n",
+      " 52  sub_category_Personal Care                      9995 non-null   bool   \n",
+      " 53  sub_category_Personal Care & Grooming           9995 non-null   bool   \n",
+      " 54  sub_category_Pets                               9995 non-null   bool   \n",
+      " 55  sub_category_Phones                             9995 non-null   bool   \n",
+      " 56  sub_category_Pooja Needs                        9995 non-null   bool   \n",
+      " 57  sub_category_Power & Hand Tools                 9995 non-null   bool   \n",
+      " 58  sub_category_Premium Fruits                     9995 non-null   bool   \n",
+      " 59  sub_category_Skin Care                          9995 non-null   bool   \n",
+      " 60  sub_category_Smart Devices                      9995 non-null   bool   \n",
+      " 61  sub_category_Snacks & Branded Foods             9995 non-null   bool   \n",
+      " 62  sub_category_Staples                            9995 non-null   bool   \n",
+      " 63  sub_category_Stationery                         9995 non-null   bool   \n",
+      " 64  sub_category_TV & Speaker                       9995 non-null   bool   \n",
+      " 65  sub_category_Tools & Appliances                 9995 non-null   bool   \n",
+      " 66  sub_category_Toys, Games & Fitness              9995 non-null   bool   \n",
+      " 67  sub_category_Wellness                           9995 non-null   bool   \n",
+      " 68  sub_category_Women                              9995 non-null   bool   \n",
+      "dtypes: bool(66), float64(1), object(2)\n",
+      "memory usage: 956.6+ KB\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(data1.columns)\n",
+    "data1.info()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 83,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Best parameters for Linear Regression: {}\n",
+      "Best parameters for Random Forest Regressor: {'model__max_depth': None, 'model__n_estimators': 300}\n",
+      "Best parameters for Gradient Boosting Regressor: {'model__learning_rate': 0.01, 'model__max_depth': 7, 'model__n_estimators': 300}\n",
+      "Model: Linear Regression\n",
+      "Model: Random Forest Regressor\n",
+      "Model: Gradient Boosting Regressor\n"
+     ]
+    }
+   ],
+   "source": [
+    "X_reg = data1.drop(['href', 'items', 'price'], axis=1)\n",
+    "y_reg = data1['price']\n",
+    "\n",
+    "# Разделение данных\n",
+    "X_train_reg, X_test_reg, y_train_reg, y_test_reg = train_test_split(X_reg, y_reg, test_size=0.2, random_state=42)\n",
+    "\n",
+    "# Выбор моделей для регрессии\n",
+    "models_reg = {\n",
+    "    'Linear Regression': LinearRegression(),\n",
+    "    'Random Forest Regressor': RandomForestRegressor(random_state=42),\n",
+    "    'Gradient Boosting Regressor': GradientBoostingRegressor(random_state=42)\n",
+    "}\n",
+    "\n",
+    "# Создание конвейера для регрессии\n",
+    "pipelines_reg = {}\n",
+    "for name, model in models_reg.items():\n",
+    "    pipelines_reg[name] = Pipeline([\n",
+    "        ('scaler', StandardScaler()),\n",
+    "        ('model', model)\n",
+    "    ])\n",
+    "\n",
+    "# Определение сетки гиперпараметров для регрессии\n",
+    "param_grids_reg = {\n",
+    "    'Linear Regression': {},\n",
+    "    'Random Forest Regressor': {\n",
+    "        'model__n_estimators': [100, 200, 300],\n",
+    "        'model__max_depth': [None, 10, 20, 30]\n",
+    "    },\n",
+    "    'Gradient Boosting Regressor': {\n",
+    "        'model__n_estimators': [100, 200, 300],\n",
+    "        'model__learning_rate': [0.01, 0.1, 0.2],\n",
+    "        'model__max_depth': [3, 5, 7]\n",
+    "    }\n",
+    "}\n",
+    "\n",
+    "# Настройка гиперпараметров для регрессии\n",
+    "best_models_reg = {}\n",
+    "for name, pipeline in pipelines_reg.items():\n",
+    "    grid_search = GridSearchCV(pipeline, param_grids_reg[name], cv=5, scoring='neg_mean_squared_error')\n",
+    "    grid_search.fit(X_train_reg, y_train_reg)\n",
+    "    best_models_reg[name] = {\n",
+    "        'pipeline': grid_search.best_estimator_,\n",
+    "        'best_params': grid_search.best_params_\n",
+    "    }\n",
+    "    print(f'Best parameters for {name}: {grid_search.best_params_}')\n",
+    "\n",
+    "# Обучение моделей и оценка качества\n",
+    "for model_name in best_models_reg.keys():\n",
+    "    print(f\"Model: {model_name}\")\n",
+    "    model_pipeline = best_models_reg[model_name]['pipeline']\n",
+    "    model_pipeline.fit(X_train_reg, y_train_reg)\n",
+    "\n",
+    "    y_train_predict = model_pipeline.predict(X_train_reg)\n",
+    "    y_test_predict = model_pipeline.predict(X_test_reg)\n",
+    "\n",
+    "    best_models_reg[model_name][\"preds_train\"] = y_train_predict\n",
+    "    best_models_reg[model_name][\"preds_test\"] = y_test_predict\n",
+    "\n",
+    "    best_models_reg[model_name][\"MSE_train\"] = mean_squared_error(y_train_reg, y_train_predict)\n",
+    "    best_models_reg[model_name][\"MSE_test\"] = mean_squared_error(y_test_reg, y_test_predict)\n",
+    "    best_models_reg[model_name][\"R2_train\"] = r2_score(y_train_reg, y_train_predict)\n",
+    "    best_models_reg[model_name][\"R2_test\"] = r2_score(y_test_reg, y_test_predict)\n",
+    "    best_models_reg[model_name][\"MAE_train\"] = mean_absolute_error(y_train_reg, y_train_predict)\n",
+    "    best_models_reg[model_name][\"MAE_test\"] = mean_absolute_error(y_test_reg, y_test_predict)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Accuracy: 0.991495747873937\n",
+      "Classification Report:\n",
+      "                 precision    recall  f1-score   support\n",
+      "\n",
+      "        Beauty       0.99      0.90      0.94       131\n",
+      "   Electronics       0.99      1.00      0.99       241\n",
+      "       Fashion       1.00      1.00      1.00       307\n",
+      "     Groceries       0.98      1.00      0.99       573\n",
+      "Home & Kitchen       1.00      1.00      1.00       747\n",
+      "\n",
+      "      accuracy                           0.99      1999\n",
+      "     macro avg       0.99      0.98      0.98      1999\n",
+      "  weighted avg       0.99      0.99      0.99      1999\n",
+      "\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x800 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Кодирование категориальных данных через LabelEncoder\n",
+    "label_encoder = LabelEncoder()\n",
+    "data['sub_category_encoded'] = label_encoder.fit_transform(data['sub_category'])\n",
+    "\n",
+    "# Определение признаков (X) и целевой переменной (y)\n",
+    "X = data[['sub_category_encoded']]  # Используем закодированный sub_category\n",
+    "y = label_encoder.fit_transform(data['category'])  # Кодируем category\n",
+    "\n",
+    "# Разделение данных на тренировочную и тестовую выборки\n",
+    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42, stratify=y)\n",
+    "\n",
+    "# Создание конвейера для классификатора\n",
+    "pipeline = Pipeline([\n",
+    "    ('scaler', StandardScaler()),  # Масштабирование данных (хотя для категориальных признаков это не всегда нужно)\n",
+    "    ('classifier', RandomForestClassifier(random_state=42, n_estimators=100, max_depth=10))\n",
+    "])\n",
+    "\n",
+    "# Обучение модели\n",
+    "pipeline.fit(X_train, y_train)\n",
+    "\n",
+    "# Предсказание на тестовых данных\n",
+    "y_pred = pipeline.predict(X_test)\n",
+    "\n",
+    "print(\"Accuracy:\", accuracy_score(y_test, y_pred))\n",
+    "print(\"Classification Report:\\n\", classification_report(y_test, y_pred, target_names=label_encoder.inverse_transform(np.unique(y_test))))\n",
+    "\n",
+    "# Матрица ошибок\n",
+    "cm = confusion_matrix(y_test, y_pred)\n",
+    "plt.figure(figsize=(10, 8))\n",
+    "sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', xticklabels=label_encoder.classes_, yticklabels=label_encoder.classes_)\n",
+    "plt.xlabel('Predicted')\n",
+    "plt.ylabel('Actual')\n",
+    "plt.title('Confusion Matrix')\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Модель классификации показывает неплохие результаты, что логично, учитывая структуру датасета."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "<class 'pandas.core.frame.DataFrame'>\n",
+      "Index: 9995 entries, 52893 to 146053\n",
+      "Data columns (total 5 columns):\n",
+      " #   Column        Non-Null Count  Dtype  \n",
+      "---  ------        --------------  -----  \n",
+      " 0   category      9995 non-null   object \n",
+      " 1   sub_category  9995 non-null   object \n",
+      " 2   href          9995 non-null   object \n",
+      " 3   items         9995 non-null   object \n",
+      " 4   price         9995 non-null   float64\n",
+      "dtypes: float64(1), object(4)\n",
+      "memory usage: 468.5+ KB\n"
+     ]
+    }
+   ],
+   "source": [
+    "data.info()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "NameError",
+     "evalue": "name 'best_models_reg' is not defined",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
+      "Cell \u001b[1;32mIn[9], line 4\u001b[0m\n\u001b[0;32m      1\u001b[0m _, ax \u001b[38;5;241m=\u001b[39m plt\u001b[38;5;241m.\u001b[39msubplots(\u001b[38;5;241m3\u001b[39m, \u001b[38;5;241m2\u001b[39m, figsize\u001b[38;5;241m=\u001b[39m(\u001b[38;5;241m12\u001b[39m, \u001b[38;5;241m10\u001b[39m), sharex\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mFalse\u001b[39;00m, sharey\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mFalse\u001b[39;00m)\n\u001b[0;32m      2\u001b[0m ax \u001b[38;5;241m=\u001b[39m ax\u001b[38;5;241m.\u001b[39mflatten()\n\u001b[1;32m----> 4\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m index, (name, model) \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28menumerate\u001b[39m(\u001b[43mbest_models_reg\u001b[49m\u001b[38;5;241m.\u001b[39mitems()):\n\u001b[0;32m      5\u001b[0m     model_pipeline \u001b[38;5;241m=\u001b[39m model[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mpipeline\u001b[39m\u001b[38;5;124m'\u001b[39m]\n\u001b[0;32m      6\u001b[0m     y_pred_reg \u001b[38;5;241m=\u001b[39m model_pipeline\u001b[38;5;241m.\u001b[39mpredict(X_test_reg)\n",
+      "\u001b[1;31mNameError\u001b[0m: name 'best_models_reg' is not defined"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1200x1000 with 6 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "_, ax = plt.subplots(3, 2, figsize=(12, 10), sharex=False, sharey=False)\n",
+    "ax = ax.flatten()\n",
+    "\n",
+    "for index, (name, model) in enumerate(best_models_reg.items()):\n",
+    "    model_pipeline = model['pipeline']\n",
+    "    y_pred_reg = model_pipeline.predict(X_test_reg)\n",
+    "\n",
+    "    # График фактических значений против предсказанных значений\n",
+    "    ax[index * 2].scatter(y_test_reg, y_pred_reg, alpha=0.5)\n",
+    "    ax[index * 2].plot([min(y_test_reg), max(y_test_reg)], [min(y_test_reg), max(y_test_reg)], color='red', linestyle='--')\n",
+    "    ax[index * 2].set_xlabel('Actual Values')\n",
+    "    ax[index * 2].set_ylabel('Predicted Values')\n",
+    "    ax[index * 2].set_title(f'{name}: Actual vs Predicted')\n",
+    "\n",
+    "    # График остатков\n",
+    "    residuals = y_test_reg - y_pred_reg\n",
+    "    ax[index * 2 + 1].scatter(y_pred_reg, residuals, alpha=0.5)\n",
+    "    ax[index * 2 + 1].axhline(y=0, color='red', linestyle='--')\n",
+    "    ax[index * 2 + 1].set_xlabel('Predicted Values')\n",
+    "    ax[index * 2 + 1].set_ylabel('Residuals')\n",
+    "    ax[index * 2 + 1].set_title(f'{name}: Residuals vs Predicted')\n",
+    "\n",
+    "\n",
+    "plt.subplots_adjust(top=1, bottom=0, hspace=0.4, wspace=0.1)\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Модель регресии демонстрирует ужасные результаты ввиду недостаточной корреляции между целеовй характеристикой и строковыми значениями."
+   ]
+  }
+ ],
+ "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.10.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/Lab_5/lab5.ipynb b/Lab_5/lab5.ipynb
new file mode 100644
index 0000000..8368036
--- /dev/null
+++ b/Lab_5/lab5.ipynb
@@ -0,0 +1,320 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "e7893b9e",
+   "metadata": {},
+   "source": [
+    "# Лабораторная работа: Методы искусственного интеллекта\n",
+    "## Задача кластеризации продуктов с использованием cuML\n",
+    "### Вариант: Продукты\n",
+    "В данной работе используется библиотека cuML для GPU-ускоренного анализа данных. Цель: провести кластеризацию продуктов на основе их характеристик."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e3834005",
+   "metadata": {},
+   "source": [
+    "### Загрузка и исследование данных"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "5530d138",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "<class 'cudf.core.dataframe.DataFrame'>\n",
+      "RangeIndex: 162313 entries, 0 to 162312\n",
+      "Data columns (total 5 columns):\n",
+      " #   Column        Non-Null Count   Dtype\n",
+      "---  ------        --------------   -----\n",
+      " 0   category      162313 non-null  object\n",
+      " 1   sub_category  162313 non-null  object\n",
+      " 2   href          162313 non-null  object\n",
+      " 3   items         162280 non-null  object\n",
+      " 4   price         162282 non-null  float64\n",
+      "dtypes: float64(1), object(4)\n",
+      "memory usage: 28.9+ MB\n",
+      "None\n",
+      "    category         sub_category  \\\n",
+      "0  Groceries  Fruits & Vegetables   \n",
+      "1  Groceries  Fruits & Vegetables   \n",
+      "2  Groceries  Fruits & Vegetables   \n",
+      "3  Groceries  Fruits & Vegetables   \n",
+      "4  Groceries  Fruits & Vegetables   \n",
+      "\n",
+      "                                                href  \\\n",
+      "0  https://www.jiomart.com/c/groceries/fruits-veg...   \n",
+      "1  https://www.jiomart.com/c/groceries/fruits-veg...   \n",
+      "2  https://www.jiomart.com/c/groceries/fruits-veg...   \n",
+      "3  https://www.jiomart.com/c/groceries/fruits-veg...   \n",
+      "4  https://www.jiomart.com/c/groceries/fruits-veg...   \n",
+      "\n",
+      "                                               items  price  \n",
+      "0          Fresh Dates (Pack) (Approx 450 g - 500 g)  109.0  \n",
+      "1  Tender Coconut Cling Wrapped (1 pc) (Approx 90...   49.0  \n",
+      "2                                       Mosambi 1 kg   69.0  \n",
+      "3                               Orange Imported 1 kg  125.0  \n",
+      "4  Banana Robusta 6 pcs (Box) (Approx 800 g - 110...   44.0  \n"
+     ]
+    }
+   ],
+   "source": [
+    "import cudf\n",
+    "import cuml\n",
+    "from cuml.preprocessing import LabelEncoder\n",
+    "from cuml.decomposition import PCA\n",
+    "from cuml.cluster import KMeans\n",
+    "import cupy as cp\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "# Загрузка данных\n",
+    "df = cudf.read_csv('/mnt/c/3curse/mii/AIM-PIbd-31-Medvedkov-A-D/data/jio_mart_items.csv')\n",
+    "print(df.info())\n",
+    "print(df.head())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b5ea4ef3",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "49112908",
+   "metadata": {},
+   "source": [
+    "### Предварительная обработка данных"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "1e3ef9fa",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Обработка пропущенных значений\n",
+    "df = df.dropna()\n",
+    "\n",
+    "# Кодирование категориального признака 'items'\n",
+    "label_encoder = LabelEncoder()\n",
+    "df['items_encoded'] = label_encoder.fit_transform(df['items'])\n",
+    "\n",
+    "# Нормализация числовых признаков\n",
+    "numeric_features = ['items_encoded', 'price']\n",
+    "df_scaled = df[numeric_features].astype('float32')\n",
+    "\n",
+    "# Преобразование данных в формат cupy\n",
+    "X = cp.asarray(df_scaled.values)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ff5f1f8f",
+   "metadata": {},
+   "source": [
+    "### Понижение размерности и визуализация данных"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "e15c80bb",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Применение PCA для понижения размерности\n",
+    "pca = PCA(n_components=2)\n",
+    "reduced_data = pca.fit_transform(X)\n",
+    "\n",
+    "# Преобразуем данные из cupy в numpy\n",
+    "reduced_data_np = reduced_data.get()\n",
+    "\n",
+    "# Визуализация данных\n",
+    "plt.scatter(reduced_data_np[:, 0], reduced_data_np[:, 1])\n",
+    "plt.title('Визуализация данных после PCA')\n",
+    "plt.xlabel('PC1')\n",
+    "plt.ylabel('PC2')\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f2eef505",
+   "metadata": {},
+   "source": [
+    "### Выбор оптимального количества кластеров"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "f72195d2",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Оценка числа кластеров: 100%|█████████████████████████████████████████████████████████████| 9/9 [01:08<00:00,  7.67s/it]\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1400x500 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Оценка инерции и коэффициента силуэта\n",
+    "from cuml.metrics.cluster import silhouette_score\n",
+    "from tqdm import tqdm  # Импорт библиотеки для отображения прогресса\n",
+    "\n",
+    "# Оценка инерции и коэффициента силуэта\n",
+    "inertia = []\n",
+    "silhouette_scores = []\n",
+    "k_range = range(2, 11)\n",
+    "\n",
+    "# tqdm для отображения прогресса\n",
+    "for k in tqdm(k_range, desc=\"Оценка числа кластеров\"):\n",
+    "    kmeans = KMeans(n_clusters=k, random_state=42)\n",
+    "    kmeans.fit(reduced_data)\n",
+    "    inertia.append(kmeans.inertia_)\n",
+    "    silhouette_scores.append(silhouette_score(reduced_data, kmeans.labels_))\n",
+    "\n",
+    "# Построение графиков\n",
+    "plt.figure(figsize=(14, 5))\n",
+    "\n",
+    "# График инерции\n",
+    "plt.subplot(1, 2, 1)\n",
+    "plt.plot(k_range, inertia, marker='o')\n",
+    "plt.title('Критерий инерции')\n",
+    "plt.xlabel('Число кластеров')\n",
+    "plt.ylabel('Инерция')\n",
+    "\n",
+    "# График коэффициента силуэта\n",
+    "plt.subplot(1, 2, 2)\n",
+    "plt.plot(k_range, silhouette_scores, marker='o')\n",
+    "plt.title('Коэффициент силуэта')\n",
+    "plt.xlabel('Число кластеров')\n",
+    "plt.ylabel('Силуэт')\n",
+    "\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "180e85ac",
+   "metadata": {},
+   "source": [
+    "### Кластерный анализ"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "dd573024",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Кластеризация с использованием KMeans\n",
+    "optimal_k = 4  # Выбираем на основе графиков\n",
+    "kmeans = KMeans(n_clusters=optimal_k, random_state=42)\n",
+    "labels = kmeans.fit_predict(reduced_data)\n",
+    "\n",
+    "# Преобразуем данные из cupy в numpy\n",
+    "reduced_data_np = reduced_data.get()\n",
+    "labels_np = labels.get()\n",
+    "\n",
+    "# Визуализация кластеров\n",
+    "plt.scatter(reduced_data_np[:, 0], reduced_data_np[:, 1], c=labels_np, cmap='viridis')\n",
+    "plt.title('Кластеры (KMeans)')\n",
+    "plt.xlabel('PC1')\n",
+    "plt.ylabel('PC2')\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "407d268e",
+   "metadata": {},
+   "source": [
+    "### Оценка качества кластеризации"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "d00795e2",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Силуэт для кластеризации: 0.58\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Оценка коэффициента силуэта\n",
+    "silhouette = silhouette_score(reduced_data, labels)\n",
+    "print(f'Силуэт для кластеризации: {silhouette:.2f}')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7b4aa1da",
+   "metadata": {},
+   "source": [
+    "Получился вплоне неплохой силуэт кластеризации, кластеры хорошо различимы, хоть и имеют пересечение."
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}