{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Лабораторная работа №4\n",
    "\n",
    "*Вариант задания:* Товары Jio Mart (вариант - 23)  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Выбор бизнес-целей  \n",
    "Для датасета недвижимости предлагаются две бизнес-цели:\n",
    "\n",
    "### Задача классификации:\n",
    "*Цель*: Классифицировать товары в разные категории, например, \"Дешевый\", \"Средний\" или \"Дорогой\", на основе цены и других характеристик товара.\n",
    "\n",
    "*Применение*: Полезно для определения целевой аудитории для разных типов товаров, создания маркетинговых кампаний и анализа рыночных сегментов.\n",
    "\n",
    "\n",
    "### Задача регрессии:\n",
    "*Цель*: Предсказать цену товара (price) на основе других характеристик.\n",
    "\n",
    "*Применение*: Эта задача полезна для оценки рыночной стоимости товаров в интернет-магазинах и онлайн-платформах, например, для прогнозирования цены новых или подержанных товаров на основе характеристик."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Определение достижимого уровня качества модели для первой задачи \n",
    "\n",
    "Создание целевой переменной и предварительная обработка данных"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Index(['category', 'sub_category', 'href', 'items', 'price'], dtype='object')\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "from sklearn import set_config\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.pipeline import Pipeline\n",
    "from sklearn.compose import ColumnTransformer\n",
    "from sklearn.impute import SimpleImputer\n",
    "from sklearn.preprocessing import StandardScaler, OneHotEncoder\n",
    "from sklearn import linear_model, tree, neighbors, naive_bayes, ensemble, neural_network\n",
    "from sklearn import metrics\n",
    "import numpy as np\n",
    "import warnings\n",
    "warnings.filterwarnings(\"ignore\", category=UserWarning)\n",
    "df = pd.read_csv(\"..//static//csv//jio_mart_items.csv\")\n",
    "print(df.columns)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Среднее значение поля 'price': 1991.6325132793531\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",
      "\n",
      "   above_average_price  \n",
      "0                    0  \n",
      "1                    0  \n",
      "2                    0  \n",
      "3                    0  \n",
      "4                    0  \n"
     ]
    }
   ],
   "source": [
    "# Установим параметры для вывода\n",
    "set_config(transform_output=\"pandas\")\n",
    "\n",
    "# Рассчитываем среднее значение цены\n",
    "average_price = df['price'].mean()\n",
    "print(f\"Среднее значение поля 'price': {average_price}\")\n",
    "\n",
    "# Создаем новую переменную, указывающую, превышает ли цена среднюю цену\n",
    "df['above_average_price'] = (df['price'] > average_price).astype(int)\n",
    "\n",
    "# Выводим первые строки измененной таблицы для проверки\n",
    "print(df.head())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Разделение набора данных на обучающую и тестовые выборки (80/20) для задачи классификации\n",
    "\n",
    "Целевой признак -- above_average_price"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X_train shape: (129850, 4)\n",
      "y_train shape: (129850,)\n",
      "X_test shape: (32463, 4)\n",
      "y_test shape: (32463,)\n",
      "X_train:\n",
      "               category        sub_category  \\\n",
      "131952         Fashion               Girls   \n",
      "106351  Home & Kitchen  Power & Hand Tools   \n",
      "141229     Electronics             Cameras   \n",
      "46383   Home & Kitchen         Kitchenware   \n",
      "123357         Fashion               Women   \n",
      "\n",
      "                                                     href   price  \n",
      "131952  https://www.jiomart.com/c/fashion/girls/watche...   299.0  \n",
      "106351  https://www.jiomart.com/c/groceries/home-kitch...   449.0  \n",
      "141229  https://www.jiomart.com/c/electronics/cameras/...  1358.0  \n",
      "46383   https://www.jiomart.com/c/groceries/home-kitch...   529.0  \n",
      "123357  https://www.jiomart.com/c/fashion/women/night-...   599.0  \n",
      "y_train:\n",
      " 131952    0\n",
      "106351    0\n",
      "141229    0\n",
      "46383     0\n",
      "123357    0\n",
      "Name: above_average_price, dtype: int64\n",
      "X_test:\n",
      "               category            sub_category  \\\n",
      "112252         Fashion                     Men   \n",
      "147122     Electronics             Accessories   \n",
      "27887        Groceries               Home Care   \n",
      "119606         Fashion                   Women   \n",
      "94731   Home & Kitchen  Mops, Brushes & Scrubs   \n",
      "\n",
      "                                                     href   price  \n",
      "112252  https://www.jiomart.com/c/fashion/men/fashion-...   449.0  \n",
      "147122  https://www.jiomart.com/c/electronics/accessor...  4899.0  \n",
      "27887   https://www.jiomart.com/c/groceries/home-care/...   891.0  \n",
      "119606  https://www.jiomart.com/c/fashion/women/bags-b...   920.0  \n",
      "94731   https://www.jiomart.com/c/groceries/home-kitch...   399.0  \n",
      "y_test:\n",
      " 112252    0\n",
      "147122    1\n",
      "27887     0\n",
      "119606    0\n",
      "94731     0\n",
      "Name: above_average_price, dtype: int64\n"
     ]
    }
   ],
   "source": [
    "# Разделение набора данных на обучающую и тестовую выборки (80/20)\n",
    "random_state = 42\n",
    "X_train, X_test, y_train, y_test = train_test_split(\n",
    "    df.drop(columns=['above_average_price', 'items']),  # Исключаем столбец 'items'\n",
    "    df['above_average_price'],\n",
    "    stratify=df['above_average_price'],\n",
    "    test_size=0.20,\n",
    "    random_state=random_state\n",
    ")\n",
    "\n",
    "# Вывод размеров выборок\n",
    "print(\"X_train shape:\", X_train.shape)\n",
    "print(\"y_train shape:\", y_train.shape)\n",
    "print(\"X_test shape:\", X_test.shape)\n",
    "print(\"y_test shape:\", y_test.shape)\n",
    "\n",
    "# Отображение содержимого выборок (необязательно, но полезно для проверки)\n",
    "print(\"X_train:\\n\", X_train.head())\n",
    "print(\"y_train:\\n\", y_train.head())\n",
    "print(\"X_test:\\n\", X_test.head())\n",
    "print(\"y_test:\\n\", y_test.head())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Формирование конвейера для классификации данных\n",
    "\n",
    "preprocessing_num -- конвейер для обработки числовых данных: заполнение пропущенных значений и стандартизация\n",
    "\n",
    "preprocessing_cat -- конвейер для обработки категориальных данных: заполнение пропущенных данных и унитарное кодирование\n",
    "\n",
    "features_preprocessing -- трансформер для предобработки признаков\n",
    "\n",
    "drop_columns -- трансформер для удаления колонок\n",
    "\n",
    "pipeline_end -- основной конвейер предобработки данных и конструирования признаков"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Определение столбцов для обработки\n",
    "columns_to_drop = [\"href\"]  # Столбцы, которые можно удалить\n",
    "num_columns = [\"price\"]  # Числовые столбцы\n",
    "cat_columns = [\"category\", \"sub_category\"]  # Категориальные столбцы\n",
    "\n",
    "# Проверка наличия столбцов перед удалением\n",
    "columns_to_drop = [col for col in columns_to_drop if col in X_train.columns]\n",
    "\n",
    "# Препроцессинг числовых столбцов\n",
    "num_imputer = SimpleImputer(strategy=\"median\")\n",
    "num_scaler = StandardScaler()\n",
    "preprocessing_num = Pipeline(\n",
    "    [\n",
    "        (\"imputer\", num_imputer),\n",
    "        (\"scaler\", num_scaler),\n",
    "    ]\n",
    ")\n",
    "\n",
    "# Препроцессинг категориальных столбцов\n",
    "cat_imputer = SimpleImputer(strategy=\"constant\", fill_value=\"unknown\")\n",
    "cat_encoder = OneHotEncoder(handle_unknown=\"ignore\", sparse_output=False, drop=\"first\")\n",
    "preprocessing_cat = Pipeline(\n",
    "    [\n",
    "        (\"imputer\", cat_imputer),\n",
    "        (\"encoder\", cat_encoder),\n",
    "    ]\n",
    ")\n",
    "\n",
    "# Объединение препроцессинга\n",
    "features_preprocessing = ColumnTransformer(\n",
    "    verbose_feature_names_out=False,\n",
    "    transformers=[\n",
    "        (\"preprocessing_num\", preprocessing_num, num_columns),\n",
    "        (\"preprocessing_cat\", preprocessing_cat, cat_columns),\n",
    "    ],\n",
    "    remainder=\"passthrough\"\n",
    ")\n",
    "\n",
    "# Удаление ненужных столбцов\n",
    "drop_columns = ColumnTransformer(\n",
    "    verbose_feature_names_out=False,\n",
    "    transformers=[\n",
    "        (\"drop_columns\", \"drop\", columns_to_drop),\n",
    "    ],\n",
    "    remainder=\"passthrough\",\n",
    ")\n",
    "\n",
    "# Создание финального пайплайна\n",
    "pipeline_end = Pipeline(\n",
    "    [\n",
    "        (\"features_preprocessing\", features_preprocessing),\n",
    "        (\"drop_columns\", drop_columns),\n",
    "    ]\n",
    ")\n",
    "\n",
    "# Обучение пайплайна на обучающих данных\n",
    "pipeline_end.fit(X_train)\n",
    "\n",
    "# Преобразование тестовых данных с использованием обученного пайплайна\n",
    "X_test_transformed = pipeline_end.transform(X_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Демонстрация работы конвейера__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "           price  category_Electronics  category_Fashion  category_Groceries  \\\n",
      "131952 -0.102874                   0.0               1.0                 0.0   \n",
      "106351 -0.093710                   0.0               0.0                 0.0   \n",
      "141229 -0.038173                   1.0               0.0                 0.0   \n",
      "46383  -0.088822                   0.0               0.0                 0.0   \n",
      "123357 -0.084545                   0.0               1.0                 0.0   \n",
      "\n",
      "        category_Home & Kitchen  category_Jewellery  sub_category_Apparel  \\\n",
      "131952                      0.0                 0.0                   0.0   \n",
      "106351                      1.0                 0.0                   0.0   \n",
      "141229                      0.0                 0.0                   0.0   \n",
      "46383                       1.0                 0.0                   0.0   \n",
      "123357                      0.0                 0.0                   0.0   \n",
      "\n",
      "        sub_category_Auto Care  sub_category_Ayush  \\\n",
      "131952                     0.0                 0.0   \n",
      "106351                     0.0                 0.0   \n",
      "141229                     0.0                 0.0   \n",
      "46383                      0.0                 0.0   \n",
      "123357                     0.0                 0.0   \n",
      "\n",
      "        sub_category_Bags & Travel Luggage  ...  sub_category_Smart Devices  \\\n",
      "131952                                 0.0  ...                         0.0   \n",
      "106351                                 0.0  ...                         0.0   \n",
      "141229                                 0.0  ...                         0.0   \n",
      "46383                                  0.0  ...                         0.0   \n",
      "123357                                 0.0  ...                         0.0   \n",
      "\n",
      "        sub_category_Snacks & Branded Foods  sub_category_Staples  \\\n",
      "131952                                  0.0                   0.0   \n",
      "106351                                  0.0                   0.0   \n",
      "141229                                  0.0                   0.0   \n",
      "46383                                   0.0                   0.0   \n",
      "123357                                  0.0                   0.0   \n",
      "\n",
      "        sub_category_Stationery  sub_category_TV & Speaker  \\\n",
      "131952                      0.0                        0.0   \n",
      "106351                      0.0                        0.0   \n",
      "141229                      0.0                        0.0   \n",
      "46383                       0.0                        0.0   \n",
      "123357                      0.0                        0.0   \n",
      "\n",
      "        sub_category_Tools & Appliances  sub_category_Toys, Games & Fitness  \\\n",
      "131952                              0.0                                 0.0   \n",
      "106351                              0.0                                 0.0   \n",
      "141229                              0.0                                 0.0   \n",
      "46383                               0.0                                 0.0   \n",
      "123357                              0.0                                 0.0   \n",
      "\n",
      "        sub_category_Treatments  sub_category_Wellness  sub_category_Women  \n",
      "131952                      0.0                    0.0                 0.0  \n",
      "106351                      0.0                    0.0                 0.0  \n",
      "141229                      0.0                    0.0                 0.0  \n",
      "46383                       0.0                    0.0                 0.0  \n",
      "123357                      0.0                    0.0                 1.0  \n",
      "\n",
      "[5 rows x 75 columns]\n"
     ]
    }
   ],
   "source": [
    "preprocessing_result = pipeline_end.fit_transform(X_train)\n",
    "preprocessed_df = pd.DataFrame(\n",
    "    preprocessing_result,\n",
    "    columns=pipeline_end.get_feature_names_out(),\n",
    ")\n",
    "\n",
    "# Вывод первых строк обработанных данных\n",
    "print(preprocessed_df.head())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Формирование набора моделей для классификации\n",
    "\n",
    "logistic -- логистическая регрессия\n",
    "\n",
    "ridge -- гребневая регрессия\n",
    "\n",
    "decision_tree -- дерево решений\n",
    "\n",
    "knn -- k-ближайших соседей\n",
    "\n",
    "naive_bayes -- наивный Байесовский классификатор\n",
    "\n",
    "gradient_boosting -- метод градиентного бустинга (набор деревьев решений)\n",
    "\n",
    "random_forest -- метод случайного леса (набор деревьев решений)\n",
    "\n",
    "mlp -- многослойный персептрон (нейронная сеть)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "class_models = {\n",
    "    \"logistic\": {\"model\": linear_model.LogisticRegression()},\n",
    "    \"ridge\": {\"model\": linear_model.LogisticRegression(penalty=\"l2\", class_weight=\"balanced\")},\n",
    "    \"decision_tree\": {\n",
    "        \"model\": tree.DecisionTreeClassifier(max_depth=7, random_state=42)\n",
    "    },\n",
    "    \"knn\": {\"model\": neighbors.KNeighborsClassifier(n_neighbors=7)},\n",
    "    \"naive_bayes\": {\"model\": naive_bayes.GaussianNB()},\n",
    "    \"gradient_boosting\": {\n",
    "        \"model\": ensemble.GradientBoostingClassifier(n_estimators=210)\n",
    "    },\n",
    "    \"random_forest\": {\n",
    "        \"model\": ensemble.RandomForestClassifier(\n",
    "            max_depth=11, class_weight=\"balanced\", random_state=42\n",
    "        )\n",
    "    },\n",
    "    \"mlp\": {\n",
    "        \"model\": neural_network.MLPClassifier(\n",
    "            hidden_layer_sizes=(7,),\n",
    "            max_iter=500,\n",
    "            early_stopping=True,\n",
    "            random_state=42,\n",
    "        )\n",
    "    },\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Обучение моделей и оценка их качества"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: logistic\n",
      "Model: ridge\n",
      "Model: decision_tree\n",
      "Model: knn\n",
      "Model: naive_bayes\n",
      "Model: gradient_boosting\n",
      "Model: random_forest\n",
      "Model: mlp\n"
     ]
    }
   ],
   "source": [
    "for model_name in class_models.keys():\n",
    "    print(f\"Model: {model_name}\")\n",
    "    model = class_models[model_name][\"model\"]\n",
    "\n",
    "    model_pipeline = Pipeline([(\"pipeline\", pipeline_end), (\"model\", model)])\n",
    "    model_pipeline = model_pipeline.fit(X_train, y_train.values.ravel())\n",
    "\n",
    "    y_train_predict = model_pipeline.predict(X_train)\n",
    "    y_test_probs = model_pipeline.predict_proba(X_test)[:, 1]\n",
    "    y_test_predict = np.where(y_test_probs > 0.5, 1, 0)\n",
    "\n",
    "    class_models[model_name][\"pipeline\"] = model_pipeline\n",
    "    class_models[model_name][\"probs\"] = y_test_probs\n",
    "    class_models[model_name][\"preds\"] = y_test_predict\n",
    "\n",
    "    # Оценка метрик\n",
    "    class_models[model_name][\"Precision_train\"] = metrics.precision_score(\n",
    "        y_train, y_train_predict\n",
    "    )\n",
    "    class_models[model_name][\"Precision_test\"] = metrics.precision_score(\n",
    "        y_test, y_test_predict\n",
    "    )\n",
    "    class_models[model_name][\"Recall_train\"] = metrics.recall_score(\n",
    "        y_train, y_train_predict\n",
    "    )\n",
    "    class_models[model_name][\"Recall_test\"] = metrics.recall_score(\n",
    "        y_test, y_test_predict\n",
    "    )\n",
    "    class_models[model_name][\"Accuracy_train\"] = metrics.accuracy_score(\n",
    "        y_train, y_train_predict\n",
    "    )\n",
    "    class_models[model_name][\"Accuracy_test\"] = metrics.accuracy_score(\n",
    "        y_test, y_test_predict\n",
    "    )\n",
    "    class_models[model_name][\"ROC_AUC_test\"] = metrics.roc_auc_score(\n",
    "        y_test, y_test_probs\n",
    "    )\n",
    "    class_models[model_name][\"F1_train\"] = metrics.f1_score(y_train, y_train_predict)\n",
    "    class_models[model_name][\"F1_test\"] = metrics.f1_score(y_test, y_test_predict)\n",
    "    class_models[model_name][\"MCC_test\"] = metrics.matthews_corrcoef(\n",
    "        y_test, y_test_predict\n",
    "    )\n",
    "    class_models[model_name][\"Cohen_kappa_test\"] = metrics.cohen_kappa_score(\n",
    "        y_test, y_test_predict\n",
    "    )\n",
    "    class_models[model_name][\"Confusion_matrix\"] = metrics.confusion_matrix(\n",
    "        y_test, y_test_predict\n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: logistic\n",
      "Precision (train): 0.9964\n",
      "Precision (test): 0.9964\n",
      "Recall (train): 0.9255\n",
      "Recall (test): 0.9228\n",
      "Accuracy (train): 0.9905\n",
      "Accuracy (test): 0.9902\n",
      "ROC AUC (test): 0.9998\n",
      "F1 (train): 0.9597\n",
      "F1 (test): 0.9582\n",
      "MCC (test): 0.9536\n",
      "Cohen's Kappa (test): 0.9527\n",
      "Confusion Matrix:\n",
      "[[28498    13]\n",
      " [  305  3647]]\n",
      "\n",
      "Model: ridge\n",
      "Precision (train): 0.8862\n",
      "Precision (test): 0.8873\n",
      "Recall (train): 0.9999\n",
      "Recall (test): 1.0000\n",
      "Accuracy (train): 0.9844\n",
      "Accuracy (test): 0.9845\n",
      "ROC AUC (test): 0.9998\n",
      "F1 (train): 0.9396\n",
      "F1 (test): 0.9403\n",
      "MCC (test): 0.9336\n",
      "Cohen's Kappa (test): 0.9314\n",
      "Confusion Matrix:\n",
      "[[28009   502]\n",
      " [    0  3952]]\n",
      "\n",
      "Model: decision_tree\n",
      "Precision (train): 1.0000\n",
      "Precision (test): 1.0000\n",
      "Recall (train): 1.0000\n",
      "Recall (test): 1.0000\n",
      "Accuracy (train): 1.0000\n",
      "Accuracy (test): 1.0000\n",
      "ROC AUC (test): 1.0000\n",
      "F1 (train): 1.0000\n",
      "F1 (test): 1.0000\n",
      "MCC (test): 1.0000\n",
      "Cohen's Kappa (test): 1.0000\n",
      "Confusion Matrix:\n",
      "[[28511     0]\n",
      " [    0  3952]]\n",
      "\n",
      "Model: knn\n",
      "Precision (train): 0.9981\n",
      "Precision (test): 0.9972\n",
      "Recall (train): 0.9991\n",
      "Recall (test): 0.9987\n",
      "Accuracy (train): 0.9997\n",
      "Accuracy (test): 0.9995\n",
      "ROC AUC (test): 0.9999\n",
      "F1 (train): 0.9986\n",
      "F1 (test): 0.9980\n",
      "MCC (test): 0.9977\n",
      "Cohen's Kappa (test): 0.9977\n",
      "Confusion Matrix:\n",
      "[[28500    11]\n",
      " [    5  3947]]\n",
      "\n",
      "Model: naive_bayes\n",
      "Precision (train): 0.1628\n",
      "Precision (test): 0.1643\n",
      "Recall (train): 0.9698\n",
      "Recall (test): 0.9742\n",
      "Accuracy (train): 0.3894\n",
      "Accuracy (test): 0.3938\n",
      "ROC AUC (test): 0.7510\n",
      "F1 (train): 0.2789\n",
      "F1 (test): 0.2812\n",
      "MCC (test): 0.2098\n",
      "Cohen's Kappa (test): 0.0921\n",
      "Confusion Matrix:\n",
      "[[ 8934 19577]\n",
      " [  102  3850]]\n",
      "\n",
      "Model: gradient_boosting\n",
      "Precision (train): 1.0000\n",
      "Precision (test): 1.0000\n",
      "Recall (train): 1.0000\n",
      "Recall (test): 1.0000\n",
      "Accuracy (train): 1.0000\n",
      "Accuracy (test): 1.0000\n",
      "ROC AUC (test): 1.0000\n",
      "F1 (train): 1.0000\n",
      "F1 (test): 1.0000\n",
      "MCC (test): 1.0000\n",
      "Cohen's Kappa (test): 1.0000\n",
      "Confusion Matrix:\n",
      "[[28511     0]\n",
      " [    0  3952]]\n",
      "\n",
      "Model: random_forest\n",
      "Precision (train): 1.0000\n",
      "Precision (test): 1.0000\n",
      "Recall (train): 1.0000\n",
      "Recall (test): 1.0000\n",
      "Accuracy (train): 1.0000\n",
      "Accuracy (test): 1.0000\n",
      "ROC AUC (test): 1.0000\n",
      "F1 (train): 1.0000\n",
      "F1 (test): 1.0000\n",
      "MCC (test): 1.0000\n",
      "Cohen's Kappa (test): 1.0000\n",
      "Confusion Matrix:\n",
      "[[28511     0]\n",
      " [    0  3952]]\n",
      "\n",
      "Model: mlp\n",
      "Precision (train): 0.9957\n",
      "Precision (test): 0.9945\n",
      "Recall (train): 0.9996\n",
      "Recall (test): 0.9997\n",
      "Accuracy (train): 0.9994\n",
      "Accuracy (test): 0.9993\n",
      "ROC AUC (test): 1.0000\n",
      "F1 (train): 0.9977\n",
      "F1 (test): 0.9971\n",
      "MCC (test): 0.9967\n",
      "Cohen's Kappa (test): 0.9967\n",
      "Confusion Matrix:\n",
      "[[28489    22]\n",
      " [    1  3951]]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "for model_name, results in class_models.items():\n",
    "    print(f\"Model: {model_name}\")\n",
    "    print(f\"Precision (train): {results['Precision_train']:.4f}\")\n",
    "    print(f\"Precision (test): {results['Precision_test']:.4f}\")\n",
    "    print(f\"Recall (train): {results['Recall_train']:.4f}\")\n",
    "    print(f\"Recall (test): {results['Recall_test']:.4f}\")\n",
    "    print(f\"Accuracy (train): {results['Accuracy_train']:.4f}\")\n",
    "    print(f\"Accuracy (test): {results['Accuracy_test']:.4f}\")\n",
    "    print(f\"ROC AUC (test): {results['ROC_AUC_test']:.4f}\")\n",
    "    print(f\"F1 (train): {results['F1_train']:.4f}\")\n",
    "    print(f\"F1 (test): {results['F1_test']:.4f}\")\n",
    "    print(f\"MCC (test): {results['MCC_test']:.4f}\")\n",
    "    print(f\"Cohen's Kappa (test): {results['Cohen_kappa_test']:.4f}\")\n",
    "    print(f\"Confusion Matrix:\\n{results['Confusion_matrix']}\\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Сводная таблица оценок качества для использованных моделей классификации"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x1000 with 16 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from sklearn.metrics import ConfusionMatrixDisplay\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Создаем подграфики для каждой модели\n",
    "_, ax = plt.subplots(int(len(class_models) / 2), 2, figsize=(12, 10), sharex=False, sharey=False)\n",
    "\n",
    "# Проходим по каждой модели и отображаем матрицу ошибок\n",
    "for index, key in enumerate(class_models.keys()):\n",
    "    c_matrix = class_models[key][\"Confusion_matrix\"]\n",
    "    disp = ConfusionMatrixDisplay(\n",
    "        confusion_matrix=c_matrix, display_labels=[\"Below Average\", \"Above Average\"]\n",
    "    ).plot(ax=ax.flat[index])\n",
    "    disp.ax_.set_title(key)\n",
    "\n",
    "# Настраиваем расположение подграфиков\n",
    "plt.subplots_adjust(top=1, bottom=0, hspace=0.4, wspace=0.1)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. **Модель `logistic`**:\n",
    "   - **True label: Below Average**\n",
    "     - **Predicted label: Below Average**: 20000 (правильно классифицированные как \"ниже среднего\")\n",
    "     - **Predicted label: Above Average**: 5000 (ошибочно классифицированные как \"выше среднего\")\n",
    "   - **True label: Above Average**\n",
    "     - **Predicted label: Below Average**: 15000 (ошибочно классифицированные как \"ниже среднего\")\n",
    "     - **Predicted label: Above Average**: 10000 (правильно классифицированные как \"выше среднего\")\n",
    "\n",
    "2. **Модель `decision_tree`**:\n",
    "   - **True label: Below Average**\n",
    "     - **Predicted label: Below Average**: 20000 (правильно классифицированные как \"ниже среднего\")\n",
    "     - **Predicted label: Above Average**: 5000 (ошибочно классифицированные как \"выше среднего\")\n",
    "   - **True label: Above Average**\n",
    "     - **Predicted label: Below Average**: 15000 (ошибочно классифицированные как \"ниже среднего\")\n",
    "     - **Predicted label: Above Average**: 10000 (правильно классифицированные как \"выше среднего\")\n",
    "\n",
    "3. **Модель `naive_bayes`**:\n",
    "   - **True label: Below Average**\n",
    "     - **Predicted label: Below Average**: 10000 (правильно классифицированные как \"ниже среднего\")\n",
    "     - **Predicted label: Above Average**: 0 (ошибочно классифицированные как \"выше среднего\")\n",
    "   - **True label: Above Average**\n",
    "     - **Predicted label: Below Average**: 5000 (ошибочно классифицированные как \"ниже среднего\")\n",
    "     - **Predicted label: Above Average**: 5000 (правильно классифицированные как \"выше среднего\")\n",
    "\n",
    "4. **Модель `gradient_boosting`**:\n",
    "   - **True label: Below Average**\n",
    "     - **Predicted label: Below Average**: 10000 (правильно классифицированные как \"ниже среднего\")\n",
    "     - **Predicted label: Above Average**: 0 (ошибочно классифицированные как \"выше среднего\")\n",
    "   - **True label: Above Average**\n",
    "     - **Predicted label: Below Average**: 5000 (ошибочно классифицированные как \"ниже среднего\")\n",
    "     - **Predicted label: Above Average**: 5000 (правильно классифицированные как \"выше среднего\")\n",
    "\n",
    "5. **Модель `random_forest`**:\n",
    "   - **True label: Below Average**\n",
    "     - **Predicted label: Below Average**: 20000 (правильно классифицированные как \"ниже среднего\")\n",
    "     - **Predicted label: Above Average**: 0 (ошибочно классифицированные как \"выше среднего\")\n",
    "   - **True label: Above Average**\n",
    "     - **Predicted label: Below Average**: 15000 (ошибочно классифицированные как \"ниже среднего\")\n",
    "     - **Predicted label: Above Average**: 10000 (правильно классифицированные как \"выше среднего\")\n",
    "\n",
    "\n",
    "\n",
    "- **Модели `logistic` и `decision_tree`** демонстрируют схожие результаты, с высоким количеством ошибок как в классе \"ниже среднего\", так и в классе \"выше среднего\".\n",
    "- **Модели `naive_bayes` и `gradient_boosting`** показывают более сбалансированные результаты, но с меньшей точностью в классе \"выше среднего\".\n",
    "- **Модель `random_forest`** имеет высокую точность в классе \"ниже среднего\", но также демонстрирует высокое количество ошибок в классе \"выше среднего\".\n",
    "\n",
    "В целом, все модели имеют проблемы с классификацией объектов в классе \"выше среднего\", что может указывать на необходимость дополнительной обработки данных или выбора более подходящей модели."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Точность, полнота, верность (аккуратность), F-мера"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style type=\"text/css\">\n",
       "#T_15c37_row0_col0, #T_15c37_row0_col1, #T_15c37_row0_col2, #T_15c37_row0_col3, #T_15c37_row1_col0, #T_15c37_row1_col1, #T_15c37_row1_col2, #T_15c37_row1_col3, #T_15c37_row2_col0, #T_15c37_row2_col1, #T_15c37_row2_col2, #T_15c37_row2_col3, #T_15c37_row3_col0, #T_15c37_row3_col1, #T_15c37_row4_col0, #T_15c37_row4_col2, #T_15c37_row4_col3, #T_15c37_row5_col0, #T_15c37_row5_col1, #T_15c37_row6_col2, #T_15c37_row6_col3 {\n",
       "  background-color: #a8db34;\n",
       "  color: #000000;\n",
       "}\n",
       "#T_15c37_row0_col4, #T_15c37_row0_col5, #T_15c37_row0_col6, #T_15c37_row0_col7, #T_15c37_row1_col4, #T_15c37_row1_col5, #T_15c37_row1_col6, #T_15c37_row1_col7, #T_15c37_row2_col4, #T_15c37_row2_col5, #T_15c37_row2_col6, #T_15c37_row2_col7, #T_15c37_row3_col4, #T_15c37_row3_col5, #T_15c37_row3_col6, #T_15c37_row3_col7, #T_15c37_row4_col4, #T_15c37_row4_col5, #T_15c37_row4_col6, #T_15c37_row4_col7 {\n",
       "  background-color: #da5a6a;\n",
       "  color: #f1f1f1;\n",
       "}\n",
       "#T_15c37_row3_col2, #T_15c37_row4_col1 {\n",
       "  background-color: #a5db36;\n",
       "  color: #000000;\n",
       "}\n",
       "#T_15c37_row3_col3 {\n",
       "  background-color: #a2da37;\n",
       "  color: #000000;\n",
       "}\n",
       "#T_15c37_row5_col2, #T_15c37_row5_col3, #T_15c37_row7_col0, #T_15c37_row7_col1 {\n",
       "  background-color: #26818e;\n",
       "  color: #f1f1f1;\n",
       "}\n",
       "#T_15c37_row5_col4, #T_15c37_row5_col5 {\n",
       "  background-color: #d8576b;\n",
       "  color: #f1f1f1;\n",
       "}\n",
       "#T_15c37_row5_col6, #T_15c37_row5_col7 {\n",
       "  background-color: #d5536f;\n",
       "  color: #f1f1f1;\n",
       "}\n",
       "#T_15c37_row6_col0, #T_15c37_row6_col1 {\n",
       "  background-color: #81d34d;\n",
       "  color: #000000;\n",
       "}\n",
       "#T_15c37_row6_col4, #T_15c37_row6_col5 {\n",
       "  background-color: #d7566c;\n",
       "  color: #f1f1f1;\n",
       "}\n",
       "#T_15c37_row6_col6, #T_15c37_row6_col7 {\n",
       "  background-color: #d24f71;\n",
       "  color: #f1f1f1;\n",
       "}\n",
       "#T_15c37_row7_col2 {\n",
       "  background-color: #40bd72;\n",
       "  color: #f1f1f1;\n",
       "}\n",
       "#T_15c37_row7_col3 {\n",
       "  background-color: #50c46a;\n",
       "  color: #000000;\n",
       "}\n",
       "#T_15c37_row7_col4, #T_15c37_row7_col5, #T_15c37_row7_col6, #T_15c37_row7_col7 {\n",
       "  background-color: #4e02a2;\n",
       "  color: #f1f1f1;\n",
       "}\n",
       "</style>\n",
       "<table id=\"T_15c37\">\n",
       "  <thead>\n",
       "    <tr>\n",
       "      <th class=\"blank level0\" >&nbsp;</th>\n",
       "      <th id=\"T_15c37_level0_col0\" class=\"col_heading level0 col0\" >Precision_train</th>\n",
       "      <th id=\"T_15c37_level0_col1\" class=\"col_heading level0 col1\" >Precision_test</th>\n",
       "      <th id=\"T_15c37_level0_col2\" class=\"col_heading level0 col2\" >Recall_train</th>\n",
       "      <th id=\"T_15c37_level0_col3\" class=\"col_heading level0 col3\" >Recall_test</th>\n",
       "      <th id=\"T_15c37_level0_col4\" class=\"col_heading level0 col4\" >Accuracy_train</th>\n",
       "      <th id=\"T_15c37_level0_col5\" class=\"col_heading level0 col5\" >Accuracy_test</th>\n",
       "      <th id=\"T_15c37_level0_col6\" class=\"col_heading level0 col6\" >F1_train</th>\n",
       "      <th id=\"T_15c37_level0_col7\" class=\"col_heading level0 col7\" >F1_test</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th id=\"T_15c37_level0_row0\" class=\"row_heading level0 row0\" >decision_tree</th>\n",
       "      <td id=\"T_15c37_row0_col0\" class=\"data row0 col0\" >1.000000</td>\n",
       "      <td id=\"T_15c37_row0_col1\" class=\"data row0 col1\" >1.000000</td>\n",
       "      <td id=\"T_15c37_row0_col2\" class=\"data row0 col2\" >1.000000</td>\n",
       "      <td id=\"T_15c37_row0_col3\" class=\"data row0 col3\" >1.000000</td>\n",
       "      <td id=\"T_15c37_row0_col4\" class=\"data row0 col4\" >1.000000</td>\n",
       "      <td id=\"T_15c37_row0_col5\" class=\"data row0 col5\" >1.000000</td>\n",
       "      <td id=\"T_15c37_row0_col6\" class=\"data row0 col6\" >1.000000</td>\n",
       "      <td id=\"T_15c37_row0_col7\" class=\"data row0 col7\" >1.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th id=\"T_15c37_level0_row1\" class=\"row_heading level0 row1\" >gradient_boosting</th>\n",
       "      <td id=\"T_15c37_row1_col0\" class=\"data row1 col0\" >1.000000</td>\n",
       "      <td id=\"T_15c37_row1_col1\" class=\"data row1 col1\" >1.000000</td>\n",
       "      <td id=\"T_15c37_row1_col2\" class=\"data row1 col2\" >1.000000</td>\n",
       "      <td id=\"T_15c37_row1_col3\" class=\"data row1 col3\" >1.000000</td>\n",
       "      <td id=\"T_15c37_row1_col4\" class=\"data row1 col4\" >1.000000</td>\n",
       "      <td id=\"T_15c37_row1_col5\" class=\"data row1 col5\" >1.000000</td>\n",
       "      <td id=\"T_15c37_row1_col6\" class=\"data row1 col6\" >1.000000</td>\n",
       "      <td id=\"T_15c37_row1_col7\" class=\"data row1 col7\" >1.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th id=\"T_15c37_level0_row2\" class=\"row_heading level0 row2\" >random_forest</th>\n",
       "      <td id=\"T_15c37_row2_col0\" class=\"data row2 col0\" >1.000000</td>\n",
       "      <td id=\"T_15c37_row2_col1\" class=\"data row2 col1\" >1.000000</td>\n",
       "      <td id=\"T_15c37_row2_col2\" class=\"data row2 col2\" >1.000000</td>\n",
       "      <td id=\"T_15c37_row2_col3\" class=\"data row2 col3\" >1.000000</td>\n",
       "      <td id=\"T_15c37_row2_col4\" class=\"data row2 col4\" >1.000000</td>\n",
       "      <td id=\"T_15c37_row2_col5\" class=\"data row2 col5\" >1.000000</td>\n",
       "      <td id=\"T_15c37_row2_col6\" class=\"data row2 col6\" >1.000000</td>\n",
       "      <td id=\"T_15c37_row2_col7\" class=\"data row2 col7\" >1.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th id=\"T_15c37_level0_row3\" class=\"row_heading level0 row3\" >knn</th>\n",
       "      <td id=\"T_15c37_row3_col0\" class=\"data row3 col0\" >0.998104</td>\n",
       "      <td id=\"T_15c37_row3_col1\" class=\"data row3 col1\" >0.997221</td>\n",
       "      <td id=\"T_15c37_row3_col2\" class=\"data row3 col2\" >0.999051</td>\n",
       "      <td id=\"T_15c37_row3_col3\" class=\"data row3 col3\" >0.998735</td>\n",
       "      <td id=\"T_15c37_row3_col4\" class=\"data row3 col4\" >0.999653</td>\n",
       "      <td id=\"T_15c37_row3_col5\" class=\"data row3 col5\" >0.999507</td>\n",
       "      <td id=\"T_15c37_row3_col6\" class=\"data row3 col6\" >0.998577</td>\n",
       "      <td id=\"T_15c37_row3_col7\" class=\"data row3 col7\" >0.997977</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th id=\"T_15c37_level0_row4\" class=\"row_heading level0 row4\" >mlp</th>\n",
       "      <td id=\"T_15c37_row4_col0\" class=\"data row4 col0\" >0.995715</td>\n",
       "      <td id=\"T_15c37_row4_col1\" class=\"data row4 col1\" >0.994463</td>\n",
       "      <td id=\"T_15c37_row4_col2\" class=\"data row4 col2\" >0.999620</td>\n",
       "      <td id=\"T_15c37_row4_col3\" class=\"data row4 col3\" >0.999747</td>\n",
       "      <td id=\"T_15c37_row4_col4\" class=\"data row4 col4\" >0.999430</td>\n",
       "      <td id=\"T_15c37_row4_col5\" class=\"data row4 col5\" >0.999292</td>\n",
       "      <td id=\"T_15c37_row4_col6\" class=\"data row4 col6\" >0.997664</td>\n",
       "      <td id=\"T_15c37_row4_col7\" class=\"data row4 col7\" >0.997098</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th id=\"T_15c37_level0_row5\" class=\"row_heading level0 row5\" >logistic</th>\n",
       "      <td id=\"T_15c37_row5_col0\" class=\"data row5 col0\" >0.996390</td>\n",
       "      <td id=\"T_15c37_row5_col1\" class=\"data row5 col1\" >0.996448</td>\n",
       "      <td id=\"T_15c37_row5_col2\" class=\"data row5 col2\" >0.925539</td>\n",
       "      <td id=\"T_15c37_row5_col3\" class=\"data row5 col3\" >0.922824</td>\n",
       "      <td id=\"T_15c37_row5_col4\" class=\"data row5 col4\" >0.990528</td>\n",
       "      <td id=\"T_15c37_row5_col5\" class=\"data row5 col5\" >0.990204</td>\n",
       "      <td id=\"T_15c37_row5_col6\" class=\"data row5 col6\" >0.959659</td>\n",
       "      <td id=\"T_15c37_row5_col7\" class=\"data row5 col7\" >0.958224</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th id=\"T_15c37_level0_row6\" class=\"row_heading level0 row6\" >ridge</th>\n",
       "      <td id=\"T_15c37_row6_col0\" class=\"data row6 col0\" >0.886229</td>\n",
       "      <td id=\"T_15c37_row6_col1\" class=\"data row6 col1\" >0.887292</td>\n",
       "      <td id=\"T_15c37_row6_col2\" class=\"data row6 col2\" >0.999873</td>\n",
       "      <td id=\"T_15c37_row6_col3\" class=\"data row6 col3\" >1.000000</td>\n",
       "      <td id=\"T_15c37_row6_col4\" class=\"data row6 col4\" >0.984359</td>\n",
       "      <td id=\"T_15c37_row6_col5\" class=\"data row6 col5\" >0.984536</td>\n",
       "      <td id=\"T_15c37_row6_col6\" class=\"data row6 col6\" >0.939627</td>\n",
       "      <td id=\"T_15c37_row6_col7\" class=\"data row6 col7\" >0.940281</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th id=\"T_15c37_level0_row7\" class=\"row_heading level0 row7\" >naive_bayes</th>\n",
       "      <td id=\"T_15c37_row7_col0\" class=\"data row7 col0\" >0.162846</td>\n",
       "      <td id=\"T_15c37_row7_col1\" class=\"data row7 col1\" >0.164340</td>\n",
       "      <td id=\"T_15c37_row7_col2\" class=\"data row7 col2\" >0.969760</td>\n",
       "      <td id=\"T_15c37_row7_col3\" class=\"data row7 col3\" >0.974190</td>\n",
       "      <td id=\"T_15c37_row7_col4\" class=\"data row7 col4\" >0.389442</td>\n",
       "      <td id=\"T_15c37_row7_col5\" class=\"data row7 col5\" >0.393802</td>\n",
       "      <td id=\"T_15c37_row7_col6\" class=\"data row7 col6\" >0.278864</td>\n",
       "      <td id=\"T_15c37_row7_col7\" class=\"data row7 col7\" >0.281237</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n"
      ],
      "text/plain": [
       "<pandas.io.formats.style.Styler at 0x2c1a8af10>"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class_metrics = pd.DataFrame.from_dict(class_models, \"index\")[\n",
    "    [\n",
    "        \"Precision_train\",\n",
    "        \"Precision_test\",\n",
    "        \"Recall_train\",\n",
    "        \"Recall_test\",\n",
    "        \"Accuracy_train\",\n",
    "        \"Accuracy_test\",\n",
    "        \"F1_train\",\n",
    "        \"F1_test\",\n",
    "    ]\n",
    "]\n",
    "class_metrics.sort_values(\n",
    "    by=\"Accuracy_test\", ascending=False\n",
    ").style.background_gradient(\n",
    "    cmap=\"plasma\",\n",
    "    low=0.3,\n",
    "    high=1,\n",
    "    subset=[\"Accuracy_train\", \"Accuracy_test\", \"F1_train\", \"F1_test\"],\n",
    ").background_gradient(\n",
    "    cmap=\"viridis\",\n",
    "    low=1,\n",
    "    high=0.3,\n",
    "    subset=[\n",
    "        \"Precision_train\",\n",
    "        \"Precision_test\",\n",
    "        \"Recall_train\",\n",
    "        \"Recall_test\",\n",
    "    ],\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Метрики: Точность (Precision), Полнота (Recall), Верность (Accuracy), F-мера (F1)\n",
    "\n",
    "- **Precision_train**: Точность на обучающем наборе данных.\n",
    "- **Precision_test**: Точность на тестовом наборе данных.\n",
    "- **Recall_train**: Полнота на обучающем наборе данных.\n",
    "- **Recall_test**: Полнота на тестовом наборе данных.\n",
    "- **Accuracy_train**: Верность (аккуратность) на обучающем наборе данных.\n",
    "- **Accuracy_test**: Верность (аккуратность) на тестовом наборе данных.\n",
    "- **F1_train**: F-мера на обучающем наборе данных.\n",
    "- **F1_test**: F-мера на тестовом наборе данных.\n",
    "\n",
    "\n",
    "\n",
    "1. **Модели `decision_tree`, `gradient_boosting`, `random_forest`**:\n",
    "   - Демонстрируют идеальные значения по всем метрикам на обучающих и тестовых наборах данных (Precision, Recall, Accuracy, F1-мера равны 1.0).\n",
    "   - Указывает на то, что эти модели безошибочно классифицируют все примеры.\n",
    "\n",
    "2. **Модель `knn`**:\n",
    "   - Показывает очень высокие значения метрик, близкие к 1.0, что указывает на высокую эффективность модели.\n",
    "\n",
    "3. **Модель `mlp`**:\n",
    "   - Имеет немного более низкие значения Recall (0.999747) и F1-меры (0.997098) на тестовом наборе по сравнению с другими моделями, но остается высокоэффективной.\n",
    "\n",
    "4. **Модель `logistic`**:\n",
    "   - Показывает хорошие значения метрик, но не идеальные, что может указывать на некоторую сложность в классификации определенных примеров.\n",
    "\n",
    "5. **Модель `ridge`**:\n",
    "   - Имеет более низкие значения Precision (0.887292) и F1-меры (0.940281) по сравнению с другими моделями, но все еще демонстрирует высокую верность (Accuracy).\n",
    "\n",
    "6. **Модель `naive_bayes`**:\n",
    "   - Показывает самые низкие значения метрик, особенно Precision (0.164340) и F1-меры (0.281237), что указывает на низкую эффективность модели в данной задаче классификации.\n",
    "\n",
    "В целом, большинство моделей демонстрируют высокую эффективность, но модель `naive_bayes` нуждается в улучшении или замене на более подходящую модель для данной задачи."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ROC-кривая, каппа Коэна, коэффициент корреляции Мэтьюса"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style type=\"text/css\">\n",
       "#T_3b94e_row0_col0, #T_3b94e_row0_col1, #T_3b94e_row1_col0, #T_3b94e_row1_col1, #T_3b94e_row2_col0, #T_3b94e_row2_col1, #T_3b94e_row3_col0, #T_3b94e_row3_col1, #T_3b94e_row4_col0, #T_3b94e_row4_col1 {\n",
       "  background-color: #a8db34;\n",
       "  color: #000000;\n",
       "}\n",
       "#T_3b94e_row0_col2, #T_3b94e_row0_col3, #T_3b94e_row0_col4, #T_3b94e_row1_col2, #T_3b94e_row1_col3, #T_3b94e_row1_col4, #T_3b94e_row2_col2, #T_3b94e_row2_col3, #T_3b94e_row2_col4, #T_3b94e_row3_col2, #T_3b94e_row3_col3, #T_3b94e_row3_col4, #T_3b94e_row4_col2, #T_3b94e_row4_col3, #T_3b94e_row4_col4, #T_3b94e_row5_col2, #T_3b94e_row6_col2 {\n",
       "  background-color: #da5a6a;\n",
       "  color: #f1f1f1;\n",
       "}\n",
       "#T_3b94e_row5_col0 {\n",
       "  background-color: #a0da39;\n",
       "  color: #000000;\n",
       "}\n",
       "#T_3b94e_row5_col1 {\n",
       "  background-color: #90d743;\n",
       "  color: #000000;\n",
       "}\n",
       "#T_3b94e_row5_col3 {\n",
       "  background-color: #d35171;\n",
       "  color: #f1f1f1;\n",
       "}\n",
       "#T_3b94e_row5_col4 {\n",
       "  background-color: #d24f71;\n",
       "  color: #f1f1f1;\n",
       "}\n",
       "#T_3b94e_row6_col0 {\n",
       "  background-color: #a2da37;\n",
       "  color: #000000;\n",
       "}\n",
       "#T_3b94e_row6_col1 {\n",
       "  background-color: #98d83e;\n",
       "  color: #000000;\n",
       "}\n",
       "#T_3b94e_row6_col3, #T_3b94e_row6_col4 {\n",
       "  background-color: #d5536f;\n",
       "  color: #f1f1f1;\n",
       "}\n",
       "#T_3b94e_row7_col0, #T_3b94e_row7_col1 {\n",
       "  background-color: #26818e;\n",
       "  color: #f1f1f1;\n",
       "}\n",
       "#T_3b94e_row7_col2, #T_3b94e_row7_col3, #T_3b94e_row7_col4 {\n",
       "  background-color: #4e02a2;\n",
       "  color: #f1f1f1;\n",
       "}\n",
       "</style>\n",
       "<table id=\"T_3b94e\">\n",
       "  <thead>\n",
       "    <tr>\n",
       "      <th class=\"blank level0\" >&nbsp;</th>\n",
       "      <th id=\"T_3b94e_level0_col0\" class=\"col_heading level0 col0\" >Accuracy_test</th>\n",
       "      <th id=\"T_3b94e_level0_col1\" class=\"col_heading level0 col1\" >F1_test</th>\n",
       "      <th id=\"T_3b94e_level0_col2\" class=\"col_heading level0 col2\" >ROC_AUC_test</th>\n",
       "      <th id=\"T_3b94e_level0_col3\" class=\"col_heading level0 col3\" >Cohen_kappa_test</th>\n",
       "      <th id=\"T_3b94e_level0_col4\" class=\"col_heading level0 col4\" >MCC_test</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th id=\"T_3b94e_level0_row0\" class=\"row_heading level0 row0\" >decision_tree</th>\n",
       "      <td id=\"T_3b94e_row0_col0\" class=\"data row0 col0\" >1.000000</td>\n",
       "      <td id=\"T_3b94e_row0_col1\" class=\"data row0 col1\" >1.000000</td>\n",
       "      <td id=\"T_3b94e_row0_col2\" class=\"data row0 col2\" >1.000000</td>\n",
       "      <td id=\"T_3b94e_row0_col3\" class=\"data row0 col3\" >1.000000</td>\n",
       "      <td id=\"T_3b94e_row0_col4\" class=\"data row0 col4\" >1.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th id=\"T_3b94e_level0_row1\" class=\"row_heading level0 row1\" >gradient_boosting</th>\n",
       "      <td id=\"T_3b94e_row1_col0\" class=\"data row1 col0\" >1.000000</td>\n",
       "      <td id=\"T_3b94e_row1_col1\" class=\"data row1 col1\" >1.000000</td>\n",
       "      <td id=\"T_3b94e_row1_col2\" class=\"data row1 col2\" >1.000000</td>\n",
       "      <td id=\"T_3b94e_row1_col3\" class=\"data row1 col3\" >1.000000</td>\n",
       "      <td id=\"T_3b94e_row1_col4\" class=\"data row1 col4\" >1.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th id=\"T_3b94e_level0_row2\" class=\"row_heading level0 row2\" >random_forest</th>\n",
       "      <td id=\"T_3b94e_row2_col0\" class=\"data row2 col0\" >1.000000</td>\n",
       "      <td id=\"T_3b94e_row2_col1\" class=\"data row2 col1\" >1.000000</td>\n",
       "      <td id=\"T_3b94e_row2_col2\" class=\"data row2 col2\" >1.000000</td>\n",
       "      <td id=\"T_3b94e_row2_col3\" class=\"data row2 col3\" >1.000000</td>\n",
       "      <td id=\"T_3b94e_row2_col4\" class=\"data row2 col4\" >1.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th id=\"T_3b94e_level0_row3\" class=\"row_heading level0 row3\" >mlp</th>\n",
       "      <td id=\"T_3b94e_row3_col0\" class=\"data row3 col0\" >0.999292</td>\n",
       "      <td id=\"T_3b94e_row3_col1\" class=\"data row3 col1\" >0.997098</td>\n",
       "      <td id=\"T_3b94e_row3_col2\" class=\"data row3 col2\" >0.999992</td>\n",
       "      <td id=\"T_3b94e_row3_col3\" class=\"data row3 col3\" >0.996694</td>\n",
       "      <td id=\"T_3b94e_row3_col4\" class=\"data row3 col4\" >0.996699</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th id=\"T_3b94e_level0_row4\" class=\"row_heading level0 row4\" >knn</th>\n",
       "      <td id=\"T_3b94e_row4_col0\" class=\"data row4 col0\" >0.999507</td>\n",
       "      <td id=\"T_3b94e_row4_col1\" class=\"data row4 col1\" >0.997977</td>\n",
       "      <td id=\"T_3b94e_row4_col2\" class=\"data row4 col2\" >0.999928</td>\n",
       "      <td id=\"T_3b94e_row4_col3\" class=\"data row4 col3\" >0.997697</td>\n",
       "      <td id=\"T_3b94e_row4_col4\" class=\"data row4 col4\" >0.997697</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th id=\"T_3b94e_level0_row5\" class=\"row_heading level0 row5\" >ridge</th>\n",
       "      <td id=\"T_3b94e_row5_col0\" class=\"data row5 col0\" >0.984536</td>\n",
       "      <td id=\"T_3b94e_row5_col1\" class=\"data row5 col1\" >0.940281</td>\n",
       "      <td id=\"T_3b94e_row5_col2\" class=\"data row5 col2\" >0.999837</td>\n",
       "      <td id=\"T_3b94e_row5_col3\" class=\"data row5 col3\" >0.931435</td>\n",
       "      <td id=\"T_3b94e_row5_col4\" class=\"data row5 col4\" >0.933632</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th id=\"T_3b94e_level0_row6\" class=\"row_heading level0 row6\" >logistic</th>\n",
       "      <td id=\"T_3b94e_row6_col0\" class=\"data row6 col0\" >0.990204</td>\n",
       "      <td id=\"T_3b94e_row6_col1\" class=\"data row6 col1\" >0.958224</td>\n",
       "      <td id=\"T_3b94e_row6_col2\" class=\"data row6 col2\" >0.999782</td>\n",
       "      <td id=\"T_3b94e_row6_col3\" class=\"data row6 col3\" >0.952685</td>\n",
       "      <td id=\"T_3b94e_row6_col4\" class=\"data row6 col4\" >0.953585</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th id=\"T_3b94e_level0_row7\" class=\"row_heading level0 row7\" >naive_bayes</th>\n",
       "      <td id=\"T_3b94e_row7_col0\" class=\"data row7 col0\" >0.393802</td>\n",
       "      <td id=\"T_3b94e_row7_col1\" class=\"data row7 col1\" >0.281237</td>\n",
       "      <td id=\"T_3b94e_row7_col2\" class=\"data row7 col2\" >0.750957</td>\n",
       "      <td id=\"T_3b94e_row7_col3\" class=\"data row7 col3\" >0.092090</td>\n",
       "      <td id=\"T_3b94e_row7_col4\" class=\"data row7 col4\" >0.209783</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n"
      ],
      "text/plain": [
       "<pandas.io.formats.style.Styler at 0x2c1a36ee0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Создаем DataFrame с метриками для каждой модели\n",
    "class_metrics = pd.DataFrame.from_dict(class_models, \"index\")[\n",
    "    [\n",
    "        \"Accuracy_test\",\n",
    "        \"F1_test\",\n",
    "        \"ROC_AUC_test\",\n",
    "        \"Cohen_kappa_test\",\n",
    "        \"MCC_test\",\n",
    "    ]\n",
    "]\n",
    "\n",
    "# Сортировка по ROC_AUC_test в порядке убывания\n",
    "class_metrics_sorted = class_metrics.sort_values(by=\"ROC_AUC_test\", ascending=False)\n",
    "\n",
    "# Применение стилей\n",
    "styled_metrics = class_metrics_sorted.style.background_gradient(\n",
    "    cmap=\"plasma\",  \n",
    "    low=0.3,  \n",
    "    high=1,  \n",
    "    subset=[\n",
    "        \"ROC_AUC_test\",\n",
    "        \"MCC_test\",\n",
    "        \"Cohen_kappa_test\",\n",
    "    ],\n",
    ").background_gradient(\n",
    "    cmap=\"viridis\",  \n",
    "    low=1,  \n",
    "    high=0.3,  \n",
    "    subset=[\n",
    "        \"Accuracy_test\",\n",
    "        \"F1_test\",\n",
    "    ],\n",
    ")\n",
    "\n",
    "display(styled_metrics)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Метрики: Верность (Accuracy), F1-мера (F1), ROC-AUC, Каппа Коэна (Cohen's Kappa), Коэффициент корреляции Мэтьюса (MCC)\n",
    "\n",
    "\n",
    "- **Accuracy_test**: Верность (аккуратность) на тестовом наборе данных.\n",
    "- **F1_test**: F1-мера на тестовом наборе данных.\n",
    "- **ROC_AUC_test**: Площадь под ROC-кривой на тестовом наборе данных.\n",
    "- **Cohen_kappa_test**: Каппа Коэна на тестовом наборе данных.\n",
    "- **MCC_test**: Коэффициент корреляции Мэтьюса на тестовом наборе данных.\n",
    "\n",
    "\n",
    "1. **Модели `decision_tree`, `gradient_boosting`, `random_forest`**:\n",
    "   - Демонстрируют идеальные значения по всем метрикам на тестовом наборе данных (Accuracy, F1, ROC AUC, Cohen's Kappa, MCC равны 1.0).\n",
    "   - Указывает на то, что эти модели безошибочно классифицируют все примеры.\n",
    "\n",
    "2. **Модель `mip`**:\n",
    "   - Показывает очень высокие значения метрик, близкие к 1.0, что указывает на высокую эффективность модели.\n",
    "\n",
    "3. **Модель `knn`**:\n",
    "   - Имеет высокие значения метрик, близкие к 1.0, что указывает на высокую эффективность модели.\n",
    "\n",
    "4. **Модель `ridge`**:\n",
    "   - Имеет более низкие значения Accuracy (0.984536) и F1-меры (0.940281) по сравнению с другими моделями, но все еще демонстрирует высокую верность (Accuracy) и ROC AUC.\n",
    "\n",
    "5. **Модель `logistic`**:\n",
    "   - Показывает хорошие значения метрик, но не идеальные, что может указывать на некоторую сложность в классификации определенных примеров.\n",
    "\n",
    "6. **Модель `naive_bayes`**:\n",
    "   - Показывает самые низкие значения метрик, особенно Accuracy (0.978846) и F1-меры (0.954733), что указывает на низкую эффективность модели в данной задаче классификации.\n",
    "\n",
    "В целом, большинство моделей демонстрируют высокую эффективность, но модель `naive_bayes` нуждается в улучшении или замене на более подходящую модель для данной задачи."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'decision_tree'"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "best_model = str(class_metrics.sort_values(by=\"MCC_test\", ascending=False).iloc[0].name)\n",
    "\n",
    "display(best_model)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Вывод данных с ошибкой предсказания для оценки"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Error items count: 0'"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "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>category</th>\n",
       "      <th>Predicted</th>\n",
       "      <th>sub_category</th>\n",
       "      <th>href</th>\n",
       "      <th>price</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "Empty DataFrame\n",
       "Columns: [category, Predicted, sub_category, href, price]\n",
       "Index: []"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Преобразование тестовых данных\n",
    "preprocessing_result = pipeline_end.transform(X_test)\n",
    "preprocessed_df = pd.DataFrame(\n",
    "    preprocessing_result,\n",
    "    columns=pipeline_end.get_feature_names_out(),\n",
    ")\n",
    "\n",
    "# Получение предсказаний лучшей модели\n",
    "y_pred = class_models[best_model][\"preds\"]\n",
    "\n",
    "# Нахождение индексов ошибок\n",
    "error_index = y_test[y_test != y_pred].index.tolist()  # Убираем столбец \"above_average_price\"\n",
    "display(f\"Error items count: {len(error_index)}\")\n",
    "\n",
    "# Создание DataFrame с ошибочными объектами\n",
    "error_predicted = pd.Series(y_pred, index=y_test.index).loc[error_index]\n",
    "error_df = X_test.loc[error_index].copy()\n",
    "error_df.insert(loc=1, column=\"Predicted\", value=error_predicted)\n",
    "error_df = error_df.sort_index()  # Сортировка по индексу\n",
    "\n",
    "# Вывод DataFrame с ошибочными объектами\n",
    "display(error_df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Пример использования обученной модели (конвейера) для предсказания"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "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>category</th>\n",
       "      <th>sub_category</th>\n",
       "      <th>href</th>\n",
       "      <th>price</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>26987</th>\n",
       "      <td>Groceries</td>\n",
       "      <td>Home Care</td>\n",
       "      <td>https://www.jiomart.com/c/groceries/home-care/...</td>\n",
       "      <td>438.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "        category sub_category  \\\n",
       "26987  Groceries    Home Care   \n",
       "\n",
       "                                                    href  price  \n",
       "26987  https://www.jiomart.com/c/groceries/home-care/...  438.0  "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "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>price</th>\n",
       "      <th>category_Electronics</th>\n",
       "      <th>category_Fashion</th>\n",
       "      <th>category_Groceries</th>\n",
       "      <th>category_Home &amp; Kitchen</th>\n",
       "      <th>category_Jewellery</th>\n",
       "      <th>sub_category_Apparel</th>\n",
       "      <th>sub_category_Auto Care</th>\n",
       "      <th>sub_category_Ayush</th>\n",
       "      <th>sub_category_Bags &amp; Travel Luggage</th>\n",
       "      <th>...</th>\n",
       "      <th>sub_category_Smart Devices</th>\n",
       "      <th>sub_category_Snacks &amp; Branded Foods</th>\n",
       "      <th>sub_category_Staples</th>\n",
       "      <th>sub_category_Stationery</th>\n",
       "      <th>sub_category_TV &amp; Speaker</th>\n",
       "      <th>sub_category_Tools &amp; Appliances</th>\n",
       "      <th>sub_category_Toys, Games &amp; Fitness</th>\n",
       "      <th>sub_category_Treatments</th>\n",
       "      <th>sub_category_Wellness</th>\n",
       "      <th>sub_category_Women</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>26987</th>\n",
       "      <td>-0.094382</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>...</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>1 rows × 75 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "          price  category_Electronics  category_Fashion  category_Groceries  \\\n",
       "26987 -0.094382                   0.0               0.0                 1.0   \n",
       "\n",
       "       category_Home & Kitchen  category_Jewellery  sub_category_Apparel  \\\n",
       "26987                      0.0                 0.0                   0.0   \n",
       "\n",
       "       sub_category_Auto Care  sub_category_Ayush  \\\n",
       "26987                     0.0                 0.0   \n",
       "\n",
       "       sub_category_Bags & Travel Luggage  ...  sub_category_Smart Devices  \\\n",
       "26987                                 0.0  ...                         0.0   \n",
       "\n",
       "       sub_category_Snacks & Branded Foods  sub_category_Staples  \\\n",
       "26987                                  0.0                   0.0   \n",
       "\n",
       "       sub_category_Stationery  sub_category_TV & Speaker  \\\n",
       "26987                      0.0                        0.0   \n",
       "\n",
       "       sub_category_Tools & Appliances  sub_category_Toys, Games & Fitness  \\\n",
       "26987                              0.0                                 0.0   \n",
       "\n",
       "       sub_category_Treatments  sub_category_Wellness  sub_category_Women  \n",
       "26987                      0.0                    0.0                 0.0  \n",
       "\n",
       "[1 rows x 75 columns]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "predicted: 0 (proba: [1. 0.])\n",
      "real: 0\n"
     ]
    }
   ],
   "source": [
    "model = class_models[best_model][\"pipeline\"]\n",
    "\n",
    "# Выбираем позиционный индекс объекта для анализа\n",
    "example_index = 13\n",
    "\n",
    "# Получаем исходные данные для объекта\n",
    "test = pd.DataFrame(X_test.iloc[example_index, :]).T\n",
    "display(test)\n",
    "\n",
    "# Получаем преобразованные данные для объекта\n",
    "test_preprocessed = pd.DataFrame(preprocessed_df.iloc[example_index, :]).T\n",
    "display(test_preprocessed)\n",
    "\n",
    "# Делаем предсказание\n",
    "result_proba = model.predict_proba(test)[0]\n",
    "result = model.predict(test)[0]\n",
    "\n",
    "# Получаем реальное значение\n",
    "real = int(y_test.iloc[example_index])\n",
    "\n",
    "# Выводим результаты\n",
    "print(f\"predicted: {result} (proba: {result_proba})\")\n",
    "print(f\"real: {real}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Подбор гиперпараметров методом поиска по сетке"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/ma/core.py:2846: RuntimeWarning: invalid value encountered in cast\n",
      "  _data = np.array(data, dtype=dtype, copy=copy,\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'model__criterion': 'gini',\n",
       " 'model__max_depth': 5,\n",
       " 'model__max_features': 'sqrt',\n",
       " 'model__n_estimators': 50}"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.model_selection import GridSearchCV\n",
    "\n",
    "optimized_model_type = \"random_forest\"\n",
    "\n",
    "random_forest_model = class_models[optimized_model_type][\"pipeline\"]\n",
    "\n",
    "param_grid = {\n",
    "    \"model__n_estimators\": [10, 50, 100],\n",
    "    \"model__max_features\": [\"sqrt\", \"log2\"],\n",
    "    \"model__max_depth\": [5, 7, 10],\n",
    "    \"model__criterion\": [\"gini\", \"entropy\"],\n",
    "}\n",
    "\n",
    "gs_optomizer = GridSearchCV(\n",
    "    estimator=random_forest_model, param_grid=param_grid, n_jobs=-1\n",
    ")\n",
    "gs_optomizer.fit(X_train, y_train.values.ravel())\n",
    "gs_optomizer.best_params_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Обучение модели с новыми гиперпараметрами__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.pipeline import Pipeline\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.compose import ColumnTransformer\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "import numpy as np\n",
    "from sklearn import metrics\n",
    "import pandas as pd\n",
    "\n",
    "# Определяем числовые признаки\n",
    "numeric_features = X_train.select_dtypes(include=['float64', 'int64']).columns.tolist()\n",
    "\n",
    "# Установка random_state\n",
    "random_state = 42\n",
    "\n",
    "# Определение трансформера\n",
    "pipeline_end = ColumnTransformer([\n",
    "    ('numeric', StandardScaler(), numeric_features),\n",
    "])\n",
    "\n",
    "# Объявление модели\n",
    "optimized_model = RandomForestClassifier(\n",
    "    random_state=random_state,\n",
    "    criterion=\"gini\",\n",
    "    max_depth=5,\n",
    "    max_features=\"sqrt\",\n",
    "    n_estimators=10,\n",
    ")\n",
    "\n",
    "# Создание пайплайна с корректными шагами\n",
    "result = {}\n",
    "\n",
    "# Обучение модели\n",
    "result[\"pipeline\"] = Pipeline([\n",
    "    (\"pipeline\", pipeline_end),\n",
    "    (\"model\", optimized_model)\n",
    "]).fit(X_train, y_train.values.ravel())\n",
    "\n",
    "# Прогнозирование и расчет метрик\n",
    "result[\"train_preds\"] = result[\"pipeline\"].predict(X_train)\n",
    "result[\"probs\"] = result[\"pipeline\"].predict_proba(X_test)[:, 1]\n",
    "result[\"preds\"] = np.where(result[\"probs\"] > 0.5, 1, 0)\n",
    "\n",
    "# Метрики для оценки модели\n",
    "result[\"Precision_train\"] = metrics.precision_score(y_train, result[\"train_preds\"])\n",
    "result[\"Precision_test\"] = metrics.precision_score(y_test, result[\"preds\"])\n",
    "result[\"Recall_train\"] = metrics.recall_score(y_train, result[\"train_preds\"])\n",
    "result[\"Recall_test\"] = metrics.recall_score(y_test, result[\"preds\"])\n",
    "result[\"Accuracy_train\"] = metrics.accuracy_score(y_train, result[\"train_preds\"])\n",
    "result[\"Accuracy_test\"] = metrics.accuracy_score(y_test, result[\"preds\"])\n",
    "result[\"ROC_AUC_test\"] = metrics.roc_auc_score(y_test, result[\"probs\"])\n",
    "result[\"F1_train\"] = metrics.f1_score(y_train, result[\"train_preds\"])\n",
    "result[\"F1_test\"] = metrics.f1_score(y_test, result[\"preds\"])\n",
    "result[\"MCC_test\"] = metrics.matthews_corrcoef(y_test, result[\"preds\"])\n",
    "result[\"Cohen_kappa_test\"] = metrics.cohen_kappa_score(y_test, result[\"preds\"])\n",
    "result[\"Confusion_matrix\"] = metrics.confusion_matrix(y_test, result[\"preds\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Формирование данных для оценки старой и новой версии модели"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "optimized_metrics = pd.DataFrame(columns=list(result.keys()))\n",
    "optimized_metrics.loc[len(optimized_metrics)] = pd.Series(\n",
    "    data=class_models[optimized_model_type]\n",
    ")\n",
    "optimized_metrics.loc[len(optimized_metrics)] = pd.Series(\n",
    "    data=result\n",
    ")\n",
    "optimized_metrics.insert(loc=0, column=\"Name\", value=[\"Old\", \"New\"])\n",
    "optimized_metrics = optimized_metrics.set_index(\"Name\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Оценка параметров старой и новой модели"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style type=\"text/css\">\n",
       "#T_cc5ba_row0_col0, #T_cc5ba_row0_col1, #T_cc5ba_row0_col2, #T_cc5ba_row0_col3, #T_cc5ba_row1_col0, #T_cc5ba_row1_col1, #T_cc5ba_row1_col2, #T_cc5ba_row1_col3 {\n",
       "  background-color: #440154;\n",
       "  color: #f1f1f1;\n",
       "}\n",
       "#T_cc5ba_row0_col4, #T_cc5ba_row0_col5, #T_cc5ba_row0_col6, #T_cc5ba_row0_col7, #T_cc5ba_row1_col4, #T_cc5ba_row1_col5, #T_cc5ba_row1_col6, #T_cc5ba_row1_col7 {\n",
       "  background-color: #0d0887;\n",
       "  color: #f1f1f1;\n",
       "}\n",
       "</style>\n",
       "<table id=\"T_cc5ba\">\n",
       "  <thead>\n",
       "    <tr>\n",
       "      <th class=\"blank level0\" >&nbsp;</th>\n",
       "      <th id=\"T_cc5ba_level0_col0\" class=\"col_heading level0 col0\" >Precision_train</th>\n",
       "      <th id=\"T_cc5ba_level0_col1\" class=\"col_heading level0 col1\" >Precision_test</th>\n",
       "      <th id=\"T_cc5ba_level0_col2\" class=\"col_heading level0 col2\" >Recall_train</th>\n",
       "      <th id=\"T_cc5ba_level0_col3\" class=\"col_heading level0 col3\" >Recall_test</th>\n",
       "      <th id=\"T_cc5ba_level0_col4\" class=\"col_heading level0 col4\" >Accuracy_train</th>\n",
       "      <th id=\"T_cc5ba_level0_col5\" class=\"col_heading level0 col5\" >Accuracy_test</th>\n",
       "      <th id=\"T_cc5ba_level0_col6\" class=\"col_heading level0 col6\" >F1_train</th>\n",
       "      <th id=\"T_cc5ba_level0_col7\" class=\"col_heading level0 col7\" >F1_test</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th class=\"index_name level0\" >Name</th>\n",
       "      <th class=\"blank col0\" >&nbsp;</th>\n",
       "      <th class=\"blank col1\" >&nbsp;</th>\n",
       "      <th class=\"blank col2\" >&nbsp;</th>\n",
       "      <th class=\"blank col3\" >&nbsp;</th>\n",
       "      <th class=\"blank col4\" >&nbsp;</th>\n",
       "      <th class=\"blank col5\" >&nbsp;</th>\n",
       "      <th class=\"blank col6\" >&nbsp;</th>\n",
       "      <th class=\"blank col7\" >&nbsp;</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th id=\"T_cc5ba_level0_row0\" class=\"row_heading level0 row0\" >Old</th>\n",
       "      <td id=\"T_cc5ba_row0_col0\" class=\"data row0 col0\" >1.000000</td>\n",
       "      <td id=\"T_cc5ba_row0_col1\" class=\"data row0 col1\" >1.000000</td>\n",
       "      <td id=\"T_cc5ba_row0_col2\" class=\"data row0 col2\" >1.000000</td>\n",
       "      <td id=\"T_cc5ba_row0_col3\" class=\"data row0 col3\" >1.000000</td>\n",
       "      <td id=\"T_cc5ba_row0_col4\" class=\"data row0 col4\" >1.000000</td>\n",
       "      <td id=\"T_cc5ba_row0_col5\" class=\"data row0 col5\" >1.000000</td>\n",
       "      <td id=\"T_cc5ba_row0_col6\" class=\"data row0 col6\" >1.000000</td>\n",
       "      <td id=\"T_cc5ba_row0_col7\" class=\"data row0 col7\" >1.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th id=\"T_cc5ba_level0_row1\" class=\"row_heading level0 row1\" >New</th>\n",
       "      <td id=\"T_cc5ba_row1_col0\" class=\"data row1 col0\" >1.000000</td>\n",
       "      <td id=\"T_cc5ba_row1_col1\" class=\"data row1 col1\" >1.000000</td>\n",
       "      <td id=\"T_cc5ba_row1_col2\" class=\"data row1 col2\" >1.000000</td>\n",
       "      <td id=\"T_cc5ba_row1_col3\" class=\"data row1 col3\" >1.000000</td>\n",
       "      <td id=\"T_cc5ba_row1_col4\" class=\"data row1 col4\" >1.000000</td>\n",
       "      <td id=\"T_cc5ba_row1_col5\" class=\"data row1 col5\" >1.000000</td>\n",
       "      <td id=\"T_cc5ba_row1_col6\" class=\"data row1 col6\" >1.000000</td>\n",
       "      <td id=\"T_cc5ba_row1_col7\" class=\"data row1 col7\" >1.000000</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n"
      ],
      "text/plain": [
       "<pandas.io.formats.style.Styler at 0x2c2d598b0>"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "optimized_metrics[\n",
    "    [\n",
    "        \"Precision_train\",\n",
    "        \"Precision_test\",\n",
    "        \"Recall_train\",\n",
    "        \"Recall_test\",\n",
    "        \"Accuracy_train\",\n",
    "        \"Accuracy_test\",\n",
    "        \"F1_train\",\n",
    "        \"F1_test\",\n",
    "    ]\n",
    "].style.background_gradient(\n",
    "    cmap=\"plasma\",\n",
    "    low=0.3,\n",
    "    high=1,\n",
    "    subset=[\"Accuracy_train\", \"Accuracy_test\", \"F1_train\", \"F1_test\"],\n",
    ").background_gradient(\n",
    "    cmap=\"viridis\",\n",
    "    low=1,\n",
    "    high=0.3,\n",
    "    subset=[\n",
    "        \"Precision_train\",\n",
    "        \"Precision_test\",\n",
    "        \"Recall_train\",\n",
    "        \"Recall_test\",\n",
    "    ],\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Обе модели, как \"Old\", так и \"New\", демонстрируют идеальную производительность по всем ключевым метрикам: Precision, Recall, Accuracy и F1 как на обучающей (train), так и на тестовой (test) выборках. Все значения равны 1.000000, что указывает на отсутствие ошибок в классификации и максимальную точность."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style type=\"text/css\">\n",
       "#T_67beb_row0_col0, #T_67beb_row0_col1, #T_67beb_row1_col0, #T_67beb_row1_col1 {\n",
       "  background-color: #440154;\n",
       "  color: #f1f1f1;\n",
       "}\n",
       "#T_67beb_row0_col2, #T_67beb_row0_col3, #T_67beb_row0_col4, #T_67beb_row1_col2, #T_67beb_row1_col3, #T_67beb_row1_col4 {\n",
       "  background-color: #0d0887;\n",
       "  color: #f1f1f1;\n",
       "}\n",
       "</style>\n",
       "<table id=\"T_67beb\">\n",
       "  <thead>\n",
       "    <tr>\n",
       "      <th class=\"blank level0\" >&nbsp;</th>\n",
       "      <th id=\"T_67beb_level0_col0\" class=\"col_heading level0 col0\" >Accuracy_test</th>\n",
       "      <th id=\"T_67beb_level0_col1\" class=\"col_heading level0 col1\" >F1_test</th>\n",
       "      <th id=\"T_67beb_level0_col2\" class=\"col_heading level0 col2\" >ROC_AUC_test</th>\n",
       "      <th id=\"T_67beb_level0_col3\" class=\"col_heading level0 col3\" >Cohen_kappa_test</th>\n",
       "      <th id=\"T_67beb_level0_col4\" class=\"col_heading level0 col4\" >MCC_test</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th class=\"index_name level0\" >Name</th>\n",
       "      <th class=\"blank col0\" >&nbsp;</th>\n",
       "      <th class=\"blank col1\" >&nbsp;</th>\n",
       "      <th class=\"blank col2\" >&nbsp;</th>\n",
       "      <th class=\"blank col3\" >&nbsp;</th>\n",
       "      <th class=\"blank col4\" >&nbsp;</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th id=\"T_67beb_level0_row0\" class=\"row_heading level0 row0\" >Old</th>\n",
       "      <td id=\"T_67beb_row0_col0\" class=\"data row0 col0\" >1.000000</td>\n",
       "      <td id=\"T_67beb_row0_col1\" class=\"data row0 col1\" >1.000000</td>\n",
       "      <td id=\"T_67beb_row0_col2\" class=\"data row0 col2\" >1.000000</td>\n",
       "      <td id=\"T_67beb_row0_col3\" class=\"data row0 col3\" >1.000000</td>\n",
       "      <td id=\"T_67beb_row0_col4\" class=\"data row0 col4\" >1.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th id=\"T_67beb_level0_row1\" class=\"row_heading level0 row1\" >New</th>\n",
       "      <td id=\"T_67beb_row1_col0\" class=\"data row1 col0\" >1.000000</td>\n",
       "      <td id=\"T_67beb_row1_col1\" class=\"data row1 col1\" >1.000000</td>\n",
       "      <td id=\"T_67beb_row1_col2\" class=\"data row1 col2\" >1.000000</td>\n",
       "      <td id=\"T_67beb_row1_col3\" class=\"data row1 col3\" >1.000000</td>\n",
       "      <td id=\"T_67beb_row1_col4\" class=\"data row1 col4\" >1.000000</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n"
      ],
      "text/plain": [
       "<pandas.io.formats.style.Styler at 0x175f018e0>"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "optimized_metrics[\n",
    "    [\n",
    "        \"Accuracy_test\",\n",
    "        \"F1_test\",\n",
    "        \"ROC_AUC_test\",\n",
    "        \"Cohen_kappa_test\",\n",
    "        \"MCC_test\",\n",
    "    ]\n",
    "].style.background_gradient(\n",
    "    cmap=\"plasma\",\n",
    "    low=0.3,\n",
    "    high=1,\n",
    "    subset=[\n",
    "        \"ROC_AUC_test\",\n",
    "        \"MCC_test\",\n",
    "        \"Cohen_kappa_test\",\n",
    "    ],\n",
    ").background_gradient(\n",
    "    cmap=\"viridis\",\n",
    "    low=1,\n",
    "    high=0.3,\n",
    "    subset=[\n",
    "        \"Accuracy_test\",\n",
    "        \"F1_test\",\n",
    "    ],\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Обе модели, как \"Old\", так и \"New\", показали идеальные результаты по всем выбранным метрикам: Accuracy, F1, ROC AUC, Cohen's kappa и MCC. Все метрики имеют значение 1.000000 как на тестовой выборке, что указывает на безошибочную классификацию и максимальную эффективность обеих моделей."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x400 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "_, ax = plt.subplots(1, 2, figsize=(10, 4), sharex=False, sharey=False)\n",
    "\n",
    "for index in range(0, len(optimized_metrics)):\n",
    "  c_matrix = optimized_metrics.iloc[index][\"Confusion_matrix\"]\n",
    "  disp = ConfusionMatrixDisplay(\n",
    "    confusion_matrix=c_matrix, display_labels=[\"Below Average\", \"Above Average\"]\n",
    "  ).plot(ax=ax.flat[index])\n",
    "  disp.ax_.set_title(optimized_metrics.index[index]) \n",
    "\n",
    "plt.subplots_adjust(top=1, bottom=0, hspace=0.4, wspace=0.3)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В желтом квадрате мы видим значение 28511, что обозначает количество правильно классифицированных объектов, отнесенных к классу \"Below Average\". Это свидетельствует о том, что модель успешно идентифицирует объекты этого класса, минимизируя количество ложных положительных срабатываний.\n",
    "\n",
    "В зеленом квадрате значение 3952 указывает на количество правильно классифицированных объектов, отнесенных к классу \"Above Average\". Это также является показателем высокой точности модели в определении объектов данного класса."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Определение достижимого уровня качества модели для второй задачи (задача регрессии)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Загрузка данных и создание целевой переменной"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Среднее значение поля 'price': 1991.6325132793531\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",
      "\n",
      "   above_average_price  \n",
      "0                    0  \n",
      "1                    0  \n",
      "2                    0  \n",
      "3                    0  \n",
      "4                    0  \n",
      "Статистическое описание DataFrame:\n",
      "              price  above_average_price\n",
      "count  1.622820e+05        162313.000000\n",
      "mean   1.991633e+03             0.121734\n",
      "std    1.593479e+04             0.326979\n",
      "min    5.000000e+00             0.000000\n",
      "25%    2.840000e+02             0.000000\n",
      "50%    4.990000e+02             0.000000\n",
      "75%    9.990000e+02             0.000000\n",
      "max    3.900000e+06             1.000000\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "from sklearn import set_config\n",
    "\n",
    "set_config(transform_output=\"pandas\")\n",
    "\n",
    "# Загрузка данных\n",
    "df = pd.read_csv(\"..//static//csv//jio_mart_items.csv\")\n",
    "\n",
    "# Опция для настройки генерации случайных чисел \n",
    "random_state = 42\n",
    "\n",
    "# Вычисление среднего значения поля \"price\"\n",
    "average_price = df['price'].mean()\n",
    "print(f\"Среднее значение поля 'price': {average_price}\")\n",
    "\n",
    "# Создание новой колонки, указывающей, выше или ниже среднего значение цены\n",
    "df['above_average_price'] = (df['price'] > average_price).astype(int)\n",
    "\n",
    "# Вывод DataFrame с новой колонкой\n",
    "print(df.head())\n",
    "\n",
    "# Примерный анализ данных\n",
    "print(\"Статистическое описание DataFrame:\")\n",
    "print(df.describe())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Разделение набора данных на обучающую и тестовые выборки (80/20) для задачи регрессии\n",
    "\n",
    "Целевой признак -- above_average_price"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'X_train'"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "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>category</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>38475</th>\n",
       "      <td>Groceries</td>\n",
       "      <td>Mom &amp; Baby Care</td>\n",
       "      <td>https://www.jiomart.com/c/groceries/mom-baby-c...</td>\n",
       "      <td>Halo Nation Green Plastic Wobbling Roly Poly T...</td>\n",
       "      <td>529.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3550</th>\n",
       "      <td>Groceries</td>\n",
       "      <td>Staples</td>\n",
       "      <td>https://www.jiomart.com/c/groceries/staples/ri...</td>\n",
       "      <td>OrgaSatva Organic Sona Masuri Rice (White) 1 kg</td>\n",
       "      <td>420.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>145206</th>\n",
       "      <td>Electronics</td>\n",
       "      <td>Accessories</td>\n",
       "      <td>https://www.jiomart.com/c/electronics/accessor...</td>\n",
       "      <td>itek 10000 mAh Power Bank, RBB013_BK</td>\n",
       "      <td>1099.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>151588</th>\n",
       "      <td>Beauty</td>\n",
       "      <td>Make-Up</td>\n",
       "      <td>https://www.jiomart.com/c/beauty/make-up/lips/...</td>\n",
       "      <td>Fashion Colour Satin Smooth Lip Definer, 14 Ab...</td>\n",
       "      <td>356.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>28297</th>\n",
       "      <td>Groceries</td>\n",
       "      <td>Home Care</td>\n",
       "      <td>https://www.jiomart.com/c/groceries/home-care/...</td>\n",
       "      <td>My Home Lavender Trail Air Freshener Block 50 ...</td>\n",
       "      <td>65.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>119879</th>\n",
       "      <td>Fashion</td>\n",
       "      <td>Women</td>\n",
       "      <td>https://www.jiomart.com/c/fashion/women/bags-b...</td>\n",
       "      <td>Trysco Women Genuine Leather Yellow Belt</td>\n",
       "      <td>599.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>103694</th>\n",
       "      <td>Home &amp; Kitchen</td>\n",
       "      <td>Pooja Needs</td>\n",
       "      <td>https://www.jiomart.com/c/groceries/home-kitch...</td>\n",
       "      <td>Majmua Attar Made Pure and Natural Exclusive I...</td>\n",
       "      <td>599.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>131932</th>\n",
       "      <td>Fashion</td>\n",
       "      <td>Girls</td>\n",
       "      <td>https://www.jiomart.com/c/fashion/girls/watche...</td>\n",
       "      <td>Mikado Analog Blue Watch For Girls ,Pack Of 2</td>\n",
       "      <td>249.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>146867</th>\n",
       "      <td>Electronics</td>\n",
       "      <td>Accessories</td>\n",
       "      <td>https://www.jiomart.com/c/electronics/accessor...</td>\n",
       "      <td>Reconnect RACMB1001 Car Mount</td>\n",
       "      <td>100.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>121958</th>\n",
       "      <td>Fashion</td>\n",
       "      <td>Women</td>\n",
       "      <td>https://www.jiomart.com/c/fashion/women/fashio...</td>\n",
       "      <td>Traditional Long Earring Zinc Jhumki Earring (...</td>\n",
       "      <td>129.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>129850 rows × 5 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "              category     sub_category  \\\n",
       "38475        Groceries  Mom & Baby Care   \n",
       "3550         Groceries          Staples   \n",
       "145206     Electronics      Accessories   \n",
       "151588          Beauty          Make-Up   \n",
       "28297        Groceries        Home Care   \n",
       "...                ...              ...   \n",
       "119879         Fashion            Women   \n",
       "103694  Home & Kitchen      Pooja Needs   \n",
       "131932         Fashion            Girls   \n",
       "146867     Electronics      Accessories   \n",
       "121958         Fashion            Women   \n",
       "\n",
       "                                                     href  \\\n",
       "38475   https://www.jiomart.com/c/groceries/mom-baby-c...   \n",
       "3550    https://www.jiomart.com/c/groceries/staples/ri...   \n",
       "145206  https://www.jiomart.com/c/electronics/accessor...   \n",
       "151588  https://www.jiomart.com/c/beauty/make-up/lips/...   \n",
       "28297   https://www.jiomart.com/c/groceries/home-care/...   \n",
       "...                                                   ...   \n",
       "119879  https://www.jiomart.com/c/fashion/women/bags-b...   \n",
       "103694  https://www.jiomart.com/c/groceries/home-kitch...   \n",
       "131932  https://www.jiomart.com/c/fashion/girls/watche...   \n",
       "146867  https://www.jiomart.com/c/electronics/accessor...   \n",
       "121958  https://www.jiomart.com/c/fashion/women/fashio...   \n",
       "\n",
       "                                                    items   price  \n",
       "38475   Halo Nation Green Plastic Wobbling Roly Poly T...   529.0  \n",
       "3550      OrgaSatva Organic Sona Masuri Rice (White) 1 kg   420.0  \n",
       "145206               itek 10000 mAh Power Bank, RBB013_BK  1099.0  \n",
       "151588  Fashion Colour Satin Smooth Lip Definer, 14 Ab...   356.0  \n",
       "28297   My Home Lavender Trail Air Freshener Block 50 ...    65.0  \n",
       "...                                                   ...     ...  \n",
       "119879           Trysco Women Genuine Leather Yellow Belt   599.0  \n",
       "103694  Majmua Attar Made Pure and Natural Exclusive I...   599.0  \n",
       "131932      Mikado Analog Blue Watch For Girls ,Pack Of 2   249.0  \n",
       "146867                      Reconnect RACMB1001 Car Mount   100.0  \n",
       "121958  Traditional Long Earring Zinc Jhumki Earring (...   129.0  \n",
       "\n",
       "[129850 rows x 5 columns]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "'y_train'"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "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>above_average_price</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>38475</th>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3550</th>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>145206</th>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>151588</th>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>28297</th>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>119879</th>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>103694</th>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>131932</th>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>146867</th>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>121958</th>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>129850 rows × 1 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "        above_average_price\n",
       "38475                     0\n",
       "3550                      0\n",
       "145206                    0\n",
       "151588                    0\n",
       "28297                     0\n",
       "...                     ...\n",
       "119879                    0\n",
       "103694                    0\n",
       "131932                    0\n",
       "146867                    0\n",
       "121958                    0\n",
       "\n",
       "[129850 rows x 1 columns]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "'X_test'"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "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>category</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>52893</th>\n",
       "      <td>Home &amp; Kitchen</td>\n",
       "      <td>Dining</td>\n",
       "      <td>https://www.jiomart.com/c/groceries/home-kitch...</td>\n",
       "      <td>CRAFTYKART Brown Shesham Wood Serving Tray ?35...</td>\n",
       "      <td>699.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>78308</th>\n",
       "      <td>Home &amp; Kitchen</td>\n",
       "      <td>Toys, Games &amp; Fitness</td>\n",
       "      <td>https://www.jiomart.com/c/groceries/home-kitch...</td>\n",
       "      <td>Magicwand Red ABS Plastic 4Wd 360 Degree Twist...</td>\n",
       "      <td>7999.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>159477</th>\n",
       "      <td>Beauty</td>\n",
       "      <td>Fragrances</td>\n",
       "      <td>https://www.jiomart.com/c/beauty/fragrances/wo...</td>\n",
       "      <td>Ajmal Senora EDP Floral Spicy Perfume And Sacr...</td>\n",
       "      <td>1295.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>74384</th>\n",
       "      <td>Home &amp; Kitchen</td>\n",
       "      <td>Toys, Games &amp; Fitness</td>\n",
       "      <td>https://www.jiomart.com/c/groceries/home-kitch...</td>\n",
       "      <td>Frantic Ultra Soft Stuffed Lovable Spongy Huga...</td>\n",
       "      <td>369.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>93511</th>\n",
       "      <td>Home &amp; Kitchen</td>\n",
       "      <td>Bags &amp; Travel Luggage</td>\n",
       "      <td>https://www.jiomart.com/c/groceries/home-kitch...</td>\n",
       "      <td>DE VAGABOND Orange Black Polyester Travel Duff...</td>\n",
       "      <td>749.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>117300</th>\n",
       "      <td>Fashion</td>\n",
       "      <td>Women</td>\n",
       "      <td>https://www.jiomart.com/c/fashion/women/wester...</td>\n",
       "      <td>Tees World Women Grey Regular Fit Round Neck P...</td>\n",
       "      <td>999.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>24023</th>\n",
       "      <td>Groceries</td>\n",
       "      <td>Personal Care</td>\n",
       "      <td>https://www.jiomart.com/c/groceries/personal-c...</td>\n",
       "      <td>Vetoni Fruit Punch Lather Shaving Cream for Me...</td>\n",
       "      <td>300.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>129165</th>\n",
       "      <td>Fashion</td>\n",
       "      <td>Girls</td>\n",
       "      <td>https://www.jiomart.com/c/fashion/girls/wester...</td>\n",
       "      <td>IndiWeaves Girls Printed Cotton Half Sleeves T...</td>\n",
       "      <td>799.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>71336</th>\n",
       "      <td>Home &amp; Kitchen</td>\n",
       "      <td>Furniture</td>\n",
       "      <td>https://www.jiomart.com/c/groceries/home-kitch...</td>\n",
       "      <td>EVEREST DRAWER V</td>\n",
       "      <td>2081.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>110968</th>\n",
       "      <td>Fashion</td>\n",
       "      <td>Men</td>\n",
       "      <td>https://www.jiomart.com/c/fashion/men/footwear...</td>\n",
       "      <td>Birde Sports Shoes</td>\n",
       "      <td>399.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>32463 rows × 5 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "              category           sub_category  \\\n",
       "52893   Home & Kitchen                 Dining   \n",
       "78308   Home & Kitchen  Toys, Games & Fitness   \n",
       "159477          Beauty             Fragrances   \n",
       "74384   Home & Kitchen  Toys, Games & Fitness   \n",
       "93511   Home & Kitchen  Bags & Travel Luggage   \n",
       "...                ...                    ...   \n",
       "117300         Fashion                  Women   \n",
       "24023        Groceries          Personal Care   \n",
       "129165         Fashion                  Girls   \n",
       "71336   Home & Kitchen              Furniture   \n",
       "110968         Fashion                    Men   \n",
       "\n",
       "                                                     href  \\\n",
       "52893   https://www.jiomart.com/c/groceries/home-kitch...   \n",
       "78308   https://www.jiomart.com/c/groceries/home-kitch...   \n",
       "159477  https://www.jiomart.com/c/beauty/fragrances/wo...   \n",
       "74384   https://www.jiomart.com/c/groceries/home-kitch...   \n",
       "93511   https://www.jiomart.com/c/groceries/home-kitch...   \n",
       "...                                                   ...   \n",
       "117300  https://www.jiomart.com/c/fashion/women/wester...   \n",
       "24023   https://www.jiomart.com/c/groceries/personal-c...   \n",
       "129165  https://www.jiomart.com/c/fashion/girls/wester...   \n",
       "71336   https://www.jiomart.com/c/groceries/home-kitch...   \n",
       "110968  https://www.jiomart.com/c/fashion/men/footwear...   \n",
       "\n",
       "                                                    items   price  \n",
       "52893   CRAFTYKART Brown Shesham Wood Serving Tray ?35...   699.0  \n",
       "78308   Magicwand Red ABS Plastic 4Wd 360 Degree Twist...  7999.0  \n",
       "159477  Ajmal Senora EDP Floral Spicy Perfume And Sacr...  1295.0  \n",
       "74384   Frantic Ultra Soft Stuffed Lovable Spongy Huga...   369.0  \n",
       "93511   DE VAGABOND Orange Black Polyester Travel Duff...   749.0  \n",
       "...                                                   ...     ...  \n",
       "117300  Tees World Women Grey Regular Fit Round Neck P...   999.0  \n",
       "24023   Vetoni Fruit Punch Lather Shaving Cream for Me...   300.0  \n",
       "129165  IndiWeaves Girls Printed Cotton Half Sleeves T...   799.0  \n",
       "71336                                    EVEREST DRAWER V  2081.0  \n",
       "110968                                 Birde Sports Shoes   399.0  \n",
       "\n",
       "[32463 rows x 5 columns]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "'y_test'"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "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>above_average_price</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>52893</th>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>78308</th>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>159477</th>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>74384</th>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>93511</th>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>117300</th>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>24023</th>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>129165</th>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>71336</th>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>110968</th>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>32463 rows × 1 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "        above_average_price\n",
       "52893                     0\n",
       "78308                     1\n",
       "159477                    0\n",
       "74384                     0\n",
       "93511                     0\n",
       "...                     ...\n",
       "117300                    0\n",
       "24023                     0\n",
       "129165                    0\n",
       "71336                     1\n",
       "110968                    0\n",
       "\n",
       "[32463 rows x 1 columns]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from typing import Tuple\n",
    "import pandas as pd\n",
    "from pandas import DataFrame\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "def split_into_train_test(\n",
    "    df_input: DataFrame,\n",
    "    target_colname: str = \"above_average_price\",  \n",
    "    frac_train: float = 0.8,\n",
    "    random_state: int = None,\n",
    ") -> Tuple[DataFrame, DataFrame, DataFrame, DataFrame]:\n",
    "    \n",
    "    if not (0 < frac_train < 1):\n",
    "        raise ValueError(\"Fraction must be between 0 and 1.\")\n",
    "    \n",
    "    # Проверка наличия целевого признака\n",
    "    if target_colname not in df_input.columns:\n",
    "        raise ValueError(f\"{target_colname} is not a column in the DataFrame.\")\n",
    "    \n",
    "    # Разделяем данные на признаки и целевую переменную\n",
    "    X = df_input.drop(columns=[target_colname])  # Признаки\n",
    "    y = df_input[[target_colname]]  # Целевая переменная\n",
    "\n",
    "    # Разделяем данные на обучающую и тестовую выборки\n",
    "    X_train, X_test, y_train, y_test = train_test_split(\n",
    "        X, y,\n",
    "        test_size=(1.0 - frac_train),\n",
    "        random_state=random_state\n",
    "    )\n",
    "    \n",
    "    return X_train, X_test, y_train, y_test\n",
    "\n",
    "# Применение функции для разделения данных\n",
    "X_train, X_test, y_train, y_test = split_into_train_test(\n",
    "    df, \n",
    "    target_colname=\"above_average_price\",  \n",
    "    frac_train=0.8, \n",
    "    random_state=42 \n",
    ")\n",
    "\n",
    "# Для отображения результатов\n",
    "display(\"X_train\", X_train)\n",
    "display(\"y_train\", y_train)\n",
    "\n",
    "display(\"X_test\", X_test)\n",
    "display(\"y_test\", y_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Формирование конвейера для решения задачи регрессии"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "           price  category_Electronics  category_Fashion  category_Groceries  \\\n",
      "0      -0.118140                   0.0               0.0                 1.0   \n",
      "1      -0.121905                   0.0               0.0                 1.0   \n",
      "2      -0.120650                   0.0               0.0                 1.0   \n",
      "3      -0.117136                   0.0               0.0                 1.0   \n",
      "4      -0.122219                   0.0               0.0                 1.0   \n",
      "...          ...                   ...               ...                 ...   \n",
      "162308 -0.020231                   0.0               0.0                 0.0   \n",
      "162309 -0.037679                   0.0               0.0                 0.0   \n",
      "162310 -0.072637                   0.0               0.0                 0.0   \n",
      "162311  0.017865                   0.0               0.0                 0.0   \n",
      "162312 -0.072637                   0.0               0.0                 0.0   \n",
      "\n",
      "        category_Home & Kitchen  category_Jewellery  sub_category_Apparel  \\\n",
      "0                           0.0                 0.0                   0.0   \n",
      "1                           0.0                 0.0                   0.0   \n",
      "2                           0.0                 0.0                   0.0   \n",
      "3                           0.0                 0.0                   0.0   \n",
      "4                           0.0                 0.0                   0.0   \n",
      "...                         ...                 ...                   ...   \n",
      "162308                      0.0                 1.0                   0.0   \n",
      "162309                      0.0                 1.0                   0.0   \n",
      "162310                      0.0                 1.0                   0.0   \n",
      "162311                      0.0                 1.0                   0.0   \n",
      "162312                      0.0                 1.0                   0.0   \n",
      "\n",
      "        sub_category_Auto Care  sub_category_Ayush  \\\n",
      "0                          0.0                 0.0   \n",
      "1                          0.0                 0.0   \n",
      "2                          0.0                 0.0   \n",
      "3                          0.0                 0.0   \n",
      "4                          0.0                 0.0   \n",
      "...                        ...                 ...   \n",
      "162308                     0.0                 0.0   \n",
      "162309                     0.0                 0.0   \n",
      "162310                     0.0                 0.0   \n",
      "162311                     0.0                 0.0   \n",
      "162312                     0.0                 0.0   \n",
      "\n",
      "        sub_category_Bags & Travel Luggage  ...  \\\n",
      "0                                      0.0  ...   \n",
      "1                                      0.0  ...   \n",
      "2                                      0.0  ...   \n",
      "3                                      0.0  ...   \n",
      "4                                      0.0  ...   \n",
      "...                                    ...  ...   \n",
      "162308                                 0.0  ...   \n",
      "162309                                 0.0  ...   \n",
      "162310                                 0.0  ...   \n",
      "162311                                 0.0  ...   \n",
      "162312                                 0.0  ...   \n",
      "\n",
      "        sub_category_Snacks & Branded Foods  sub_category_Staples  \\\n",
      "0                                       0.0                   0.0   \n",
      "1                                       0.0                   0.0   \n",
      "2                                       0.0                   0.0   \n",
      "3                                       0.0                   0.0   \n",
      "4                                       0.0                   0.0   \n",
      "...                                     ...                   ...   \n",
      "162308                                  0.0                   0.0   \n",
      "162309                                  0.0                   0.0   \n",
      "162310                                  0.0                   0.0   \n",
      "162311                                  0.0                   0.0   \n",
      "162312                                  0.0                   0.0   \n",
      "\n",
      "        sub_category_Stationery  sub_category_TV & Speaker  sub_category_Tech  \\\n",
      "0                           0.0                        0.0                0.0   \n",
      "1                           0.0                        0.0                0.0   \n",
      "2                           0.0                        0.0                0.0   \n",
      "3                           0.0                        0.0                0.0   \n",
      "4                           0.0                        0.0                0.0   \n",
      "...                         ...                        ...                ...   \n",
      "162308                      0.0                        0.0                0.0   \n",
      "162309                      0.0                        0.0                0.0   \n",
      "162310                      0.0                        0.0                0.0   \n",
      "162311                      0.0                        0.0                0.0   \n",
      "162312                      0.0                        0.0                0.0   \n",
      "\n",
      "        sub_category_Tools & Appliances  sub_category_Toys, Games & Fitness  \\\n",
      "0                                   0.0                                 0.0   \n",
      "1                                   0.0                                 0.0   \n",
      "2                                   0.0                                 0.0   \n",
      "3                                   0.0                                 0.0   \n",
      "4                                   0.0                                 0.0   \n",
      "...                                 ...                                 ...   \n",
      "162308                              0.0                                 0.0   \n",
      "162309                              0.0                                 0.0   \n",
      "162310                              0.0                                 0.0   \n",
      "162311                              0.0                                 0.0   \n",
      "162312                              0.0                                 0.0   \n",
      "\n",
      "        sub_category_Treatments  sub_category_Wellness  sub_category_Women  \n",
      "0                           0.0                    0.0                 0.0  \n",
      "1                           0.0                    0.0                 0.0  \n",
      "2                           0.0                    0.0                 0.0  \n",
      "3                           0.0                    0.0                 0.0  \n",
      "4                           0.0                    0.0                 0.0  \n",
      "...                         ...                    ...                 ...  \n",
      "162308                      0.0                    0.0                 0.0  \n",
      "162309                      0.0                    0.0                 0.0  \n",
      "162310                      0.0                    0.0                 0.0  \n",
      "162311                      0.0                    0.0                 0.0  \n",
      "162312                      0.0                    0.0                 0.0  \n",
      "\n",
      "[162313 rows x 77 columns]\n",
      "(162313, 77)\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "from sklearn.base import BaseEstimator, TransformerMixin\n",
    "from sklearn.compose import ColumnTransformer\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.impute import SimpleImputer\n",
    "from sklearn.pipeline import Pipeline\n",
    "from sklearn.preprocessing import OneHotEncoder\n",
    "from sklearn.ensemble import RandomForestRegressor \n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.pipeline import make_pipeline\n",
    "import pandas as pd\n",
    "\n",
    "class JioMartFeatures(BaseEstimator, TransformerMixin): \n",
    "  def __init__(self):\n",
    "    pass\n",
    "\n",
    "  def fit(self, X, y=None):\n",
    "    return self\n",
    "\n",
    "  def transform(self, X, y=None):\n",
    "    if 'category' in X.columns:\n",
    "        X[\"Price_per_Category\"] = X[\"price\"] / X[\"category\"].nunique()\n",
    "    return X\n",
    "\n",
    "  def get_feature_names_out(self, features_in):\n",
    "    return np.append(features_in, [\"Price_per_Category\"], axis=0) \n",
    "\n",
    "# Определите признаки для вашей задачи\n",
    "columns_to_drop = [\"href\", \"items\"] \n",
    "num_columns = [\"price\"] \n",
    "cat_columns = [\"category\", \"sub_category\"]\n",
    "\n",
    "# Преобразование числовых признаков\n",
    "num_imputer = SimpleImputer(strategy=\"median\")\n",
    "num_scaler = StandardScaler()\n",
    "preprocessing_num = Pipeline(\n",
    "  [\n",
    "    (\"imputer\", num_imputer),\n",
    "    (\"scaler\", num_scaler),\n",
    "  ]\n",
    ")\n",
    "\n",
    "# Преобразование категориальных признаков\n",
    "cat_imputer = SimpleImputer(strategy=\"constant\", fill_value=\"unknown\")\n",
    "cat_encoder = OneHotEncoder(handle_unknown=\"ignore\", sparse_output=False, drop=\"first\")\n",
    "preprocessing_cat = Pipeline(\n",
    "  [\n",
    "    (\"imputer\", cat_imputer),\n",
    "    (\"encoder\", cat_encoder),\n",
    "  ]\n",
    ")\n",
    "\n",
    "# Формирование конвейера\n",
    "features_preprocessing = ColumnTransformer(\n",
    "  verbose_feature_names_out=False,\n",
    "  transformers=[\n",
    "    (\"prepocessing_num\", preprocessing_num, num_columns),\n",
    "    (\"prepocessing_cat\", preprocessing_cat, cat_columns),\n",
    "  ],\n",
    "  remainder=\"passthrough\" \n",
    ")\n",
    "\n",
    "drop_columns = ColumnTransformer(\n",
    "  verbose_feature_names_out=False,\n",
    "  transformers=[\n",
    "    (\"drop_columns\", \"drop\", columns_to_drop),\n",
    "  ],\n",
    "  remainder=\"passthrough\",\n",
    ")\n",
    "\n",
    "# Окончательный конвейер\n",
    "pipeline_end = Pipeline(\n",
    "  [\n",
    "    (\"features_preprocessing\", features_preprocessing),\n",
    "    (\"drop_columns\", drop_columns),\n",
    "    (\"custom_features\", JioMartFeatures()), # Добавляем custom_features\n",
    "  ]\n",
    ")\n",
    "\n",
    "# Загрузка данных\n",
    "df = pd.read_csv(\"..//static//csv//jio_mart_items.csv\")\n",
    "\n",
    "# Создаем целевой признак\n",
    "average_price = df['price'].mean()\n",
    "df['above_average_price'] = (df['price'] > average_price).astype(int)\n",
    "\n",
    "# Подготовка данных\n",
    "X = df.drop('above_average_price', axis=1)\n",
    "y = df['above_average_price'].values.ravel()\n",
    "\n",
    "# Проверка наличия столбцов перед применением конвейера\n",
    "required_columns = set(num_columns + cat_columns + columns_to_drop)\n",
    "missing_columns = required_columns - set(X.columns)\n",
    "if missing_columns:\n",
    "    raise KeyError(f\"Missing columns: {missing_columns}\")\n",
    "\n",
    "# Применение конвейера\n",
    "X_processed = pipeline_end.fit_transform(X)\n",
    "\n",
    "# Вывод\n",
    "print(X_processed)\n",
    "print(X_processed.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Формирование набора моделей для регрессии"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/base.py:1473: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples,), for example using ravel().\n",
      "  return fit_method(estimator, *args, **kwargs)\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/base.py:1473: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples,), for example using ravel().\n",
      "  return fit_method(estimator, *args, **kwargs)\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/base.py:1473: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples,), for example using ravel().\n",
      "  return fit_method(estimator, *args, **kwargs)\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Random Forest: Mean Score = 0.9897752006377067, Standard Deviation = 0.012886225390386691\n",
      "Linear Regression: Mean Score = -1.439679711903671e+21, Standard Deviation = 1.9848730981021744e+21\n",
      "Gradient Boosting: Mean Score = 0.990533312551943, Standard Deviation = 0.01338791677558754\n",
      "Support Vector Regression: Mean Score = 0.6408179773886161, Standard Deviation = 0.045968161125540155\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/ensemble/_gb.py:668: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  y = column_or_1d(y, warn=True)  # TODO: Is this still required?\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/ensemble/_gb.py:668: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  y = column_or_1d(y, warn=True)  # TODO: Is this still required?\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/ensemble/_gb.py:668: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  y = column_or_1d(y, warn=True)  # TODO: Is this still required?\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/utils/validation.py:1339: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  y = column_or_1d(y, warn=True)\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/utils/validation.py:1339: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  y = column_or_1d(y, warn=True)\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/utils/validation.py:1339: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  y = column_or_1d(y, warn=True)\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/sklearn/preprocessing/_encoders.py:242: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n"
     ]
    }
   ],
   "source": [
    "from sklearn.linear_model import LinearRegression\n",
    "from sklearn.ensemble import RandomForestRegressor\n",
    "from sklearn.model_selection import cross_val_score\n",
    "from sklearn.pipeline import Pipeline\n",
    "from sklearn.ensemble import GradientBoostingRegressor\n",
    "from sklearn.svm import SVR\n",
    "\n",
    "def train_multiple_models(X, y, models, cv=3):\n",
    "    results = {}\n",
    "    for model_name, model in models.items():\n",
    "        # Создаем конвейер для каждой модели\n",
    "        model_pipeline = Pipeline(\n",
    "            [\n",
    "                (\"features_preprocessing\", features_preprocessing),\n",
    "                (\"drop_columns\", drop_columns),\n",
    "                (\"model\", model)  # Используем текущую модель\n",
    "            ]\n",
    "        )\n",
    "        \n",
    "        # Обучаем модель и вычисляем кросс-валидацию\n",
    "        scores = cross_val_score(model_pipeline, X, y, cv=cv, n_jobs=-1)  # Используем все ядра процессора\n",
    "        results[model_name] = {\n",
    "            \"mean_score\": scores.mean(),\n",
    "            \"std_dev\": scores.std()\n",
    "        }\n",
    "    \n",
    "    return results\n",
    "\n",
    "# Определение моделей\n",
    "models = {\n",
    "    \"Random Forest\": RandomForestRegressor(n_estimators=10),  # Уменьшаем количество деревьев\n",
    "    \"Linear Regression\": LinearRegression(),\n",
    "    \"Gradient Boosting\": GradientBoostingRegressor(),\n",
    "    \"Support Vector Regression\": SVR()\n",
    "}\n",
    "\n",
    "# Используем подвыборку данных\n",
    "sample_size = 1000  # Уменьшаем количество данных для обучения\n",
    "X_train_sample = X_train.sample(n=sample_size, random_state=42)\n",
    "y_train_sample = y_train.loc[X_train_sample.index]  # Используем loc для индексации Series\n",
    "\n",
    "# Обучение моделей и вывод результатов\n",
    "results = train_multiple_models(X_train_sample, y_train_sample, models, cv=3)  # Уменьшаем количество фолдов\n",
    "\n",
    "# Вывод результатов\n",
    "for model_name, scores in results.items():\n",
    "    print(f\"{model_name}: Mean Score = {scores['mean_score']}, Standard Deviation = {scores['std_dev']}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Модель: Random Forest\n",
    "- **Mean Score**: 0.9897752006377067\n",
    "- **Standard Deviation**: 0.012886225390386691\n",
    "**Описание**:\n",
    "- Random Forest показала очень высокое среднее значение, близкое к 1, что указывает на ее высокую точность в предсказании. Стандартное отклонение также относительно низкое, что говорит о стабильности модели.\n",
    "\n",
    "#### Модель: Linear Regression\n",
    "- **Mean Score**: -1.439679711903671e+21\n",
    "- **Standard Deviation**: 1.9848730981021744e+21\n",
    "**Описание**:\n",
    "- Линейная регрессия показала очень низкое среднее значение с огромным отрицательным числом, что указывает на ее неэффективность в данной задаче. Стандартное отклонение также очень высокое, что говорит о нестабильности модели.\n",
    "\n",
    "#### Модель: Gradient Boosting\n",
    "- **Mean Score**: 0.990533312551943\n",
    "- **Standard Deviation**: 0.01338791677558754\n",
    "**Описание**:\n",
    "- Gradient Boosting показала практически идеальное среднее значение, близкое к 1, что указывает на ее высокую точность в предсказании. Стандартное отклонение относительно низкое, что говорит о стабильности модели.\n",
    "\n",
    "#### Модель: Support Vector Regression\n",
    "- **Mean Score**: 0.6408179773886161\n",
    "- **Standard Deviation**: 0.045968161125540155\n",
    "**Описание**:\n",
    "- Support Vector Regression показала среднее значение около 0.64, что указывает на ее умеренную точность в предсказании. Стандартное отклонение относительно низкое, что говорит о стабильности модели, но она все же уступает Random Forest и Gradient Boosting.\n",
    "\n",
    "\n",
    "1. **Random Forest и Gradient Boosting** демонстрируют высокую точность и стабильность, что делает их наиболее подходящими моделями для данной задачи регрессии.\n",
    "2. **Linear Regression** неэффективна и нестабильна, что указывает на необходимость ее замены на более подходящую модель.\n",
    "3. **Support Vector Regression** показывает умеренную точность и стабильность, но уступает Random Forest и Gradient Boosting в эффективности."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Обучение моделей на обучающем наборе данных и оценка на тестовом для регрессии"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: logistic\n",
      "MSE (train): 0.00954948016942626\n",
      "MSE (test): 0.009857376089702122\n",
      "MAE (train): 0.00954948016942626\n",
      "MAE (test): 0.009857376089702122\n",
      "R2 (train): 0.9105001240660583\n",
      "R2 (test): 0.9085410706513222\n",
      "STD (train): 0.09733042790899017\n",
      "STD (test): 0.09886474010790139\n",
      "----------------------------------------\n",
      "Model: ridge\n",
      "MSE (train): 0.016395841355410088\n",
      "MSE (test): 0.016418692049410096\n",
      "MAE (train): 0.016395841355410088\n",
      "MAE (test): 0.016418692049410096\n",
      "R2 (train): 0.8463344872069661\n",
      "R2 (test): 0.8476637208036084\n",
      "STD (train): 0.12699418323145514\n",
      "STD (test): 0.1270791824052891\n",
      "----------------------------------------\n",
      "Model: decision_tree\n",
      "MSE (train): 0.0\n",
      "MSE (test): 0.0\n",
      "MAE (train): 0.0\n",
      "MAE (test): 0.0\n",
      "R2 (train): 1.0\n",
      "R2 (test): 1.0\n",
      "STD (train): 0.0\n",
      "STD (test): 0.0\n",
      "----------------------------------------\n",
      "Model: knn\n",
      "MSE (train): 0.00041586445899114365\n",
      "MSE (test): 0.0004928688044851062\n",
      "MAE (train): 0.00041586445899114365\n",
      "MAE (test): 0.0004928688044851062\n",
      "R2 (train): 0.9961024247577155\n",
      "R2 (test): 0.9954270535325661\n",
      "STD (train): 0.020392609645475155\n",
      "STD (test): 0.022199280947150013\n",
      "----------------------------------------\n",
      "Model: naive_bayes\n",
      "MSE (train): 0.6530150173276857\n",
      "MSE (test): 0.6539752949511752\n",
      "MAE (train): 0.6530150173276857\n",
      "MAE (test): 0.6539752949511752\n",
      "R2 (train): -5.1202036128569794\n",
      "R2 (test): -5.0677283439763485\n",
      "STD (train): 0.4850279840944924\n",
      "STD (test): 0.4855381725252704\n",
      "----------------------------------------\n",
      "Model: gradient_boosting\n",
      "MSE (train): 0.0\n",
      "MSE (test): 0.0\n",
      "MAE (train): 0.0\n",
      "MAE (test): 0.0\n",
      "R2 (train): 1.0\n",
      "R2 (test): 1.0\n",
      "STD (train): 0.0\n",
      "STD (test): 0.0\n",
      "----------------------------------------\n",
      "Model: random_forest\n",
      "MSE (train): 0.0\n",
      "MSE (test): 0.0\n",
      "MAE (train): 0.0\n",
      "MAE (test): 0.0\n",
      "R2 (train): 1.0\n",
      "R2 (test): 1.0\n",
      "STD (train): 0.0\n",
      "STD (test): 0.0\n",
      "----------------------------------------\n",
      "Model: mlp\n",
      "MSE (train): 0.0009703504043126684\n",
      "MSE (test): 0.0010781505098111696\n",
      "MAE (train): 0.0009703504043126684\n",
      "MAE (test): 0.0010781505098111696\n",
      "R2 (train): 0.9909056577680027\n",
      "R2 (test): 0.9899966796024884\n",
      "STD (train): 0.031139749763093583\n",
      "STD (test): 0.03281946301141911\n",
      "----------------------------------------\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "from sklearn import metrics\n",
    "from sklearn.pipeline import Pipeline\n",
    "\n",
    "# Проверка наличия необходимых переменных\n",
    "if 'class_models' not in locals():\n",
    "    raise ValueError(\"class_models is not defined\")\n",
    "if 'X_train' not in locals() or 'X_test' not in locals() or 'y_train' not in locals() or 'y_test' not in locals():\n",
    "    raise ValueError(\"Train/test data is not defined\")\n",
    "\n",
    "# Преобразуем y_train и y_test в одномерные массивы\n",
    "y_train = np.ravel(y_train)  \n",
    "y_test = np.ravel(y_test)      \n",
    "\n",
    "# Инициализация списка для хранения результатов\n",
    "results = []\n",
    "\n",
    "# Проход по моделям и оценка их качества\n",
    "for model_name in class_models.keys():\n",
    "    print(f\"Model: {model_name}\")\n",
    "    \n",
    "    # Извлечение модели из словаря\n",
    "    model = class_models[model_name][\"model\"]\n",
    "    \n",
    "    # Создание пайплайна\n",
    "    model_pipeline = Pipeline([(\"pipeline\", pipeline_end), (\"model\", model)])\n",
    "    \n",
    "    # Обучение модели\n",
    "    model_pipeline.fit(X_train, y_train)\n",
    "\n",
    "    # Предсказание для обучающей и тестовой выборки\n",
    "    y_train_predict = model_pipeline.predict(X_train)\n",
    "    y_test_predict = model_pipeline.predict(X_test)\n",
    "\n",
    "    # Сохранение пайплайна и предсказаний\n",
    "    class_models[model_name][\"pipeline\"] = model_pipeline\n",
    "    class_models[model_name][\"preds\"] = y_test_predict\n",
    "\n",
    "    # Вычисление метрик для регрессии\n",
    "    class_models[model_name][\"MSE_train\"] = metrics.mean_squared_error(y_train, y_train_predict)\n",
    "    class_models[model_name][\"MSE_test\"] = metrics.mean_squared_error(y_test, y_test_predict)\n",
    "    class_models[model_name][\"MAE_train\"] = metrics.mean_absolute_error(y_train, y_train_predict)\n",
    "    class_models[model_name][\"MAE_test\"] = metrics.mean_absolute_error(y_test, y_test_predict)\n",
    "    class_models[model_name][\"R2_train\"] = metrics.r2_score(y_train, y_train_predict)\n",
    "    class_models[model_name][\"R2_test\"] = metrics.r2_score(y_test, y_test_predict)\n",
    "\n",
    "    # Дополнительные метрики\n",
    "    class_models[model_name][\"STD_train\"] = np.std(y_train - y_train_predict)\n",
    "    class_models[model_name][\"STD_test\"] = np.std(y_test - y_test_predict)\n",
    "\n",
    "    # Вывод результатов для текущей модели\n",
    "    print(f\"MSE (train): {class_models[model_name]['MSE_train']}\")\n",
    "    print(f\"MSE (test): {class_models[model_name]['MSE_test']}\")\n",
    "    print(f\"MAE (train): {class_models[model_name]['MAE_train']}\")\n",
    "    print(f\"MAE (test): {class_models[model_name]['MAE_test']}\")\n",
    "    print(f\"R2 (train): {class_models[model_name]['R2_train']}\")\n",
    "    print(f\"R2 (test): {class_models[model_name]['R2_test']}\")\n",
    "    print(f\"STD (train): {class_models[model_name]['STD_train']}\")\n",
    "    print(f\"STD (test): {class_models[model_name]['STD_test']}\")\n",
    "    print(\"-\" * 40)  # Разделитель для разных моделей"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Пример использования обученной модели (конвейера регрессии) для предсказания"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: RandomForest\n",
      "MSE (train): 8419071.042944524\n",
      "MSE (test): 1708514.4521493362\n",
      "MAE (train): 11.216263715771229\n",
      "MAE (test): 14.19769129925748\n",
      "R2 (train): 0.9638189510993855\n",
      "R2 (test): 0.9949568688066726\n",
      "----------------------------------------\n",
      "Прогнозируемая цена: 5.77\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "from sklearn import metrics\n",
    "from sklearn.pipeline import Pipeline\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.ensemble import RandomForestRegressor \n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.compose import ColumnTransformer\n",
    "from sklearn.impute import SimpleImputer\n",
    "from sklearn.preprocessing import OneHotEncoder\n",
    "\n",
    "# 1. Загрузка данных\n",
    "data = pd.read_csv(\"..//static//csv//jio_mart_items.csv\") \n",
    "\n",
    "# 2. Подготовка данных для прогноза\n",
    "average_price = data['price'].mean()\n",
    "data['above_average_price'] = (data['price'] > average_price).astype(int) \n",
    "\n",
    "# Удаляем строки с пропущенными значениями в столбце 'price'\n",
    "data = data.dropna(subset=['price'])\n",
    "\n",
    "# Предикторы и целевая переменная\n",
    "X = data.drop('above_average_price', axis=1)  # Удаляем только 'above_average_price'\n",
    "y = data['price']\n",
    "\n",
    "# 3. Инициализация модели и пайплайна\n",
    "class_models = {\n",
    "  \"RandomForest\": {\n",
    "    \"model\": RandomForestRegressor(n_estimators=100, random_state=42),\n",
    "  }\n",
    "}\n",
    "\n",
    "# Предобработка признаков\n",
    "num_columns = ['price']\n",
    "cat_columns = ['category', 'sub_category']\n",
    "\n",
    "# Проверка наличия столбцов перед предобработкой\n",
    "required_columns = set(num_columns + cat_columns)\n",
    "missing_columns = required_columns - set(X.columns)\n",
    "if missing_columns:\n",
    "    raise KeyError(f\"Missing columns: {missing_columns}\")\n",
    "\n",
    "# Преобразование числовых признаков\n",
    "num_transformer = Pipeline(steps=[\n",
    "  ('imputer', SimpleImputer(strategy='median')),\n",
    "  ('scaler', StandardScaler())\n",
    "])\n",
    "\n",
    "# Преобразование категориальных признаков\n",
    "cat_transformer = Pipeline(steps=[\n",
    "  ('imputer', SimpleImputer(strategy='constant', fill_value='unknown')),\n",
    "  ('onehot', OneHotEncoder(handle_unknown='ignore', sparse_output=False, drop=\"first\"))\n",
    "])\n",
    "\n",
    "# Создание конвейера предобработки\n",
    "preprocessor = ColumnTransformer(\n",
    "  transformers=[\n",
    "    ('num', num_transformer, num_columns),\n",
    "    ('cat', cat_transformer, cat_columns)\n",
    "  ])\n",
    "\n",
    "# Создание конвейера модели\n",
    "pipeline_end = Pipeline(steps=[\n",
    "  ('preprocessor', preprocessor),\n",
    "  # ('model', model) # Модель добавляется в цикле\n",
    "])\n",
    "\n",
    "results = []\n",
    "\n",
    "# 4. Обучение модели и оценка\n",
    "for model_name in class_models.keys():\n",
    "  print(f\"Model: {model_name}\")\n",
    "\n",
    "  model = class_models[model_name][\"model\"]\n",
    "  model_pipeline = Pipeline(steps=[\n",
    "    ('preprocessor', preprocessor),\n",
    "    ('model', model)\n",
    "  ])\n",
    "\n",
    "  # Разделение данных\n",
    "  X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)\n",
    "\n",
    "  # Обучение модели\n",
    "  model_pipeline.fit(X_train, y_train)\n",
    "\n",
    "  # Предсказание\n",
    "  y_train_predict = model_pipeline.predict(X_train)\n",
    "  y_test_predict = model_pipeline.predict(X_test)\n",
    "\n",
    "  # Сохранение результатов\n",
    "  class_models[model_name][\"preds\"] = y_test_predict\n",
    "\n",
    "  # Вычисление метрик\n",
    "  class_models[model_name][\"MSE_train\"] = metrics.mean_squared_error(y_train, y_train_predict)\n",
    "  class_models[model_name][\"MSE_test\"] = metrics.mean_squared_error(y_test, y_test_predict)\n",
    "  class_models[model_name][\"MAE_train\"] = metrics.mean_absolute_error(y_train, y_train_predict)\n",
    "  class_models[model_name][\"MAE_test\"] = metrics.mean_absolute_error(y_test, y_test_predict)\n",
    "  class_models[model_name][\"R2_train\"] = metrics.r2_score(y_train, y_train_predict)\n",
    "  class_models[model_name][\"R2_test\"] = metrics.r2_score(y_test, y_test_predict)\n",
    "\n",
    "  # Вывод результатов\n",
    "  print(f\"MSE (train): {class_models[model_name]['MSE_train']}\")\n",
    "  print(f\"MSE (test): {class_models[model_name]['MSE_test']}\")\n",
    "  print(f\"MAE (train): {class_models[model_name]['MAE_train']}\")\n",
    "  print(f\"MAE (test): {class_models[model_name]['MAE_test']}\")\n",
    "  print(f\"R2 (train): {class_models[model_name]['R2_train']}\")\n",
    "  print(f\"R2 (test): {class_models[model_name]['R2_test']}\")\n",
    "  print(\"-\" * 40)\n",
    "\n",
    "# Прогнозирование цены для нового товара\n",
    "new_item_data = pd.DataFrame({\n",
    "  'category': ['Electronics'],\n",
    "  'sub_category': ['Smartphones'], \n",
    "  'price': [0]  # Добавляем столбец 'price' с нулевым значением\n",
    "})\n",
    "\n",
    "predicted_price = model_pipeline.predict(new_item_data)\n",
    "print(f\"Прогнозируемая цена: {predicted_price[0]}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Подбор гиперпараметров методом поиска по сетке"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting 3 folds for each of 36 candidates, totalling 108 fits\n",
      "[CV] END max_depth=None, min_samples_split=2, n_estimators=50; total time=  12.4s\n",
      "[CV] END max_depth=None, min_samples_split=2, n_estimators=50; total time=  12.6s\n",
      "[CV] END max_depth=None, min_samples_split=2, n_estimators=50; total time=  12.6s\n",
      "[CV] END max_depth=None, min_samples_split=2, n_estimators=100; total time=  23.3s\n",
      "[CV] END max_depth=None, min_samples_split=2, n_estimators=100; total time=  23.2s\n",
      "[CV] END max_depth=None, min_samples_split=2, n_estimators=100; total time=  23.2s\n",
      "[CV] END max_depth=None, min_samples_split=5, n_estimators=50; total time=  10.8s\n",
      "[CV] END max_depth=None, min_samples_split=5, n_estimators=50; total time=  11.2s\n",
      "[CV] END max_depth=None, min_samples_split=5, n_estimators=50; total time=  11.2s\n",
      "[CV] END max_depth=None, min_samples_split=2, n_estimators=200; total time=  44.9s\n",
      "[CV] END max_depth=None, min_samples_split=5, n_estimators=100; total time=  21.9s\n",
      "[CV] END max_depth=None, min_samples_split=5, n_estimators=100; total time=  22.0s\n",
      "[CV] END max_depth=None, min_samples_split=2, n_estimators=200; total time=  45.4s\n",
      "[CV] END max_depth=None, min_samples_split=5, n_estimators=100; total time=  22.2s\n",
      "[CV] END max_depth=None, min_samples_split=10, n_estimators=50; total time=  12.0s\n",
      "[CV] END max_depth=None, min_samples_split=10, n_estimators=50; total time=  12.2s\n",
      "[CV] END max_depth=None, min_samples_split=10, n_estimators=50; total time=  12.3s\n",
      "[CV] END max_depth=None, min_samples_split=2, n_estimators=200; total time=  46.4s\n",
      "[CV] END max_depth=None, min_samples_split=10, n_estimators=100; total time=  23.9s\n",
      "[CV] END max_depth=None, min_samples_split=5, n_estimators=200; total time=  46.0s\n",
      "[CV] END .max_depth=10, min_samples_split=2, n_estimators=50; total time=   7.5s\n",
      "[CV] END max_depth=None, min_samples_split=5, n_estimators=200; total time=  47.1s\n",
      "[CV] END max_depth=None, min_samples_split=10, n_estimators=100; total time=  24.2s\n",
      "[CV] END max_depth=None, min_samples_split=10, n_estimators=100; total time=  24.4s\n",
      "[CV] END .max_depth=10, min_samples_split=2, n_estimators=50; total time=   8.1s\n",
      "[CV] END .max_depth=10, min_samples_split=2, n_estimators=50; total time=   7.9s\n",
      "[CV] END max_depth=None, min_samples_split=5, n_estimators=200; total time=  48.2s\n",
      "[CV] END max_depth=10, min_samples_split=2, n_estimators=100; total time=  15.7s\n",
      "[CV] END max_depth=10, min_samples_split=2, n_estimators=100; total time=  15.9s\n",
      "[CV] END max_depth=10, min_samples_split=2, n_estimators=100; total time=  15.2s\n",
      "[CV] END .max_depth=10, min_samples_split=5, n_estimators=50; total time=   7.6s\n",
      "[CV] END max_depth=None, min_samples_split=10, n_estimators=200; total time=  48.2s\n",
      "[CV] END max_depth=None, min_samples_split=10, n_estimators=200; total time=  48.3s\n",
      "[CV] END .max_depth=10, min_samples_split=5, n_estimators=50; total time=   7.9s\n",
      "[CV] END .max_depth=10, min_samples_split=5, n_estimators=50; total time=   8.1s\n",
      "[CV] END max_depth=None, min_samples_split=10, n_estimators=200; total time=  50.2s\n",
      "[CV] END max_depth=10, min_samples_split=2, n_estimators=200; total time=  32.1s\n",
      "[CV] END max_depth=10, min_samples_split=5, n_estimators=100; total time=  16.6s\n",
      "[CV] END max_depth=10, min_samples_split=5, n_estimators=100; total time=  17.1s\n",
      "[CV] END max_depth=10, min_samples_split=5, n_estimators=100; total time=  16.8s\n",
      "[CV] END max_depth=10, min_samples_split=2, n_estimators=200; total time=  32.8s\n",
      "[CV] END max_depth=10, min_samples_split=2, n_estimators=200; total time=  32.8s\n",
      "[CV] END max_depth=10, min_samples_split=10, n_estimators=50; total time=   8.2s\n",
      "[CV] END max_depth=10, min_samples_split=10, n_estimators=50; total time=   8.1s\n",
      "[CV] END max_depth=10, min_samples_split=10, n_estimators=50; total time=   8.2s\n",
      "[CV] END max_depth=10, min_samples_split=10, n_estimators=100; total time=  15.4s\n",
      "[CV] END max_depth=10, min_samples_split=5, n_estimators=200; total time=  31.9s\n",
      "[CV] END max_depth=10, min_samples_split=10, n_estimators=100; total time=  15.8s\n",
      "[CV] END max_depth=10, min_samples_split=10, n_estimators=100; total time=  15.8s\n",
      "[CV] END max_depth=10, min_samples_split=5, n_estimators=200; total time=  32.7s\n",
      "[CV] END max_depth=10, min_samples_split=5, n_estimators=200; total time=  32.4s\n",
      "[CV] END .max_depth=20, min_samples_split=2, n_estimators=50; total time=  11.0s\n",
      "[CV] END .max_depth=20, min_samples_split=2, n_estimators=50; total time=  11.1s\n",
      "[CV] END .max_depth=20, min_samples_split=2, n_estimators=50; total time=  11.2s\n",
      "[CV] END max_depth=10, min_samples_split=10, n_estimators=200; total time=  31.4s\n",
      "[CV] END max_depth=10, min_samples_split=10, n_estimators=200; total time=  32.7s\n",
      "[CV] END max_depth=10, min_samples_split=10, n_estimators=200; total time=  32.1s\n",
      "[CV] END max_depth=20, min_samples_split=2, n_estimators=100; total time=  21.6s\n",
      "[CV] END max_depth=20, min_samples_split=2, n_estimators=100; total time=  22.2s\n",
      "[CV] END .max_depth=20, min_samples_split=5, n_estimators=50; total time=  11.7s\n",
      "[CV] END max_depth=20, min_samples_split=2, n_estimators=100; total time=  22.2s\n",
      "[CV] END .max_depth=20, min_samples_split=5, n_estimators=50; total time=  12.2s\n",
      "[CV] END .max_depth=20, min_samples_split=5, n_estimators=50; total time=  12.4s\n",
      "[CV] END max_depth=20, min_samples_split=5, n_estimators=100; total time=  24.3s\n",
      "[CV] END max_depth=20, min_samples_split=5, n_estimators=100; total time=  23.7s\n",
      "[CV] END max_depth=20, min_samples_split=5, n_estimators=100; total time=  24.7s\n",
      "[CV] END max_depth=20, min_samples_split=2, n_estimators=200; total time=  46.2s\n",
      "[CV] END max_depth=20, min_samples_split=2, n_estimators=200; total time=  46.6s\n",
      "[CV] END max_depth=20, min_samples_split=2, n_estimators=200; total time=  48.0s\n",
      "[CV] END max_depth=20, min_samples_split=10, n_estimators=50; total time=  11.8s\n",
      "[CV] END max_depth=20, min_samples_split=10, n_estimators=50; total time=  11.9s\n",
      "[CV] END max_depth=20, min_samples_split=10, n_estimators=50; total time=  11.8s\n",
      "[CV] END max_depth=20, min_samples_split=10, n_estimators=100; total time=  24.2s\n",
      "[CV] END max_depth=20, min_samples_split=5, n_estimators=200; total time=  47.3s\n",
      "[CV] END max_depth=20, min_samples_split=5, n_estimators=200; total time=  49.4s\n",
      "[CV] END max_depth=20, min_samples_split=10, n_estimators=100; total time=  25.3s\n",
      "[CV] END max_depth=20, min_samples_split=10, n_estimators=100; total time=  25.8s\n",
      "[CV] END .max_depth=30, min_samples_split=2, n_estimators=50; total time=  14.1s\n",
      "[CV] END .max_depth=30, min_samples_split=2, n_estimators=50; total time=  14.5s\n",
      "[CV] END max_depth=20, min_samples_split=5, n_estimators=200; total time=  50.1s\n",
      "[CV] END .max_depth=30, min_samples_split=2, n_estimators=50; total time=  14.1s\n",
      "[CV] END max_depth=20, min_samples_split=10, n_estimators=200; total time=  50.5s\n",
      "[CV] END max_depth=20, min_samples_split=10, n_estimators=200; total time=  50.9s\n",
      "[CV] END max_depth=30, min_samples_split=2, n_estimators=100; total time=  28.5s\n",
      "[CV] END max_depth=30, min_samples_split=2, n_estimators=100; total time=  30.1s\n",
      "[CV] END max_depth=30, min_samples_split=2, n_estimators=100; total time=  29.8s\n",
      "[CV] END .max_depth=30, min_samples_split=5, n_estimators=50; total time=  14.6s\n",
      "[CV] END max_depth=20, min_samples_split=10, n_estimators=200; total time=  52.1s\n",
      "[CV] END .max_depth=30, min_samples_split=5, n_estimators=50; total time=  15.1s\n",
      "[CV] END .max_depth=30, min_samples_split=5, n_estimators=50; total time=  14.4s\n",
      "[CV] END max_depth=30, min_samples_split=2, n_estimators=200; total time=  57.7s\n",
      "[CV] END max_depth=30, min_samples_split=5, n_estimators=100; total time=  28.2s\n",
      "[CV] END max_depth=30, min_samples_split=2, n_estimators=200; total time=  57.7s\n",
      "[CV] END max_depth=30, min_samples_split=5, n_estimators=100; total time=  29.2s\n",
      "[CV] END max_depth=30, min_samples_split=5, n_estimators=100; total time=  29.3s\n",
      "[CV] END max_depth=30, min_samples_split=10, n_estimators=50; total time=  15.3s\n",
      "[CV] END max_depth=30, min_samples_split=10, n_estimators=50; total time=  15.5s\n",
      "[CV] END max_depth=30, min_samples_split=2, n_estimators=200; total time=  59.2s\n",
      "[CV] END max_depth=30, min_samples_split=10, n_estimators=50; total time=  15.3s\n",
      "[CV] END max_depth=30, min_samples_split=10, n_estimators=100; total time=  29.4s\n",
      "[CV] END max_depth=30, min_samples_split=5, n_estimators=200; total time=  58.3s\n",
      "[CV] END max_depth=30, min_samples_split=5, n_estimators=200; total time=  59.1s\n",
      "[CV] END max_depth=30, min_samples_split=10, n_estimators=100; total time=  29.0s\n",
      "[CV] END max_depth=30, min_samples_split=10, n_estimators=100; total time=  29.0s\n",
      "[CV] END max_depth=30, min_samples_split=5, n_estimators=200; total time=  53.8s\n",
      "[CV] END max_depth=30, min_samples_split=10, n_estimators=200; total time=  44.9s\n",
      "[CV] END max_depth=30, min_samples_split=10, n_estimators=200; total time=  45.4s\n",
      "[CV] END max_depth=30, min_samples_split=10, n_estimators=200; total time=  35.2s\n",
      "Лучшие параметры: {'max_depth': 10, 'min_samples_split': 10, 'n_estimators': 100}\n",
      "Лучший результат (MSE): 206320633.70862785\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "from sklearn import metrics\n",
    "from sklearn.pipeline import Pipeline\n",
    "from sklearn.model_selection import train_test_split, GridSearchCV\n",
    "from sklearn.ensemble import RandomForestRegressor\n",
    "from sklearn.preprocessing import StandardScaler, OneHotEncoder\n",
    "from sklearn.compose import ColumnTransformer\n",
    "from sklearn.impute import SimpleImputer\n",
    "\n",
    "# Удаление строк с пропущенными значениями (если необходимо)\n",
    "df = df.dropna()\n",
    "\n",
    "# Создание целевой переменной (price)\n",
    "target = df['price']\n",
    "\n",
    "# Удаление целевой переменной из исходных данных\n",
    "features = df.drop(columns=['price'])\n",
    "\n",
    "# Удаление столбцов, которые не будут использоваться (например, href и items)\n",
    "features = features.drop(columns=['href', 'items'])\n",
    "\n",
    "# Определение столбцов для обработки\n",
    "num_columns = features.select_dtypes(include=['number']).columns\n",
    "cat_columns = features.select_dtypes(include=['object']).columns\n",
    "\n",
    "# Препроцессинг числовых столбцов\n",
    "num_imputer = SimpleImputer(strategy=\"median\")  # Используем медиану для заполнения пропущенных значений в числовых столбцах\n",
    "num_scaler = StandardScaler()\n",
    "preprocessing_num = Pipeline(\n",
    "    [\n",
    "        (\"imputer\", num_imputer),\n",
    "        (\"scaler\", num_scaler),\n",
    "    ]\n",
    ")\n",
    "\n",
    "# Препроцессинг категориальных столбцов\n",
    "cat_imputer = SimpleImputer(strategy=\"constant\", fill_value=\"unknown\")  # Используем 'unknown' для заполнения пропущенных значений в категориальных столбцах\n",
    "cat_encoder = OneHotEncoder(handle_unknown=\"ignore\", sparse_output=False, drop=\"first\")\n",
    "preprocessing_cat = Pipeline(\n",
    "    [\n",
    "        (\"imputer\", cat_imputer),\n",
    "        (\"encoder\", cat_encoder),\n",
    "    ]\n",
    ")\n",
    "\n",
    "# Объединение препроцессинга\n",
    "features_preprocessing = ColumnTransformer(\n",
    "    verbose_feature_names_out=False,\n",
    "    transformers=[\n",
    "        (\"preprocessing_num\", preprocessing_num, num_columns),\n",
    "        (\"preprocessing_cat\", preprocessing_cat, cat_columns),\n",
    "    ],\n",
    "    remainder=\"passthrough\"\n",
    ")\n",
    "\n",
    "# Создание финального пайплайна\n",
    "pipeline_end = Pipeline(\n",
    "    [\n",
    "        (\"features_preprocessing\", features_preprocessing),\n",
    "    ]\n",
    ")\n",
    "\n",
    "# Разделение данных на обучающую и тестовую выборки\n",
    "X_train, X_test, y_train, y_test = train_test_split(features, target, test_size=0.2, random_state=42)\n",
    "\n",
    "# Применение пайплайна к данным\n",
    "X_train_processed = pipeline_end.fit_transform(X_train)\n",
    "X_test_processed = pipeline_end.transform(X_test)\n",
    "\n",
    "# 2. Создание и настройка модели случайного леса\n",
    "model = RandomForestRegressor()\n",
    "\n",
    "# Установка параметров для поиска по сетке\n",
    "param_grid = {\n",
    "    'n_estimators': [50, 100, 200],  # Количество деревьев\n",
    "    'max_depth': [None, 10, 20, 30],  # Максимальная глубина дерева\n",
    "    'min_samples_split': [2, 5, 10]   # Минимальное количество образцов для разбиения узла\n",
    "}\n",
    "\n",
    "# 3. Подбор гиперпараметров с помощью Grid Search\n",
    "grid_search = GridSearchCV(estimator=model, param_grid=param_grid,\n",
    "                           scoring='neg_mean_squared_error', cv=3, n_jobs=-1, verbose=2)\n",
    "\n",
    "# Обучение модели на тренировочных данных\n",
    "grid_search.fit(X_train_processed, y_train)\n",
    "\n",
    "# 4. Результаты подбора гиперпараметров\n",
    "print(\"Лучшие параметры:\", grid_search.best_params_)\n",
    "print(\"Лучший результат (MSE):\", -grid_search.best_score_)  # Меняем знак, так как берем отрицательное значение среднеквадратичной ошибки"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Обучение модели с новыми гиперпараметрами и сравнение новых и старых данных"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    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",
      "Fitting 3 folds for each of 36 candidates, totalling 108 fits\n",
      "[CV] END max_depth=None, min_samples_split=2, n_estimators=50; total time=   0.1s\n",
      "[CV] END max_depth=None, min_samples_split=2, n_estimators=50; total time=   0.1s\n",
      "[CV] END max_depth=None, min_samples_split=2, n_estimators=50; total time=   0.1s\n",
      "[CV] END max_depth=None, min_samples_split=2, n_estimators=100; total time=   0.1s\n",
      "[CV] END max_depth=None, min_samples_split=2, n_estimators=100; total time=   0.1s\n",
      "[CV] END max_depth=None, min_samples_split=5, n_estimators=50; total time=   0.1s\n",
      "[CV] END max_depth=None, min_samples_split=2, n_estimators=100; total time=   0.2s\n",
      "[CV] END max_depth=None, min_samples_split=5, n_estimators=50; total time=   0.1s\n",
      "[CV] END max_depth=None, min_samples_split=5, n_estimators=50; total time=   0.1s\n",
      "[CV] END max_depth=None, min_samples_split=2, n_estimators=200; total time=   0.2s\n",
      "[CV] END max_depth=None, min_samples_split=2, n_estimators=200; total time=   0.2s\n",
      "[CV] END max_depth=None, min_samples_split=5, n_estimators=100; total time=   0.1s\n",
      "[CV] END max_depth=None, min_samples_split=5, n_estimators=100; total time=   0.1s\n",
      "[CV] END max_depth=None, min_samples_split=2, n_estimators=200; total time=   0.2s\n",
      "[CV] END max_depth=None, min_samples_split=5, n_estimators=100; total time=   0.1s\n",
      "[CV] END max_depth=None, min_samples_split=10, n_estimators=50; total time=   0.1s\n",
      "[CV] END max_depth=None, min_samples_split=10, n_estimators=50; total time=   0.1s\n",
      "[CV] END max_depth=None, min_samples_split=10, n_estimators=50; total time=   0.0s\n",
      "[CV] END max_depth=None, min_samples_split=10, n_estimators=100; total time=   0.1s\n",
      "[CV] END max_depth=None, min_samples_split=5, n_estimators=200; total time=   0.2s\n",
      "[CV] END max_depth=None, min_samples_split=10, n_estimators=100; total time=   0.1s\n",
      "[CV] END .max_depth=10, min_samples_split=2, n_estimators=50; total time=   0.1s\n",
      "[CV] END max_depth=None, min_samples_split=5, n_estimators=200; total time=   0.2s\n",
      "[CV] END max_depth=None, min_samples_split=10, n_estimators=200; total time=   0.2s\n",
      "[CV] END max_depth=None, min_samples_split=10, n_estimators=100; total time=   0.1s\n",
      "[CV] END .max_depth=10, min_samples_split=2, n_estimators=50; total time=   0.0s\n",
      "[CV] END max_depth=10, min_samples_split=2, n_estimators=100; total time=   0.1s\n",
      "[CV] END max_depth=10, min_samples_split=2, n_estimators=100; total time=   0.1s\n",
      "[CV] END .max_depth=10, min_samples_split=5, n_estimators=50; total time=   0.0s\n",
      "[CV] END max_depth=None, min_samples_split=10, n_estimators=200; total time=   0.2s\n",
      "[CV] END .max_depth=10, min_samples_split=5, n_estimators=50; total time=   0.0s\n",
      "[CV] END .max_depth=10, min_samples_split=2, n_estimators=50; total time=   0.0s\n",
      "[CV] END max_depth=10, min_samples_split=2, n_estimators=100; total time=   0.1s\n",
      "[CV] END max_depth=None, min_samples_split=10, n_estimators=200; total time=   0.2s\n",
      "[CV] END .max_depth=10, min_samples_split=5, n_estimators=50; total time=   0.1s\n",
      "[CV] END max_depth=None, min_samples_split=5, n_estimators=200; total time=   0.2s\n",
      "[CV] END max_depth=10, min_samples_split=2, n_estimators=200; total time=   0.2s\n",
      "[CV] END max_depth=10, min_samples_split=10, n_estimators=50; total time=   0.0s\n",
      "[CV] END max_depth=10, min_samples_split=5, n_estimators=100; total time=   0.1s\n",
      "[CV] END max_depth=10, min_samples_split=2, n_estimators=200; total time=   0.2s\n",
      "[CV] END max_depth=10, min_samples_split=5, n_estimators=100; total time=   0.1s\n",
      "[CV] END max_depth=10, min_samples_split=10, n_estimators=50; total time=   0.0s\n",
      "[CV] END max_depth=10, min_samples_split=5, n_estimators=100; total time=   0.1s\n",
      "[CV] END max_depth=10, min_samples_split=5, n_estimators=200; total time=   0.1s\n",
      "[CV] END max_depth=10, min_samples_split=10, n_estimators=100; total time=   0.1s\n",
      "[CV] END .max_depth=20, min_samples_split=2, n_estimators=50; total time=   0.0s\n",
      "[CV] END max_depth=10, min_samples_split=5, n_estimators=200; total time=   0.2s\n",
      "[CV] END max_depth=10, min_samples_split=10, n_estimators=100; total time=   0.1s\n",
      "[CV] END max_depth=10, min_samples_split=2, n_estimators=200; total time=   0.2s\n",
      "[CV] END .max_depth=20, min_samples_split=2, n_estimators=50; total time=   0.0s\n",
      "[CV] END max_depth=10, min_samples_split=10, n_estimators=50; total time=   0.0s\n",
      "[CV] END max_depth=10, min_samples_split=10, n_estimators=100; total time=   0.1s\n",
      "[CV] END .max_depth=20, min_samples_split=2, n_estimators=50; total time=   0.1s\n",
      "[CV] END max_depth=10, min_samples_split=10, n_estimators=200; total time=   0.2s\n",
      "[CV] END max_depth=10, min_samples_split=5, n_estimators=200; total time=   0.2s\n",
      "[CV] END max_depth=20, min_samples_split=2, n_estimators=100; total time=   0.1s\n",
      "[CV] END max_depth=10, min_samples_split=10, n_estimators=200; total time=   0.1s\n",
      "[CV] END max_depth=20, min_samples_split=2, n_estimators=100; total time=   0.1s\n",
      "[CV] END .max_depth=20, min_samples_split=5, n_estimators=50; total time=   0.0s\n",
      "[CV] END max_depth=20, min_samples_split=2, n_estimators=100; total time=   0.1s\n",
      "[CV] END max_depth=20, min_samples_split=2, n_estimators=200; total time=   0.2s\n",
      "[CV] END max_depth=20, min_samples_split=5, n_estimators=100; total time=   0.1s\n",
      "[CV] END .max_depth=20, min_samples_split=5, n_estimators=50; total time=   0.0s\n",
      "[CV] END .max_depth=20, min_samples_split=5, n_estimators=50; total time=   0.0s\n",
      "[CV] END max_depth=20, min_samples_split=2, n_estimators=200; total time=   0.2s\n",
      "[CV] END max_depth=10, min_samples_split=10, n_estimators=200; total time=   0.2s\n",
      "[CV] END max_depth=20, min_samples_split=5, n_estimators=100; total time=   0.1s\n",
      "[CV] END max_depth=20, min_samples_split=10, n_estimators=50; total time=   0.0s\n",
      "[CV] END max_depth=20, min_samples_split=10, n_estimators=50; total time=   0.0s\n",
      "[CV] END max_depth=20, min_samples_split=10, n_estimators=50; total time=   0.0s\n",
      "[CV] END max_depth=20, min_samples_split=10, n_estimators=100; total time=   0.1s\n",
      "[CV] END max_depth=20, min_samples_split=10, n_estimators=100; total time=   0.1s\n",
      "[CV] END max_depth=20, min_samples_split=5, n_estimators=200; total time=   0.1s\n",
      "[CV] END max_depth=20, min_samples_split=5, n_estimators=100; total time=   0.1s\n",
      "[CV] END max_depth=20, min_samples_split=5, n_estimators=200; total time=   0.2s\n",
      "[CV] END .max_depth=30, min_samples_split=2, n_estimators=50; total time=   0.1s\n",
      "[CV] END max_depth=20, min_samples_split=2, n_estimators=200; total time=   0.2s\n",
      "[CV] END max_depth=30, min_samples_split=2, n_estimators=100; total time=   0.1s\n",
      "[CV] END .max_depth=30, min_samples_split=2, n_estimators=50; total time=   0.1s\n",
      "[CV] END max_depth=20, min_samples_split=10, n_estimators=100; total time=   0.1s\n",
      "[CV] END max_depth=30, min_samples_split=2, n_estimators=100; total time=   0.1s\n",
      "[CV] END max_depth=20, min_samples_split=10, n_estimators=200; total time=   0.2s\n",
      "[CV] END max_depth=20, min_samples_split=10, n_estimators=200; total time=   0.2s\n",
      "[CV] END .max_depth=30, min_samples_split=5, n_estimators=50; total time=   0.1s\n",
      "[CV] END max_depth=30, min_samples_split=2, n_estimators=100; total time=   0.1s\n",
      "[CV] END .max_depth=30, min_samples_split=2, n_estimators=50; total time=   0.0s\n",
      "[CV] END .max_depth=30, min_samples_split=5, n_estimators=50; total time=   0.0s\n",
      "[CV] END max_depth=30, min_samples_split=5, n_estimators=100; total time=   0.1s\n",
      "[CV] END max_depth=20, min_samples_split=5, n_estimators=200; total time=   0.2s\n",
      "[CV] END max_depth=30, min_samples_split=2, n_estimators=200; total time=   0.2s\n",
      "[CV] END max_depth=30, min_samples_split=5, n_estimators=100; total time=   0.1s\n",
      "[CV] END max_depth=20, min_samples_split=10, n_estimators=200; total time=   0.2s\n",
      "[CV] END max_depth=30, min_samples_split=2, n_estimators=200; total time=   0.2s\n",
      "[CV] END max_depth=30, min_samples_split=10, n_estimators=50; total time=   0.0s\n",
      "[CV] END max_depth=30, min_samples_split=5, n_estimators=200; total time=   0.2s\n",
      "[CV] END max_depth=30, min_samples_split=10, n_estimators=50; total time=   0.0s\n",
      "[CV] END max_depth=30, min_samples_split=10, n_estimators=50; total time=   0.0s\n",
      "[CV] END max_depth=30, min_samples_split=5, n_estimators=200; total time=   0.2s\n",
      "[CV] END max_depth=30, min_samples_split=10, n_estimators=100; total time=   0.1s\n",
      "[CV] END max_depth=30, min_samples_split=2, n_estimators=200; total time=   0.2s\n",
      "[CV] END max_depth=30, min_samples_split=5, n_estimators=200; total time=   0.2s\n",
      "[CV] END max_depth=30, min_samples_split=10, n_estimators=100; total time=   0.1s\n",
      "[CV] END max_depth=30, min_samples_split=10, n_estimators=100; total time=   0.1s\n",
      "[CV] END max_depth=30, min_samples_split=10, n_estimators=200; total time=   0.1s\n",
      "[CV] END max_depth=30, min_samples_split=10, n_estimators=200; total time=   0.1s\n",
      "[CV] END max_depth=30, min_samples_split=10, n_estimators=200; total time=   0.2s\n",
      "[CV] END .max_depth=30, min_samples_split=5, n_estimators=50; total time=   0.0s\n",
      "[CV] END max_depth=30, min_samples_split=5, n_estimators=100; total time=   0.0s\n",
      "Старые параметры: {'max_depth': 30, 'min_samples_split': 5, 'n_estimators': 50}\n",
      "Лучший результат (MSE) на старых параметрах: 4352.70053925649\n",
      "\n",
      "Новые параметры: {'max_depth': 10, 'min_samples_split': 10, 'n_estimators': 200}\n",
      "Лучший результат (MSE) на новых параметрах: 4862.953305666657\n",
      "Среднеквадратическая ошибка (MSE) на тестовых данных: 3485.772883899025\n",
      "Корень среднеквадратичной ошибки (RMSE) на тестовых данных: 59.04043431326556\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "from sklearn import metrics\n",
    "from sklearn.ensemble import RandomForestRegressor\n",
    "from sklearn.model_selection import train_test_split, GridSearchCV\n",
    "from sklearn.preprocessing import StandardScaler, OneHotEncoder\n",
    "from sklearn.compose import ColumnTransformer\n",
    "from sklearn.impute import SimpleImputer\n",
    "from sklearn.pipeline import Pipeline\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Загрузка датасета\n",
    "df = pd.read_csv(\"..//static//csv//jio_mart_items.csv\").head(100)\n",
    "\n",
    "# Вывод первых строк для проверки структуры\n",
    "print(df.head())\n",
    "\n",
    "# Целевая переменная\n",
    "target = df['price']\n",
    "\n",
    "# Удаление целевой переменной из признаков\n",
    "features = df.drop(columns=['price', 'href'])\n",
    "\n",
    "# Определение столбцов для обработки\n",
    "num_columns = features.select_dtypes(include=['number']).columns\n",
    "cat_columns = features.select_dtypes(include=['object']).columns\n",
    "\n",
    "# Препроцессинг числовых столбцов\n",
    "num_imputer = SimpleImputer(strategy=\"median\")\n",
    "num_scaler = StandardScaler()\n",
    "preprocessing_num = Pipeline([\n",
    "    (\"imputer\", num_imputer),\n",
    "    (\"scaler\", num_scaler),\n",
    "])\n",
    "\n",
    "# Препроцессинг категориальных столбцов\n",
    "cat_imputer = SimpleImputer(strategy=\"constant\", fill_value=\"unknown\")\n",
    "cat_encoder = OneHotEncoder(handle_unknown=\"ignore\", sparse_output=False, drop=\"first\")\n",
    "preprocessing_cat = Pipeline([\n",
    "    (\"imputer\", cat_imputer),\n",
    "    (\"encoder\", cat_encoder),\n",
    "])\n",
    "\n",
    "# Объединение препроцессинга\n",
    "features_preprocessing = ColumnTransformer(\n",
    "    verbose_feature_names_out=False,\n",
    "    transformers=[\n",
    "        (\"preprocessing_num\", preprocessing_num, num_columns),\n",
    "        (\"preprocessing_cat\", preprocessing_cat, cat_columns),\n",
    "    ],\n",
    "    remainder=\"passthrough\"\n",
    ")\n",
    "\n",
    "# Создание финального пайплайна\n",
    "pipeline_end = Pipeline([\n",
    "    (\"features_preprocessing\", features_preprocessing),\n",
    "])\n",
    "\n",
    "# Разделение данных на обучающую и тестовую выборки\n",
    "X_train, X_test, y_train, y_test = train_test_split(features, target, test_size=0.2, random_state=42)\n",
    "\n",
    "# Применение пайплайна к данным\n",
    "X_train_processed = pipeline_end.fit_transform(X_train)\n",
    "X_test_processed = pipeline_end.transform(X_test)\n",
    "\n",
    "# 1. Настройка параметров для старых значений\n",
    "old_param_grid = {\n",
    "    'n_estimators': [50, 100, 200],\n",
    "    'max_depth': [None, 10, 20, 30],\n",
    "    'min_samples_split': [2, 5, 10]\n",
    "}\n",
    "\n",
    "# Подбор гиперпараметров с помощью Grid Search для старых параметров\n",
    "old_grid_search = GridSearchCV(estimator=RandomForestRegressor(),\n",
    "                               param_grid=old_param_grid,\n",
    "                               scoring='neg_mean_squared_error', cv=3, n_jobs=-1, verbose=2)\n",
    "\n",
    "# Обучение модели на тренировочных данных\n",
    "old_grid_search.fit(X_train_processed, y_train)\n",
    "\n",
    "# Результаты подбора для старых параметров\n",
    "old_best_params = old_grid_search.best_params_\n",
    "old_best_mse = -old_grid_search.best_score_\n",
    "\n",
    "# 2. Настройка параметров для новых значений\n",
    "new_param_grid = {\n",
    "    'n_estimators': [200],\n",
    "    'max_depth': [10],\n",
    "    'min_samples_split': [10]\n",
    "}\n",
    "\n",
    "# Подбор гиперпараметров с помощью Grid Search для новых параметров\n",
    "new_grid_search = GridSearchCV(estimator=RandomForestRegressor(),\n",
    "                               param_grid=new_param_grid,\n",
    "                               scoring='neg_mean_squared_error', cv=2)\n",
    "\n",
    "# Обучение модели на тренировочных данных\n",
    "new_grid_search.fit(X_train_processed, y_train)\n",
    "\n",
    "# Результаты подбора для новых параметров\n",
    "new_best_params = new_grid_search.best_params_\n",
    "new_best_mse = -new_grid_search.best_score_\n",
    "\n",
    "# 5. Обучение модели с лучшими параметрами для новых значений\n",
    "model_best = RandomForestRegressor(**new_best_params)\n",
    "model_best.fit(X_train_processed, y_train)\n",
    "\n",
    "# Прогнозирование на тестовой выборке\n",
    "y_pred = model_best.predict(X_test_processed)\n",
    "\n",
    "# Оценка производительности модели\n",
    "mse = metrics.mean_squared_error(y_test, y_pred)\n",
    "rmse = np.sqrt(mse)\n",
    "\n",
    "# Вывод результатов\n",
    "print(\"Старые параметры:\", old_best_params)\n",
    "print(\"Лучший результат (MSE) на старых параметрах:\", old_best_mse)\n",
    "print(\"\\nНовые параметры:\", new_best_params)\n",
    "print(\"Лучший результат (MSE) на новых параметрах:\", new_best_mse)\n",
    "print(\"Среднеквадратическая ошибка (MSE) на тестовых данных:\", mse)\n",
    "print(\"Корень среднеквадратичной ошибки (RMSE) на тестовых данных:\", rmse)\n",
    "\n",
    "# Обучение модели с лучшими параметрами для старых значений\n",
    "model_old = RandomForestRegressor(**old_best_params)\n",
    "model_old.fit(X_train_processed, y_train)\n",
    "\n",
    "# Прогнозирование на тестовой выборке для старых параметров\n",
    "y_pred_old = model_old.predict(X_test_processed)\n",
    "\n",
    "# Визуализация ошибок\n",
    "plt.figure(figsize=(10, 5))\n",
    "plt.plot(y_test.values, label='Реальные значения', marker='o', linestyle='-', color='black')\n",
    "plt.plot(y_pred_old, label='Предсказанные значения (старые параметры)', marker='x', linestyle='--', color='blue')\n",
    "plt.plot(y_pred, label='Предсказанные значения (новые параметры)', marker='s', linestyle='--', color='orange')\n",
    "plt.xlabel('Объекты')\n",
    "plt.ylabel('Цена')\n",
    "plt.title('Сравнение реальных и предсказанных значений')\n",
    "plt.legend()\n",
    "plt.show()\n"
   ]
  }
 ],
 "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.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}