AIM-PIbd-31-LOBASHOV-I-D/lab_4/lab_4.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Вариант 19:* Данные о миллионерах"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Index(['Rank', 'Name', 'Networth', 'Age', 'Country', 'Source', 'Industry'], dtype='object')\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "\n",
    "df = pd.read_csv(\"C:/Users/goldfest/Desktop/3 курс/MII/AIM-PIbd-31-LOBASHOV-I-D/static/csv/Forbes Billionaires.csv\", sep=\",\")\n",
    "print(df.columns)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Бизнес-цели\n",
    "\n",
    "### Задача классификации\n",
    "Классифицировать людей по уровню состояния (например, низкий, средний, высокий уровень богатства).\n",
    "\n",
    "### Задача регрессии:\n",
    "Прогнозирование состояния миллионеров (Networth):\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Определение достижимого уровня качества модели для первой задачи "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Среднее значение поля 'Networth': 4.8607499999999995\n",
      "   Rank                       Name  Networth  Age        Country  \\\n",
      "0     1                 Elon Musk      219.0   50  United States   \n",
      "1     2                Jeff Bezos      171.0   58  United States   \n",
      "2     3  Bernard Arnault & family      158.0   73         France   \n",
      "3     4                Bill Gates      129.0   66  United States   \n",
      "4     5            Warren Buffett      118.0   91  United States   \n",
      "\n",
      "               Source                Industry  above_average_networth  \n",
      "0       Tesla, SpaceX             Automotive                        1  \n",
      "1              Amazon             Technology                        1  \n",
      "2                LVMH       Fashion & Retail                        1  \n",
      "3           Microsoft             Technology                        1  \n",
      "4  Berkshire Hathaway  Finance & Investments                        1  \n"
     ]
    }
   ],
   "source": [
    "from sklearn import set_config\n",
    "\n",
    "set_config(transform_output=\"pandas\")\n",
    "\n",
    "# Устанавливаем случайное состояние\n",
    "random_state = 42\n",
    "average_networth = df['Networth'].mean()\n",
    "print(f\"Среднее значение поля 'Networth': {average_networth}\")\n",
    "\n",
    "# Создаем новую переменную, указывающую, превышает ли чистое состояние среднее\n",
    "df['above_average_networth'] = (df['Networth'] > average_networth).astype(int)\n",
    "\n",
    "print(df.head())\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Разделение набора данных на обучающую и тестовые выборки (80/20) для задачи классификации\n",
    "\n",
    "Целевой признак -- above_average_networth "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X_train shape: (2080, 8)\n",
      "y_train shape: (2080, 1)\n",
      "X_test shape: (520, 8)\n",
      "y_test shape: (520, 1)\n",
      "X_train:\n",
      "       Rank                 Name  Networth  Age  Country               Source  \\\n",
      "2125  2076      Yogesh Kothari        1.4   73    India  specialty chemicals   \n",
      "1165  1163        Yvonne Bauer        2.7   45  Germany     magazines, media   \n",
      "397    398     Juergen Blickle        6.4   75  Germany           auto parts   \n",
      "1432  1397  Alexander Svetakov        2.2   54   Russia          real estate   \n",
      "1024  1012              Li Min        3.0   56    China        semiconductor   \n",
      "\n",
      "                    Industry  above_average_networth  \n",
      "2125          Manufacturing                        0  \n",
      "1165  Media & Entertainment                        0  \n",
      "397           Manufacturing                        1  \n",
      "1432  Finance & Investments                        0  \n",
      "1024             Technology                        0  \n",
      "y_train:\n",
      "       above_average_networth\n",
      "2125                       0\n",
      "1165                       0\n",
      "397                        1\n",
      "1432                       0\n",
      "1024                       0\n",
      "X_test:\n",
      "       Rank                Name  Networth  Age              Country  \\\n",
      "2437  2324     Horst Wortmann        1.2   80              Germany   \n",
      "2118  2076      Ramesh Juneja        1.4   66                India   \n",
      "1327  1292  Teresita Sy-Coson        2.4   71          Philippines   \n",
      "2063  1929        Myron Wentz        1.5   82  St. Kitts and Nevis   \n",
      "1283  1238      Suh Kyung-bae        2.5   59          South Korea   \n",
      "\n",
      "               Source           Industry  above_average_networth  \n",
      "2437         footwear  Fashion & Retail                        0  \n",
      "2118  pharmaceuticals        Healthcare                        0  \n",
      "1327    diversified       diversified                          0  \n",
      "2063  health products  Fashion & Retail                        0  \n",
      "1283        cosmetics  Fashion & Retail                        0  \n",
      "y_test:\n",
      "       above_average_networth\n",
      "2437                       0\n",
      "2118                       0\n",
      "1327                       0\n",
      "2063                       0\n",
      "1283                       0\n"
     ]
    }
   ],
   "source": [
    "from typing import Tuple\n",
    "from pandas import DataFrame\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "def split_stratified_into_train_val_test(\n",
    "    df_input,\n",
    "    stratify_colname=\"y\",\n",
    "    frac_train=0.6,\n",
    "    frac_val=0.15,\n",
    "    frac_test=0.25,\n",
    "    random_state=None,\n",
    ") -> Tuple[DataFrame, DataFrame, DataFrame, DataFrame, DataFrame, DataFrame]:\n",
    "\n",
    "\n",
    "    if frac_train + frac_val + frac_test != 1.0:\n",
    "        raise ValueError(\n",
    "            \"fractions %f, %f, %f do not add up to 1.0\"\n",
    "            % (frac_train, frac_val, frac_test)\n",
    "        )\n",
    "    if stratify_colname not in df_input.columns:\n",
    "        raise ValueError(\"%s is not a column in the dataframe\" % (stratify_colname))\n",
    "    X = df_input\n",
    "    y = df_input[\n",
    "        [stratify_colname]\n",
    "    ]  \n",
    "    df_train, df_temp, y_train, y_temp = train_test_split(\n",
    "        X, y, stratify=y, test_size=(1.0 - frac_train), random_state=random_state\n",
    "    )\n",
    "    if frac_val <= 0:\n",
    "        assert len(df_input) == len(df_train) + len(df_temp)\n",
    "        return df_train, pd.DataFrame(), df_temp, y_train, pd.DataFrame(), y_temp\n",
    "    relative_frac_test = frac_test / (frac_val + frac_test)\n",
    "    df_val, df_test, y_val, y_test = train_test_split(\n",
    "        df_temp,\n",
    "        y_temp,\n",
    "        stratify=y_temp,\n",
    "        test_size=relative_frac_test,\n",
    "        random_state=random_state,\n",
    "    )\n",
    "    assert len(df_input) == len(df_train) + len(df_val) + len(df_test)\n",
    "    return df_train, df_val, df_test, y_train, y_val, y_test\n",
    "\n",
    "random_state = 42  \n",
    "X_train, X_val, X_test, y_train, y_val, y_test = split_stratified_into_train_val_test(\n",
    "    df, stratify_colname=\"above_average_networth\", frac_train=0.80, frac_val=0, frac_test=0.20, 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())\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Построение конвейеров предобработки  \n",
    "Создадим пайплайн для числовых и категориальных данных.  \n",
    "\n",
    "preprocessing_num -- конвейер для обработки числовых данных: заполнение пропущенных значений и стандартизация\n",
    "\n",
    "preprocessing_cat -- конвейер для обработки категориальных данных: заполнение пропущенных данных и унитарное кодирование\n",
    "\n",
    "features_preprocessing -- трансформер для предобработки признаков\n",
    "\n",
    "features_engineering -- трансформер для конструирования признаков\n",
    "\n",
    "drop_columns -- трансформер для удаления колонок\n",
    "\n",
    "pipeline_end -- основной конвейер предобработки данных и конструирования признаков"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.compose import ColumnTransformer\n",
    "from sklearn.impute import SimpleImputer\n",
    "from sklearn.preprocessing import StandardScaler, OneHotEncoder\n",
    "from sklearn.pipeline import Pipeline\n",
    "# Определение столбцов для обработки\n",
    "columns_to_drop = [\"Name\", \"Rank\"]  # Столбцы, которые можно удалить\n",
    "num_columns = [\"Networth\", \"Age\"]  # Числовые столбцы\n",
    "cat_columns = [\"Country\", \"Source\", \"Industry\"]  # Категориальные столбцы\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",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Демонстрация работы конвейера для предобработки данных при классификации"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "      Networth       Age  Country_Argentina  Country_Australia  \\\n",
      "2125 -0.340947  0.680013                0.0                0.0   \n",
      "1165 -0.211625 -1.475070                0.0                0.0   \n",
      "397   0.156447  0.833948                0.0                0.0   \n",
      "1432 -0.261364 -0.782365                0.0                0.0   \n",
      "1024 -0.181781 -0.628430                0.0                0.0   \n",
      "\n",
      "      Country_Austria  Country_Barbados  Country_Belgium  Country_Belize  \\\n",
      "2125              0.0               0.0              0.0             0.0   \n",
      "1165              0.0               0.0              0.0             0.0   \n",
      "397               0.0               0.0              0.0             0.0   \n",
      "1432              0.0               0.0              0.0             0.0   \n",
      "1024              0.0               0.0              0.0             0.0   \n",
      "\n",
      "      Country_Brazil  Country_Bulgaria  ...  Industry_Manufacturing   \\\n",
      "2125             0.0               0.0  ...                      1.0   \n",
      "1165             0.0               0.0  ...                      0.0   \n",
      "397              0.0               0.0  ...                      1.0   \n",
      "1432             0.0               0.0  ...                      0.0   \n",
      "1024             0.0               0.0  ...                      0.0   \n",
      "\n",
      "      Industry_Media & Entertainment   Industry_Metals & Mining   \\\n",
      "2125                              0.0                        0.0   \n",
      "1165                              1.0                        0.0   \n",
      "397                               0.0                        0.0   \n",
      "1432                              0.0                        0.0   \n",
      "1024                              0.0                        0.0   \n",
      "\n",
      "      Industry_Real Estate   Industry_Service   Industry_Sports   \\\n",
      "2125                    0.0                0.0               0.0   \n",
      "1165                    0.0                0.0               0.0   \n",
      "397                     0.0                0.0               0.0   \n",
      "1432                    0.0                0.0               0.0   \n",
      "1024                    0.0                0.0               0.0   \n",
      "\n",
      "      Industry_Technology   Industry_Telecom   Industry_diversified     \\\n",
      "2125                   0.0                0.0                      0.0   \n",
      "1165                   0.0                0.0                      0.0   \n",
      "397                    0.0                0.0                      0.0   \n",
      "1432                   0.0                0.0                      0.0   \n",
      "1024                   1.0                0.0                      0.0   \n",
      "\n",
      "      above_average_networth  \n",
      "2125                       0  \n",
      "1165                       0  \n",
      "397                        1  \n",
      "1432                       0  \n",
      "1024                       0  \n",
      "\n",
      "[5 rows x 859 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",
    "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": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn import linear_model, tree, neighbors, naive_bayes, ensemble, neural_network\n",
    "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": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: logistic\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\Users\\goldfest\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\sklearn\\preprocessing\\_encoders.py:242: UserWarning: Found unknown categories in columns [0, 1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: ridge\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\Users\\goldfest\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\sklearn\\preprocessing\\_encoders.py:242: UserWarning: Found unknown categories in columns [0, 1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: decision_tree\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\Users\\goldfest\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\sklearn\\preprocessing\\_encoders.py:242: UserWarning: Found unknown categories in columns [0, 1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: knn\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\Users\\goldfest\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\sklearn\\preprocessing\\_encoders.py:242: UserWarning: Found unknown categories in columns [0, 1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: naive_bayes\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\Users\\goldfest\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\sklearn\\preprocessing\\_encoders.py:242: UserWarning: Found unknown categories in columns [0, 1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: gradient_boosting\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\Users\\goldfest\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\sklearn\\preprocessing\\_encoders.py:242: UserWarning: Found unknown categories in columns [0, 1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: random_forest\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\Users\\goldfest\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\sklearn\\preprocessing\\_encoders.py:242: UserWarning: Found unknown categories in columns [0, 1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: mlp\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\Users\\goldfest\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\sklearn\\preprocessing\\_encoders.py:242: UserWarning: Found unknown categories in columns [0, 1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "from sklearn import metrics\n",
    "\n",
    "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",
    "  )\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Сводная таблица оценок качества для использованных моделей классификации"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "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",
    "_, ax = plt.subplots(int(len(class_models) / 2), 2, figsize=(12, 10), sharex=False, sharey=False)\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",
    "plt.subplots_adjust(top=1, bottom=0, hspace=0.4, wspace=0.1)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "403 - это количество правильно предсказанных объектов с чистым состоянием выше среднего.\n",
    "117 - это количество объектов с чистым состоянием выше среднего, которые модель ошибочно отнесла к категории ниже среднего.\n",
    "Результаты говорят о высокой точности в определении объектов с чистым состоянием выше среднего. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Точность, полнота, верность (аккуратность), F-мера"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style type=\"text/css\">\n",
       "#T_7fb0a_row0_col0, #T_7fb0a_row1_col0, #T_7fb0a_row2_col0, #T_7fb0a_row3_col0, #T_7fb0a_row4_col0, #T_7fb0a_row5_col0, #T_7fb0a_row6_col0, #T_7fb0a_row7_col0 {\n",
       "  background-color: #440154;\n",
       "  color: #f1f1f1;\n",
       "}\n",
       "#T_7fb0a_row0_col1, #T_7fb0a_row0_col2, #T_7fb0a_row0_col3, #T_7fb0a_row1_col1, #T_7fb0a_row1_col2, #T_7fb0a_row1_col3, #T_7fb0a_row2_col1, #T_7fb0a_row2_col2, #T_7fb0a_row2_col3, #T_7fb0a_row3_col1, #T_7fb0a_row3_col2, #T_7fb0a_row3_col3, #T_7fb0a_row4_col1, #T_7fb0a_row4_col2, #T_7fb0a_row4_col3, #T_7fb0a_row5_col1, #T_7fb0a_row6_col2, #T_7fb0a_row7_col1 {\n",
       "  background-color: #a8db34;\n",
       "  color: #000000;\n",
       "}\n",
       "#T_7fb0a_row0_col4, #T_7fb0a_row0_col5, #T_7fb0a_row0_col6, #T_7fb0a_row0_col7, #T_7fb0a_row1_col4, #T_7fb0a_row1_col5, #T_7fb0a_row1_col6, #T_7fb0a_row1_col7, #T_7fb0a_row2_col4, #T_7fb0a_row2_col5, #T_7fb0a_row2_col6, #T_7fb0a_row2_col7, #T_7fb0a_row3_col4, #T_7fb0a_row3_col5, #T_7fb0a_row3_col6, #T_7fb0a_row3_col7, #T_7fb0a_row4_col4, #T_7fb0a_row4_col5, #T_7fb0a_row4_col6, #T_7fb0a_row4_col7, #T_7fb0a_row6_col4, #T_7fb0a_row6_col6 {\n",
       "  background-color: #da5a6a;\n",
       "  color: #f1f1f1;\n",
       "}\n",
       "#T_7fb0a_row5_col2 {\n",
       "  background-color: #a0da39;\n",
       "  color: #000000;\n",
       "}\n",
       "#T_7fb0a_row5_col3 {\n",
       "  background-color: #8ed645;\n",
       "  color: #000000;\n",
       "}\n",
       "#T_7fb0a_row5_col4, #T_7fb0a_row5_col6 {\n",
       "  background-color: #d7566c;\n",
       "  color: #f1f1f1;\n",
       "}\n",
       "#T_7fb0a_row5_col5 {\n",
       "  background-color: #d14e72;\n",
       "  color: #f1f1f1;\n",
       "}\n",
       "#T_7fb0a_row5_col7 {\n",
       "  background-color: #d24f71;\n",
       "  color: #f1f1f1;\n",
       "}\n",
       "#T_7fb0a_row6_col1, #T_7fb0a_row7_col2, #T_7fb0a_row7_col3 {\n",
       "  background-color: #26818e;\n",
       "  color: #f1f1f1;\n",
       "}\n",
       "#T_7fb0a_row6_col3 {\n",
       "  background-color: #9bd93c;\n",
       "  color: #000000;\n",
       "}\n",
       "#T_7fb0a_row6_col5 {\n",
       "  background-color: #a11b9b;\n",
       "  color: #f1f1f1;\n",
       "}\n",
       "#T_7fb0a_row6_col7 {\n",
       "  background-color: #aa2395;\n",
       "  color: #f1f1f1;\n",
       "}\n",
       "#T_7fb0a_row7_col4, #T_7fb0a_row7_col5, #T_7fb0a_row7_col6, #T_7fb0a_row7_col7 {\n",
       "  background-color: #4e02a2;\n",
       "  color: #f1f1f1;\n",
       "}\n",
       "</style>\n",
       "<table id=\"T_7fb0a\">\n",
       "  <thead>\n",
       "    <tr>\n",
       "      <th class=\"blank level0\" >&nbsp;</th>\n",
       "      <th id=\"T_7fb0a_level0_col0\" class=\"col_heading level0 col0\" >Precision_train</th>\n",
       "      <th id=\"T_7fb0a_level0_col1\" class=\"col_heading level0 col1\" >Precision_test</th>\n",
       "      <th id=\"T_7fb0a_level0_col2\" class=\"col_heading level0 col2\" >Recall_train</th>\n",
       "      <th id=\"T_7fb0a_level0_col3\" class=\"col_heading level0 col3\" >Recall_test</th>\n",
       "      <th id=\"T_7fb0a_level0_col4\" class=\"col_heading level0 col4\" >Accuracy_train</th>\n",
       "      <th id=\"T_7fb0a_level0_col5\" class=\"col_heading level0 col5\" >Accuracy_test</th>\n",
       "      <th id=\"T_7fb0a_level0_col6\" class=\"col_heading level0 col6\" >F1_train</th>\n",
       "      <th id=\"T_7fb0a_level0_col7\" class=\"col_heading level0 col7\" >F1_test</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th id=\"T_7fb0a_level0_row0\" class=\"row_heading level0 row0\" >logistic</th>\n",
       "      <td id=\"T_7fb0a_row0_col0\" class=\"data row0 col0\" >1.000000</td>\n",
       "      <td id=\"T_7fb0a_row0_col1\" class=\"data row0 col1\" >1.000000</td>\n",
       "      <td id=\"T_7fb0a_row0_col2\" class=\"data row0 col2\" >1.000000</td>\n",
       "      <td id=\"T_7fb0a_row0_col3\" class=\"data row0 col3\" >1.000000</td>\n",
       "      <td id=\"T_7fb0a_row0_col4\" class=\"data row0 col4\" >1.000000</td>\n",
       "      <td id=\"T_7fb0a_row0_col5\" class=\"data row0 col5\" >1.000000</td>\n",
       "      <td id=\"T_7fb0a_row0_col6\" class=\"data row0 col6\" >1.000000</td>\n",
       "      <td id=\"T_7fb0a_row0_col7\" class=\"data row0 col7\" >1.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th id=\"T_7fb0a_level0_row1\" class=\"row_heading level0 row1\" >ridge</th>\n",
       "      <td id=\"T_7fb0a_row1_col0\" class=\"data row1 col0\" >1.000000</td>\n",
       "      <td id=\"T_7fb0a_row1_col1\" class=\"data row1 col1\" >1.000000</td>\n",
       "      <td id=\"T_7fb0a_row1_col2\" class=\"data row1 col2\" >1.000000</td>\n",
       "      <td id=\"T_7fb0a_row1_col3\" class=\"data row1 col3\" >1.000000</td>\n",
       "      <td id=\"T_7fb0a_row1_col4\" class=\"data row1 col4\" >1.000000</td>\n",
       "      <td id=\"T_7fb0a_row1_col5\" class=\"data row1 col5\" >1.000000</td>\n",
       "      <td id=\"T_7fb0a_row1_col6\" class=\"data row1 col6\" >1.000000</td>\n",
       "      <td id=\"T_7fb0a_row1_col7\" class=\"data row1 col7\" >1.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th id=\"T_7fb0a_level0_row2\" class=\"row_heading level0 row2\" >decision_tree</th>\n",
       "      <td id=\"T_7fb0a_row2_col0\" class=\"data row2 col0\" >1.000000</td>\n",
       "      <td id=\"T_7fb0a_row2_col1\" class=\"data row2 col1\" >1.000000</td>\n",
       "      <td id=\"T_7fb0a_row2_col2\" class=\"data row2 col2\" >1.000000</td>\n",
       "      <td id=\"T_7fb0a_row2_col3\" class=\"data row2 col3\" >1.000000</td>\n",
       "      <td id=\"T_7fb0a_row2_col4\" class=\"data row2 col4\" >1.000000</td>\n",
       "      <td id=\"T_7fb0a_row2_col5\" class=\"data row2 col5\" >1.000000</td>\n",
       "      <td id=\"T_7fb0a_row2_col6\" class=\"data row2 col6\" >1.000000</td>\n",
       "      <td id=\"T_7fb0a_row2_col7\" class=\"data row2 col7\" >1.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th id=\"T_7fb0a_level0_row3\" class=\"row_heading level0 row3\" >gradient_boosting</th>\n",
       "      <td id=\"T_7fb0a_row3_col0\" class=\"data row3 col0\" >1.000000</td>\n",
       "      <td id=\"T_7fb0a_row3_col1\" class=\"data row3 col1\" >1.000000</td>\n",
       "      <td id=\"T_7fb0a_row3_col2\" class=\"data row3 col2\" >1.000000</td>\n",
       "      <td id=\"T_7fb0a_row3_col3\" class=\"data row3 col3\" >1.000000</td>\n",
       "      <td id=\"T_7fb0a_row3_col4\" class=\"data row3 col4\" >1.000000</td>\n",
       "      <td id=\"T_7fb0a_row3_col5\" class=\"data row3 col5\" >1.000000</td>\n",
       "      <td id=\"T_7fb0a_row3_col6\" class=\"data row3 col6\" >1.000000</td>\n",
       "      <td id=\"T_7fb0a_row3_col7\" class=\"data row3 col7\" >1.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th id=\"T_7fb0a_level0_row4\" class=\"row_heading level0 row4\" >random_forest</th>\n",
       "      <td id=\"T_7fb0a_row4_col0\" class=\"data row4 col0\" >1.000000</td>\n",
       "      <td id=\"T_7fb0a_row4_col1\" class=\"data row4 col1\" >1.000000</td>\n",
       "      <td id=\"T_7fb0a_row4_col2\" class=\"data row4 col2\" >1.000000</td>\n",
       "      <td id=\"T_7fb0a_row4_col3\" class=\"data row4 col3\" >1.000000</td>\n",
       "      <td id=\"T_7fb0a_row4_col4\" class=\"data row4 col4\" >1.000000</td>\n",
       "      <td id=\"T_7fb0a_row4_col5\" class=\"data row4 col5\" >1.000000</td>\n",
       "      <td id=\"T_7fb0a_row4_col6\" class=\"data row4 col6\" >1.000000</td>\n",
       "      <td id=\"T_7fb0a_row4_col7\" class=\"data row4 col7\" >1.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th id=\"T_7fb0a_level0_row5\" class=\"row_heading level0 row5\" >mlp</th>\n",
       "      <td id=\"T_7fb0a_row5_col0\" class=\"data row5 col0\" >1.000000</td>\n",
       "      <td id=\"T_7fb0a_row5_col1\" class=\"data row5 col1\" >1.000000</td>\n",
       "      <td id=\"T_7fb0a_row5_col2\" class=\"data row5 col2\" >0.995726</td>\n",
       "      <td id=\"T_7fb0a_row5_col3\" class=\"data row5 col3\" >0.982906</td>\n",
       "      <td id=\"T_7fb0a_row5_col4\" class=\"data row5 col4\" >0.999038</td>\n",
       "      <td id=\"T_7fb0a_row5_col5\" class=\"data row5 col5\" >0.996154</td>\n",
       "      <td id=\"T_7fb0a_row5_col6\" class=\"data row5 col6\" >0.997859</td>\n",
       "      <td id=\"T_7fb0a_row5_col7\" class=\"data row5 col7\" >0.991379</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th id=\"T_7fb0a_level0_row6\" class=\"row_heading level0 row6\" >naive_bayes</th>\n",
       "      <td id=\"T_7fb0a_row6_col0\" class=\"data row6 col0\" >1.000000</td>\n",
       "      <td id=\"T_7fb0a_row6_col1\" class=\"data row6 col1\" >0.920635</td>\n",
       "      <td id=\"T_7fb0a_row6_col2\" class=\"data row6 col2\" >1.000000</td>\n",
       "      <td id=\"T_7fb0a_row6_col3\" class=\"data row6 col3\" >0.991453</td>\n",
       "      <td id=\"T_7fb0a_row6_col4\" class=\"data row6 col4\" >1.000000</td>\n",
       "      <td id=\"T_7fb0a_row6_col5\" class=\"data row6 col5\" >0.978846</td>\n",
       "      <td id=\"T_7fb0a_row6_col6\" class=\"data row6 col6\" >1.000000</td>\n",
       "      <td id=\"T_7fb0a_row6_col7\" class=\"data row6 col7\" >0.954733</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th id=\"T_7fb0a_level0_row7\" class=\"row_heading level0 row7\" >knn</th>\n",
       "      <td id=\"T_7fb0a_row7_col0\" class=\"data row7 col0\" >1.000000</td>\n",
       "      <td id=\"T_7fb0a_row7_col1\" class=\"data row7 col1\" >1.000000</td>\n",
       "      <td id=\"T_7fb0a_row7_col2\" class=\"data row7 col2\" >0.848291</td>\n",
       "      <td id=\"T_7fb0a_row7_col3\" class=\"data row7 col3\" >0.811966</td>\n",
       "      <td id=\"T_7fb0a_row7_col4\" class=\"data row7 col4\" >0.965865</td>\n",
       "      <td id=\"T_7fb0a_row7_col5\" class=\"data row7 col5\" >0.957692</td>\n",
       "      <td id=\"T_7fb0a_row7_col6\" class=\"data row7 col6\" >0.917919</td>\n",
       "      <td id=\"T_7fb0a_row7_col7\" class=\"data row7 col7\" >0.896226</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n"
      ],
      "text/plain": [
       "<pandas.io.formats.style.Styler at 0x298e9d73680>"
      ]
     },
     "execution_count": 25,
     "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": [
    "Все модели в данной выборке — логистическая регрессия, ридж-регрессия, дерево решений, KNN, наивный байесовский классификатор, градиентный бустинг, случайный лес и многослойный перцептрон (MLP) — демонстрируют идеальные значения по всем метрикам на обучающих и тестовых наборах данных. Это достигается, поскольку все модели показали значения, равные 1.0 для Precision, Recall, Accuracy и F1-меры, что указывает на то, что модель безошибочно классифицирует все примеры.\n",
    "\n",
    "Модель MLP, хотя и имеет немного более низкие значения Recall (0.994) и F1-на тестовом наборе (0.997) по сравнению с другими, по-прежнему остается высокоэффективной. Тем не менее, она не снижает показатели классификации до такого уровня, что может вызвать обеспокоенность, и остается на уровне, близком к идеальному."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ROC-кривая, каппа Коэна, коэффициент корреляции Мэтьюса"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style type=\"text/css\">\n",
       "#T_61749_row0_col0, #T_61749_row0_col1, #T_61749_row1_col0, #T_61749_row1_col1, #T_61749_row2_col0, #T_61749_row2_col1, #T_61749_row3_col0, #T_61749_row3_col1, #T_61749_row5_col0, #T_61749_row5_col1 {\n",
       "  background-color: #a8db34;\n",
       "  color: #000000;\n",
       "}\n",
       "#T_61749_row0_col2, #T_61749_row0_col3, #T_61749_row0_col4, #T_61749_row1_col2, #T_61749_row1_col3, #T_61749_row1_col4, #T_61749_row2_col2, #T_61749_row2_col3, #T_61749_row2_col4, #T_61749_row3_col2, #T_61749_row3_col3, #T_61749_row3_col4, #T_61749_row4_col2, #T_61749_row5_col2, #T_61749_row5_col3, #T_61749_row5_col4 {\n",
       "  background-color: #da5a6a;\n",
       "  color: #f1f1f1;\n",
       "}\n",
       "#T_61749_row4_col0 {\n",
       "  background-color: #8ed645;\n",
       "  color: #000000;\n",
       "}\n",
       "#T_61749_row4_col1 {\n",
       "  background-color: #90d743;\n",
       "  color: #000000;\n",
       "}\n",
       "#T_61749_row4_col3 {\n",
       "  background-color: #d24f71;\n",
       "  color: #f1f1f1;\n",
       "}\n",
       "#T_61749_row4_col4 {\n",
       "  background-color: #d14e72;\n",
       "  color: #f1f1f1;\n",
       "}\n",
       "#T_61749_row6_col0, #T_61749_row6_col1 {\n",
       "  background-color: #26818e;\n",
       "  color: #f1f1f1;\n",
       "}\n",
       "#T_61749_row6_col2 {\n",
       "  background-color: #cd4a76;\n",
       "  color: #f1f1f1;\n",
       "}\n",
       "#T_61749_row6_col3, #T_61749_row6_col4, #T_61749_row7_col2 {\n",
       "  background-color: #4e02a2;\n",
       "  color: #f1f1f1;\n",
       "}\n",
       "#T_61749_row7_col0 {\n",
       "  background-color: #2fb47c;\n",
       "  color: #f1f1f1;\n",
       "}\n",
       "#T_61749_row7_col1 {\n",
       "  background-color: #3bbb75;\n",
       "  color: #f1f1f1;\n",
       "}\n",
       "#T_61749_row7_col3 {\n",
       "  background-color: #a72197;\n",
       "  color: #f1f1f1;\n",
       "}\n",
       "#T_61749_row7_col4 {\n",
       "  background-color: #a51f99;\n",
       "  color: #f1f1f1;\n",
       "}\n",
       "</style>\n",
       "<table id=\"T_61749\">\n",
       "  <thead>\n",
       "    <tr>\n",
       "      <th class=\"blank level0\" >&nbsp;</th>\n",
       "      <th id=\"T_61749_level0_col0\" class=\"col_heading level0 col0\" >Accuracy_test</th>\n",
       "      <th id=\"T_61749_level0_col1\" class=\"col_heading level0 col1\" >F1_test</th>\n",
       "      <th id=\"T_61749_level0_col2\" class=\"col_heading level0 col2\" >ROC_AUC_test</th>\n",
       "      <th id=\"T_61749_level0_col3\" class=\"col_heading level0 col3\" >Cohen_kappa_test</th>\n",
       "      <th id=\"T_61749_level0_col4\" class=\"col_heading level0 col4\" >MCC_test</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th id=\"T_61749_level0_row0\" class=\"row_heading level0 row0\" >logistic</th>\n",
       "      <td id=\"T_61749_row0_col0\" class=\"data row0 col0\" >1.000000</td>\n",
       "      <td id=\"T_61749_row0_col1\" class=\"data row0 col1\" >1.000000</td>\n",
       "      <td id=\"T_61749_row0_col2\" class=\"data row0 col2\" >1.000000</td>\n",
       "      <td id=\"T_61749_row0_col3\" class=\"data row0 col3\" >1.000000</td>\n",
       "      <td id=\"T_61749_row0_col4\" class=\"data row0 col4\" >1.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th id=\"T_61749_level0_row1\" class=\"row_heading level0 row1\" >ridge</th>\n",
       "      <td id=\"T_61749_row1_col0\" class=\"data row1 col0\" >1.000000</td>\n",
       "      <td id=\"T_61749_row1_col1\" class=\"data row1 col1\" >1.000000</td>\n",
       "      <td id=\"T_61749_row1_col2\" class=\"data row1 col2\" >1.000000</td>\n",
       "      <td id=\"T_61749_row1_col3\" class=\"data row1 col3\" >1.000000</td>\n",
       "      <td id=\"T_61749_row1_col4\" class=\"data row1 col4\" >1.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th id=\"T_61749_level0_row2\" class=\"row_heading level0 row2\" >decision_tree</th>\n",
       "      <td id=\"T_61749_row2_col0\" class=\"data row2 col0\" >1.000000</td>\n",
       "      <td id=\"T_61749_row2_col1\" class=\"data row2 col1\" >1.000000</td>\n",
       "      <td id=\"T_61749_row2_col2\" class=\"data row2 col2\" >1.000000</td>\n",
       "      <td id=\"T_61749_row2_col3\" class=\"data row2 col3\" >1.000000</td>\n",
       "      <td id=\"T_61749_row2_col4\" class=\"data row2 col4\" >1.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th id=\"T_61749_level0_row3\" class=\"row_heading level0 row3\" >gradient_boosting</th>\n",
       "      <td id=\"T_61749_row3_col0\" class=\"data row3 col0\" >1.000000</td>\n",
       "      <td id=\"T_61749_row3_col1\" class=\"data row3 col1\" >1.000000</td>\n",
       "      <td id=\"T_61749_row3_col2\" class=\"data row3 col2\" >1.000000</td>\n",
       "      <td id=\"T_61749_row3_col3\" class=\"data row3 col3\" >1.000000</td>\n",
       "      <td id=\"T_61749_row3_col4\" class=\"data row3 col4\" >1.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th id=\"T_61749_level0_row4\" class=\"row_heading level0 row4\" >mlp</th>\n",
       "      <td id=\"T_61749_row4_col0\" class=\"data row4 col0\" >0.996154</td>\n",
       "      <td id=\"T_61749_row4_col1\" class=\"data row4 col1\" >0.991379</td>\n",
       "      <td id=\"T_61749_row4_col2\" class=\"data row4 col2\" >1.000000</td>\n",
       "      <td id=\"T_61749_row4_col3\" class=\"data row4 col3\" >0.988904</td>\n",
       "      <td id=\"T_61749_row4_col4\" class=\"data row4 col4\" >0.988965</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th id=\"T_61749_level0_row5\" class=\"row_heading level0 row5\" >random_forest</th>\n",
       "      <td id=\"T_61749_row5_col0\" class=\"data row5 col0\" >1.000000</td>\n",
       "      <td id=\"T_61749_row5_col1\" class=\"data row5 col1\" >1.000000</td>\n",
       "      <td id=\"T_61749_row5_col2\" class=\"data row5 col2\" >1.000000</td>\n",
       "      <td id=\"T_61749_row5_col3\" class=\"data row5 col3\" >1.000000</td>\n",
       "      <td id=\"T_61749_row5_col4\" class=\"data row5 col4\" >1.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th id=\"T_61749_level0_row6\" class=\"row_heading level0 row6\" >knn</th>\n",
       "      <td id=\"T_61749_row6_col0\" class=\"data row6 col0\" >0.957692</td>\n",
       "      <td id=\"T_61749_row6_col1\" class=\"data row6 col1\" >0.896226</td>\n",
       "      <td id=\"T_61749_row6_col2\" class=\"data row6 col2\" >0.997858</td>\n",
       "      <td id=\"T_61749_row6_col3\" class=\"data row6 col3\" >0.870015</td>\n",
       "      <td id=\"T_61749_row6_col4\" class=\"data row6 col4\" >0.877459</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th id=\"T_61749_level0_row7\" class=\"row_heading level0 row7\" >naive_bayes</th>\n",
       "      <td id=\"T_61749_row7_col0\" class=\"data row7 col0\" >0.978846</td>\n",
       "      <td id=\"T_61749_row7_col1\" class=\"data row7 col1\" >0.954733</td>\n",
       "      <td id=\"T_61749_row7_col2\" class=\"data row7 col2\" >0.983320</td>\n",
       "      <td id=\"T_61749_row7_col3\" class=\"data row7 col3\" >0.940955</td>\n",
       "      <td id=\"T_61749_row7_col4\" class=\"data row7 col4\" >0.942055</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n"
      ],
      "text/plain": [
       "<pandas.io.formats.style.Styler at 0x298e9ed6300>"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "\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",
    "class_metrics = class_metrics.sort_values(by=\"ROC_AUC_test\", ascending=False)\n",
    "\n",
    "class_metrics.style.background_gradient(\n",
    "  cmap=\"plasma\", # Цветовая палитра для ROC_AUC_test, MCC_test, Cohen_kappa_test\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\", # Цветовая палитра для Accuracy_test, F1_test\n",
    "  low=1, \n",
    "  high=0.3, \n",
    "  subset=[\n",
    "    \"Accuracy_test\",\n",
    "    \"F1_test\",\n",
    "  ],\n",
    ")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'logistic'"
      ]
     },
     "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": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\Users\\goldfest\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\sklearn\\preprocessing\\_encoders.py:242: UserWarning: Found unknown categories in columns [0, 1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "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>Rank</th>\n",
       "      <th>Predicted</th>\n",
       "      <th>Name</th>\n",
       "      <th>Networth</th>\n",
       "      <th>Age</th>\n",
       "      <th>Country</th>\n",
       "      <th>Source</th>\n",
       "      <th>Industry</th>\n",
       "      <th>above_average_networth</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "Empty DataFrame\n",
       "Columns: [Rank, Predicted, Name, Networth, Age, Country, Source, Industry, above_average_networth]\n",
       "Index: []"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "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",
    "y_pred = class_models[best_model][\"preds\"]\n",
    "\n",
    "error_index = y_test[y_test[\"above_average_networth\"] != y_pred].index.tolist() \n",
    "display(f\"Error items count: {len(error_index)}\")\n",
    "\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",
    "display(error_df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "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>Rank</th>\n",
       "      <th>Name</th>\n",
       "      <th>Networth</th>\n",
       "      <th>Age</th>\n",
       "      <th>Country</th>\n",
       "      <th>Source</th>\n",
       "      <th>Industry</th>\n",
       "      <th>above_average_networth</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>231</th>\n",
       "      <td>230</td>\n",
       "      <td>Xavier Niel</td>\n",
       "      <td>8.9</td>\n",
       "      <td>54</td>\n",
       "      <td>France</td>\n",
       "      <td>internet, telecom</td>\n",
       "      <td>Telecom</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    Rank          Name Networth Age Country             Source  Industry  \\\n",
       "231  230  Xavier Niel       8.9  54  France  internet, telecom  Telecom    \n",
       "\n",
       "    above_average_networth  \n",
       "231                      1  "
      ]
     },
     "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>Networth</th>\n",
       "      <th>Age</th>\n",
       "      <th>Country_Argentina</th>\n",
       "      <th>Country_Australia</th>\n",
       "      <th>Country_Austria</th>\n",
       "      <th>Country_Barbados</th>\n",
       "      <th>Country_Belgium</th>\n",
       "      <th>Country_Belize</th>\n",
       "      <th>Country_Brazil</th>\n",
       "      <th>Country_Bulgaria</th>\n",
       "      <th>...</th>\n",
       "      <th>Industry_Manufacturing</th>\n",
       "      <th>Industry_Media &amp; Entertainment</th>\n",
       "      <th>Industry_Metals &amp; Mining</th>\n",
       "      <th>Industry_Real Estate</th>\n",
       "      <th>Industry_Service</th>\n",
       "      <th>Industry_Sports</th>\n",
       "      <th>Industry_Technology</th>\n",
       "      <th>Industry_Telecom</th>\n",
       "      <th>Industry_diversified</th>\n",
       "      <th>above_average_networth</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>231</th>\n",
       "      <td>0.405144</td>\n",
       "      <td>-0.782365</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>...</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>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>1 rows × 859 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "     Networth       Age  Country_Argentina  Country_Australia  \\\n",
       "231  0.405144 -0.782365                0.0                0.0   \n",
       "\n",
       "     Country_Austria  Country_Barbados  Country_Belgium  Country_Belize  \\\n",
       "231              0.0               0.0              0.0             0.0   \n",
       "\n",
       "     Country_Brazil  Country_Bulgaria  ...  Industry_Manufacturing   \\\n",
       "231             0.0               0.0  ...                      0.0   \n",
       "\n",
       "     Industry_Media & Entertainment   Industry_Metals & Mining   \\\n",
       "231                              0.0                        0.0   \n",
       "\n",
       "     Industry_Real Estate   Industry_Service   Industry_Sports   \\\n",
       "231                    0.0                0.0               0.0   \n",
       "\n",
       "     Industry_Technology   Industry_Telecom   Industry_diversified     \\\n",
       "231                   0.0                1.0                      0.0   \n",
       "\n",
       "     above_average_networth  \n",
       "231                     1.0  \n",
       "\n",
       "[1 rows x 859 columns]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "predicted: 1 (proba: [0.01305711 0.98694289])\n",
      "real: 1\n"
     ]
    }
   ],
   "source": [
    "model = class_models[best_model][\"pipeline\"]\n",
    "\n",
    "example_id = 253\n",
    "test = pd.DataFrame(X_test.iloc[example_id, :]).T\n",
    "display(test)\n",
    "test_preprocessed = pd.DataFrame(preprocessed_df.iloc[example_id, :]).T\n",
    "display(test_preprocessed)\n",
    "result_proba = model.predict_proba(test)[0]\n",
    "result = model.predict(test)[0]\n",
    "real = int(y_test.iloc[example_id].values[0])\n",
    "print(f\"predicted: {result} (proba: {result_proba})\")\n",
    "print(f\"real: {real}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Задача регрессии - прогнозирование состояния миллионеров"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Среднее значение поля 'Networth': 4.8607499999999995\n",
      "   Rank                       Name  Networth  Age        Country  \\\n",
      "0     1                 Elon Musk      219.0   50  United States   \n",
      "1     2                Jeff Bezos      171.0   58  United States   \n",
      "2     3  Bernard Arnault & family      158.0   73         France   \n",
      "3     4                Bill Gates      129.0   66  United States   \n",
      "4     5            Warren Buffett      118.0   91  United States   \n",
      "\n",
      "               Source                Industry  above_average_networth  \n",
      "0       Tesla, SpaceX             Automotive                        1  \n",
      "1              Amazon             Technology                        1  \n",
      "2                LVMH       Fashion & Retail                        1  \n",
      "3           Microsoft             Technology                        1  \n",
      "4  Berkshire Hathaway  Finance & Investments                        1  \n",
      "Статистическое описание DataFrame:\n",
      "              Rank     Networth          Age  above_average_networth\n",
      "count  2600.000000  2600.000000  2600.000000             2600.000000\n",
      "mean   1269.570769     4.860750    64.271923                0.225000\n",
      "std     728.146364    10.659671    13.220607                0.417663\n",
      "min       1.000000     1.000000    19.000000                0.000000\n",
      "25%     637.000000     1.500000    55.000000                0.000000\n",
      "50%    1292.000000     2.400000    64.000000                0.000000\n",
      "75%    1929.000000     4.500000    74.000000                0.000000\n",
      "max    2578.000000   219.000000   100.000000                1.000000\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "from sklearn import set_config\n",
    "\n",
    "set_config(transform_output=\"pandas\")\n",
    "\n",
    "df = pd.read_csv(\"..//static//csv//Forbes Billionaires.csv\")\n",
    "random_state = 42\n",
    "\n",
    "# Вычисление среднего значения поля \"Networth\"\n",
    "average_networth = df['Networth'].mean()\n",
    "print(f\"Среднее значение поля 'Networth': {average_networth}\")\n",
    "\n",
    "# Создание новой колонки, указывающей, выше или ниже среднего значение чистого состояния\n",
    "df['above_average_networth'] = (df['Networth'] > average_networth).astype(int)\n",
    "\n",
    "print(df.head())\n",
    "print(\"Статистическое описание DataFrame:\")\n",
    "print(df.describe())\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Разделение набора данных на обучающую и тестовые выборки (80/20) для задачи регрессии\n",
    "\n",
    "Целевой признак -- above_average_networth"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "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>Rank</th>\n",
       "      <th>Name</th>\n",
       "      <th>Networth</th>\n",
       "      <th>Age</th>\n",
       "      <th>Country</th>\n",
       "      <th>Source</th>\n",
       "      <th>Industry</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>582</th>\n",
       "      <td>579</td>\n",
       "      <td>Alexandra Schoerghuber &amp; family</td>\n",
       "      <td>4.9</td>\n",
       "      <td>63</td>\n",
       "      <td>Germany</td>\n",
       "      <td>real estate</td>\n",
       "      <td>Real Estate</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>48</th>\n",
       "      <td>49</td>\n",
       "      <td>He Xiangjian</td>\n",
       "      <td>28.3</td>\n",
       "      <td>79</td>\n",
       "      <td>China</td>\n",
       "      <td>home appliances</td>\n",
       "      <td>Manufacturing</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1772</th>\n",
       "      <td>1729</td>\n",
       "      <td>Bruce Mathieson</td>\n",
       "      <td>1.7</td>\n",
       "      <td>78</td>\n",
       "      <td>Australia</td>\n",
       "      <td>hotels</td>\n",
       "      <td>Food &amp; Beverage</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>964</th>\n",
       "      <td>951</td>\n",
       "      <td>Pansy Ho</td>\n",
       "      <td>3.2</td>\n",
       "      <td>59</td>\n",
       "      <td>Hong Kong</td>\n",
       "      <td>casinos</td>\n",
       "      <td>Gambling &amp; Casinos</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2213</th>\n",
       "      <td>2190</td>\n",
       "      <td>Sasson Dayan &amp; family</td>\n",
       "      <td>1.3</td>\n",
       "      <td>82</td>\n",
       "      <td>Brazil</td>\n",
       "      <td>banking</td>\n",
       "      <td>Finance &amp; Investments</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1638</th>\n",
       "      <td>1579</td>\n",
       "      <td>Wang Chou-hsiong</td>\n",
       "      <td>1.9</td>\n",
       "      <td>81</td>\n",
       "      <td>Taiwan</td>\n",
       "      <td>footwear</td>\n",
       "      <td>Manufacturing</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1095</th>\n",
       "      <td>1096</td>\n",
       "      <td>Jose Joao Abdalla Filho</td>\n",
       "      <td>2.8</td>\n",
       "      <td>76</td>\n",
       "      <td>Brazil</td>\n",
       "      <td>investments</td>\n",
       "      <td>Finance &amp; Investments</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1130</th>\n",
       "      <td>1096</td>\n",
       "      <td>Lin Chen-hai</td>\n",
       "      <td>2.8</td>\n",
       "      <td>75</td>\n",
       "      <td>Taiwan</td>\n",
       "      <td>real estate</td>\n",
       "      <td>Real Estate</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1294</th>\n",
       "      <td>1292</td>\n",
       "      <td>Banwari Lal Bawri</td>\n",
       "      <td>2.4</td>\n",
       "      <td>69</td>\n",
       "      <td>India</td>\n",
       "      <td>pharmaceuticals</td>\n",
       "      <td>Healthcare</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>860</th>\n",
       "      <td>851</td>\n",
       "      <td>Kuok Khoon Hong</td>\n",
       "      <td>3.5</td>\n",
       "      <td>72</td>\n",
       "      <td>Singapore</td>\n",
       "      <td>palm oil</td>\n",
       "      <td>Manufacturing</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>2080 rows × 7 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "      Rank                              Name  Networth  Age    Country  \\\n",
       "582    579  Alexandra Schoerghuber & family        4.9   63    Germany   \n",
       "48      49                     He Xiangjian       28.3   79      China   \n",
       "1772  1729                  Bruce Mathieson        1.7   78  Australia   \n",
       "964    951                         Pansy Ho        3.2   59  Hong Kong   \n",
       "2213  2190            Sasson Dayan & family        1.3   82     Brazil   \n",
       "...    ...                               ...       ...  ...        ...   \n",
       "1638  1579                 Wang Chou-hsiong        1.9   81     Taiwan   \n",
       "1095  1096          Jose Joao Abdalla Filho        2.8   76     Brazil   \n",
       "1130  1096                     Lin Chen-hai        2.8   75     Taiwan   \n",
       "1294  1292                Banwari Lal Bawri        2.4   69      India   \n",
       "860    851                  Kuok Khoon Hong        3.5   72  Singapore   \n",
       "\n",
       "               Source                Industry  \n",
       "582       real estate            Real Estate   \n",
       "48    home appliances          Manufacturing   \n",
       "1772           hotels        Food & Beverage   \n",
       "964           casinos     Gambling & Casinos   \n",
       "2213          banking  Finance & Investments   \n",
       "...               ...                     ...  \n",
       "1638         footwear          Manufacturing   \n",
       "1095      investments  Finance & Investments   \n",
       "1130      real estate            Real Estate   \n",
       "1294  pharmaceuticals             Healthcare   \n",
       "860          palm oil          Manufacturing   \n",
       "\n",
       "[2080 rows x 7 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_networth</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>582</th>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>48</th>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1772</th>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>964</th>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2213</th>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1638</th>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1095</th>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1130</th>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1294</th>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>860</th>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>2080 rows × 1 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "      above_average_networth\n",
       "582                        1\n",
       "48                         1\n",
       "1772                       0\n",
       "964                        0\n",
       "2213                       0\n",
       "...                      ...\n",
       "1638                       0\n",
       "1095                       0\n",
       "1130                       0\n",
       "1294                       0\n",
       "860                        0\n",
       "\n",
       "[2080 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>Rank</th>\n",
       "      <th>Name</th>\n",
       "      <th>Networth</th>\n",
       "      <th>Age</th>\n",
       "      <th>Country</th>\n",
       "      <th>Source</th>\n",
       "      <th>Industry</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1593</th>\n",
       "      <td>1579</td>\n",
       "      <td>Guangming Fu &amp; family</td>\n",
       "      <td>1.9</td>\n",
       "      <td>68</td>\n",
       "      <td>China</td>\n",
       "      <td>poultry</td>\n",
       "      <td>Food &amp; Beverage</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>196</th>\n",
       "      <td>197</td>\n",
       "      <td>Leon Black</td>\n",
       "      <td>10.0</td>\n",
       "      <td>70</td>\n",
       "      <td>United States</td>\n",
       "      <td>private equity</td>\n",
       "      <td>Finance &amp; Investments</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>239</th>\n",
       "      <td>235</td>\n",
       "      <td>Zong Qinghou</td>\n",
       "      <td>8.8</td>\n",
       "      <td>76</td>\n",
       "      <td>China</td>\n",
       "      <td>beverages</td>\n",
       "      <td>Food &amp; Beverage</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2126</th>\n",
       "      <td>2076</td>\n",
       "      <td>Kurt Krieger</td>\n",
       "      <td>1.4</td>\n",
       "      <td>74</td>\n",
       "      <td>Germany</td>\n",
       "      <td>furniture retailing</td>\n",
       "      <td>Fashion &amp; Retail</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1587</th>\n",
       "      <td>1579</td>\n",
       "      <td>Chen Kaichen</td>\n",
       "      <td>1.9</td>\n",
       "      <td>64</td>\n",
       "      <td>China</td>\n",
       "      <td>household chemicals</td>\n",
       "      <td>Manufacturing</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1778</th>\n",
       "      <td>1729</td>\n",
       "      <td>Jorge Perez</td>\n",
       "      <td>1.7</td>\n",
       "      <td>72</td>\n",
       "      <td>United States</td>\n",
       "      <td>real estate</td>\n",
       "      <td>Real Estate</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>166</th>\n",
       "      <td>167</td>\n",
       "      <td>Brian Chesky</td>\n",
       "      <td>11.5</td>\n",
       "      <td>40</td>\n",
       "      <td>United States</td>\n",
       "      <td>Airbnb</td>\n",
       "      <td>Technology</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>949</th>\n",
       "      <td>913</td>\n",
       "      <td>Zhong Ruonong &amp; family</td>\n",
       "      <td>3.3</td>\n",
       "      <td>59</td>\n",
       "      <td>China</td>\n",
       "      <td>electronics</td>\n",
       "      <td>Manufacturing</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>49</th>\n",
       "      <td>50</td>\n",
       "      <td>Miriam Adelson</td>\n",
       "      <td>27.5</td>\n",
       "      <td>76</td>\n",
       "      <td>United States</td>\n",
       "      <td>casinos</td>\n",
       "      <td>Gambling &amp; Casinos</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2511</th>\n",
       "      <td>2448</td>\n",
       "      <td>Lou Boliang</td>\n",
       "      <td>1.1</td>\n",
       "      <td>58</td>\n",
       "      <td>United States</td>\n",
       "      <td>pharmaceuticals</td>\n",
       "      <td>Healthcare</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>520 rows × 7 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "      Rank                     Name  Networth  Age        Country  \\\n",
       "1593  1579   Guangming Fu & family        1.9   68          China   \n",
       "196    197              Leon Black       10.0   70  United States   \n",
       "239    235            Zong Qinghou        8.8   76          China   \n",
       "2126  2076            Kurt Krieger        1.4   74        Germany   \n",
       "1587  1579            Chen Kaichen        1.9   64          China   \n",
       "...    ...                      ...       ...  ...            ...   \n",
       "1778  1729             Jorge Perez        1.7   72  United States   \n",
       "166    167            Brian Chesky       11.5   40  United States   \n",
       "949    913  Zhong Ruonong & family        3.3   59          China   \n",
       "49      50          Miriam Adelson       27.5   76  United States   \n",
       "2511  2448             Lou Boliang        1.1   58  United States   \n",
       "\n",
       "                   Source                Industry  \n",
       "1593              poultry        Food & Beverage   \n",
       "196        private equity  Finance & Investments   \n",
       "239             beverages        Food & Beverage   \n",
       "2126  furniture retailing       Fashion & Retail   \n",
       "1587  household chemicals          Manufacturing   \n",
       "...                   ...                     ...  \n",
       "1778          real estate            Real Estate   \n",
       "166                Airbnb             Technology   \n",
       "949           electronics          Manufacturing   \n",
       "49                casinos     Gambling & Casinos   \n",
       "2511      pharmaceuticals             Healthcare   \n",
       "\n",
       "[520 rows x 7 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_networth</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1593</th>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>196</th>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>239</th>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2126</th>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1587</th>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1778</th>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>166</th>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>949</th>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>49</th>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2511</th>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>520 rows × 1 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "      above_average_networth\n",
       "1593                       0\n",
       "196                        1\n",
       "239                        1\n",
       "2126                       0\n",
       "1587                       0\n",
       "...                      ...\n",
       "1778                       0\n",
       "166                        1\n",
       "949                        0\n",
       "49                         1\n",
       "2511                       0\n",
       "\n",
       "[520 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_networth\",  \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",
    "    if target_colname not in df_input.columns:\n",
    "        raise ValueError(f\"{target_colname} is not a column in the DataFrame.\")\n",
    "\n",
    "    X = df_input.drop(columns=[target_colname])  \n",
    "    y = df_input[[target_colname]]  \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",
    "X_train, X_test, y_train, y_test = split_into_train_test(\n",
    "    df, \n",
    "    target_colname=\"above_average_networth\",  \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)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Формирование конвейера для решения задачи регрессии"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "       Networth       Age  Country_Argentina  Country_Australia  \\\n",
      "0     20.092595 -1.079729                0.0                0.0   \n",
      "1     15.588775 -0.474496                0.0                0.0   \n",
      "2     14.368991  0.660314                0.0                0.0   \n",
      "3     11.647933  0.130736                0.0                0.0   \n",
      "4     10.615808  2.022087                0.0                0.0   \n",
      "...         ...       ...                ...                ...   \n",
      "2595  -0.362253  1.189893                0.0                0.0   \n",
      "2596  -0.362253  1.341201                0.0                0.0   \n",
      "2597  -0.362253  0.509006                0.0                0.0   \n",
      "2598  -0.362253  0.282044                0.0                0.0   \n",
      "2599  -0.362253  0.357698                0.0                0.0   \n",
      "\n",
      "      Country_Austria  Country_Barbados  Country_Belgium  Country_Belize  \\\n",
      "0                 0.0               0.0              0.0             0.0   \n",
      "1                 0.0               0.0              0.0             0.0   \n",
      "2                 0.0               0.0              0.0             0.0   \n",
      "3                 0.0               0.0              0.0             0.0   \n",
      "4                 0.0               0.0              0.0             0.0   \n",
      "...               ...               ...              ...             ...   \n",
      "2595              0.0               0.0              0.0             0.0   \n",
      "2596              0.0               0.0              0.0             0.0   \n",
      "2597              0.0               0.0              0.0             0.0   \n",
      "2598              0.0               0.0              0.0             0.0   \n",
      "2599              0.0               0.0              0.0             0.0   \n",
      "\n",
      "      Country_Brazil  Country_Bulgaria  ...  Industry_Manufacturing   \\\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",
      "2595             0.0               0.0  ...                      0.0   \n",
      "2596             0.0               0.0  ...                      0.0   \n",
      "2597             0.0               0.0  ...                      0.0   \n",
      "2598             0.0               0.0  ...                      0.0   \n",
      "2599             0.0               0.0  ...                      0.0   \n",
      "\n",
      "      Industry_Media & Entertainment   Industry_Metals & Mining   \\\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",
      "2595                              0.0                        0.0   \n",
      "2596                              0.0                        0.0   \n",
      "2597                              0.0                        0.0   \n",
      "2598                              0.0                        0.0   \n",
      "2599                              0.0                        0.0   \n",
      "\n",
      "      Industry_Real Estate   Industry_Service   Industry_Sports   \\\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",
      "2595                    0.0                0.0               0.0   \n",
      "2596                    0.0                0.0               0.0   \n",
      "2597                    0.0                0.0               0.0   \n",
      "2598                    0.0                0.0               0.0   \n",
      "2599                    0.0                0.0               0.0   \n",
      "\n",
      "      Industry_Technology   Industry_Telecom   Industry_diversified     \\\n",
      "0                      0.0                0.0                      0.0   \n",
      "1                      1.0                0.0                      0.0   \n",
      "2                      0.0                0.0                      0.0   \n",
      "3                      1.0                0.0                      0.0   \n",
      "4                      0.0                0.0                      0.0   \n",
      "...                    ...                ...                      ...   \n",
      "2595                   0.0                0.0                      0.0   \n",
      "2596                   0.0                0.0                      0.0   \n",
      "2597                   0.0                0.0                      0.0   \n",
      "2598                   0.0                0.0                      0.0   \n",
      "2599                   0.0                0.0                      0.0   \n",
      "\n",
      "      Networth_per_Age  \n",
      "0           -18.608929  \n",
      "1           -32.853309  \n",
      "2            21.760834  \n",
      "3            89.095063  \n",
      "4             5.249926  \n",
      "...                ...  \n",
      "2595         -0.304441  \n",
      "2596         -0.270096  \n",
      "2597         -0.711686  \n",
      "2598         -1.284383  \n",
      "2599         -1.012732  \n",
      "\n",
      "[2600 rows x 988 columns]\n",
      "(2600, 988)\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",
    "\n",
    "class ForbesBillionairesFeatures(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",
    "    X[\"Networth_per_Age\"] = X[\"Networth\"] / X[\"Age\"]\n",
    "    return X\n",
    "\n",
    "  def get_feature_names_out(self, features_in):\n",
    "    return np.append(features_in, [\"Networth_per_Age\"], axis=0) \n",
    "\n",
    "columns_to_drop = [\"Rank\", \"Name\"] \n",
    "num_columns = [\"Networth\", \"Age\"] \n",
    "cat_columns = [\"Country\", \"Source\", \"Industry\"]\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",
    "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",
    "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",
    "pipeline_end = Pipeline(\n",
    "  [\n",
    "    (\"features_preprocessing\", features_preprocessing),\n",
    "    (\"drop_columns\", drop_columns),\n",
    "    (\"custom_features\", ForbesBillionairesFeatures()), # Добавляем custom_features\n",
    "  ]\n",
    ")\n",
    "\n",
    "df = pd.read_csv(\"..//static//csv//Forbes Billionaires.csv\")\n",
    "\n",
    "average_networth = df['Networth'].mean()\n",
    "df['above_average_networth'] = (df['Networth'] > average_networth).astype(int)\n",
    "\n",
    "X = df.drop('above_average_networth', axis=1)\n",
    "y = df['above_average_networth'].values.ravel()\n",
    "\n",
    "X_processed = pipeline_end.fit_transform(X)\n",
    "\n",
    "print(X_processed)\n",
    "print(X_processed.shape)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Формирование набора моделей для регрессии"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\Users\\goldfest\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\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",
      "c:\\Users\\goldfest\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\sklearn\\preprocessing\\_encoders.py:242: UserWarning: Found unknown categories in columns [0, 1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "c:\\Users\\goldfest\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\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",
      "c:\\Users\\goldfest\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\sklearn\\preprocessing\\_encoders.py:242: UserWarning: Found unknown categories in columns [0, 1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "c:\\Users\\goldfest\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\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",
      "c:\\Users\\goldfest\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\sklearn\\preprocessing\\_encoders.py:242: UserWarning: Found unknown categories in columns [0, 1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "c:\\Users\\goldfest\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\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",
      "c:\\Users\\goldfest\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\sklearn\\preprocessing\\_encoders.py:242: UserWarning: Found unknown categories in columns [0, 1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "c:\\Users\\goldfest\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\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",
      "c:\\Users\\goldfest\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\sklearn\\preprocessing\\_encoders.py:242: UserWarning: Found unknown categories in columns [0, 1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "c:\\Users\\goldfest\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\sklearn\\preprocessing\\_encoders.py:242: UserWarning: Found unknown categories in columns [0, 1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "c:\\Users\\goldfest\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\sklearn\\preprocessing\\_encoders.py:242: UserWarning: Found unknown categories in columns [0, 1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "c:\\Users\\goldfest\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\sklearn\\preprocessing\\_encoders.py:242: UserWarning: Found unknown categories in columns [0, 1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "c:\\Users\\goldfest\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\sklearn\\preprocessing\\_encoders.py:242: UserWarning: Found unknown categories in columns [0, 1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "c:\\Users\\goldfest\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\sklearn\\preprocessing\\_encoders.py:242: UserWarning: Found unknown categories in columns [0, 1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "c:\\Users\\goldfest\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\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",
      "c:\\Users\\goldfest\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\sklearn\\preprocessing\\_encoders.py:242: UserWarning: Found unknown categories in columns [0, 1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "c:\\Users\\goldfest\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\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",
      "c:\\Users\\goldfest\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\sklearn\\preprocessing\\_encoders.py:242: UserWarning: Found unknown categories in columns [0, 1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "c:\\Users\\goldfest\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\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",
      "c:\\Users\\goldfest\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\sklearn\\preprocessing\\_encoders.py:242: UserWarning: Found unknown categories in columns [0, 1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "c:\\Users\\goldfest\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\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",
      "c:\\Users\\goldfest\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\sklearn\\preprocessing\\_encoders.py:242: UserWarning: Found unknown categories in columns [0, 1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "c:\\Users\\goldfest\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\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",
      "c:\\Users\\goldfest\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\sklearn\\preprocessing\\_encoders.py:242: UserWarning: Found unknown categories in columns [0, 1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "c:\\Users\\goldfest\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\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",
      "c:\\Users\\goldfest\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\sklearn\\preprocessing\\_encoders.py:242: UserWarning: Found unknown categories in columns [0, 1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "c:\\Users\\goldfest\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\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",
      "c:\\Users\\goldfest\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\sklearn\\preprocessing\\_encoders.py:242: UserWarning: Found unknown categories in columns [0, 1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "c:\\Users\\goldfest\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\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",
      "c:\\Users\\goldfest\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\sklearn\\preprocessing\\_encoders.py:242: UserWarning: Found unknown categories in columns [0, 1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "c:\\Users\\goldfest\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\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",
      "c:\\Users\\goldfest\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\sklearn\\preprocessing\\_encoders.py:242: UserWarning: Found unknown categories in columns [0, 1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "c:\\Users\\goldfest\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\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",
      "c:\\Users\\goldfest\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\sklearn\\preprocessing\\_encoders.py:242: UserWarning: Found unknown categories in columns [0, 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.9999853281013186, Standard Deviation = 2.6771556649877537e-05\n",
      "Linear Regression: Mean Score = -2.4184625766523136e+22, Standard Deviation = 2.867931120379175e+22\n",
      "Gradient Boosting: Mean Score = 0.9999999992916644, Standard Deviation = 2.7301021406313204e-12\n",
      "Support Vector Regression: Mean Score = 0.6826855358064325, Standard Deviation = 0.02039531518474594\n"
     ]
    }
   ],
   "source": [
    "from sklearn.linear_model import LinearRegression\n",
    "from sklearn.ensemble import GradientBoostingRegressor\n",
    "from sklearn.svm import SVR\n",
    "from sklearn.model_selection import cross_val_score\n",
    "\n",
    "def train_multiple_models(X, y, models):\n",
    "    results = {}\n",
    "    for model_name, model in models.items():\n",
    "        model_pipeline = Pipeline(\n",
    "            [\n",
    "                (\"features_preprocessing\", features_preprocessing),\n",
    "                (\"drop_columns\", drop_columns),\n",
    "                (\"model\", model)  \n",
    "            ]\n",
    "        )\n",
    "\n",
    "        scores = cross_val_score(model_pipeline, X, y, cv=5)  \n",
    "        results[model_name] = {\n",
    "            \"mean_score\": scores.mean(),\n",
    "            \"std_dev\": scores.std()\n",
    "        }\n",
    "    \n",
    "    return results\n",
    "\n",
    "models = {\n",
    "    \"Random Forest\": RandomForestRegressor(),\n",
    "    \"Linear Regression\": LinearRegression(),\n",
    "    \"Gradient Boosting\": GradientBoostingRegressor(),\n",
    "    \"Support Vector Regression\": SVR()\n",
    "}\n",
    "\n",
    "results = train_multiple_models(X_train, y_train, models)\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": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: logistic\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\Users\\goldfest\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\sklearn\\preprocessing\\_encoders.py:242: UserWarning: Found unknown categories in columns [0, 1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MSE (train): 0.0125\n",
      "MSE (test): 0.04038461538461539\n",
      "MAE (train): 0.0125\n",
      "MAE (test): 0.04038461538461539\n",
      "R2 (train): 0.9275415718173158\n",
      "R2 (test): 0.7776148582600195\n",
      "STD (train): 0.11110243021644485\n",
      "STD (test): 0.19685959012669935\n",
      "----------------------------------------\n",
      "Model: ridge\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\Users\\goldfest\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\sklearn\\preprocessing\\_encoders.py:242: UserWarning: Found unknown categories in columns [0, 1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MSE (train): 0.004326923076923077\n",
      "MSE (test): 0.013461538461538462\n",
      "MAE (train): 0.004326923076923077\n",
      "MAE (test): 0.013461538461538462\n",
      "R2 (train): 0.9749182363983017\n",
      "R2 (test): 0.9258716194200065\n",
      "STD (train): 0.0656368860749005\n",
      "STD (test): 0.11588034534756023\n",
      "----------------------------------------\n",
      "Model: decision_tree\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\Users\\goldfest\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\sklearn\\preprocessing\\_encoders.py:242: UserWarning: Found unknown categories in columns [0, 1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "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"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\Users\\goldfest\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\sklearn\\preprocessing\\_encoders.py:242: UserWarning: Found unknown categories in columns [0, 1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MSE (train): 0.09278846153846154\n",
      "MSE (test): 0.15384615384615385\n",
      "MAE (train): 0.09278846153846154\n",
      "MAE (test): 0.15384615384615385\n",
      "R2 (train): 0.4621355138746903\n",
      "R2 (test): 0.1528185076572175\n",
      "STD (train): 0.29276240884468824\n",
      "STD (test): 0.3684085396282311\n",
      "----------------------------------------\n",
      "Model: naive_bayes\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\Users\\goldfest\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\sklearn\\preprocessing\\_encoders.py:242: UserWarning: Found unknown categories in columns [0, 1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MSE (train): 0.37740384615384615\n",
      "MSE (test): 0.6096153846153847\n",
      "MAE (train): 0.37740384615384615\n",
      "MAE (test): 0.6096153846153847\n",
      "R2 (train): -1.1876871585925808\n",
      "R2 (test): -2.3569566634082757\n",
      "STD (train): 0.4847372309428379\n",
      "STD (test): 0.5672229402142737\n",
      "----------------------------------------\n",
      "Model: gradient_boosting\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\Users\\goldfest\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\sklearn\\preprocessing\\_encoders.py:242: UserWarning: Found unknown categories in columns [0, 1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "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"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\Users\\goldfest\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\sklearn\\preprocessing\\_encoders.py:242: UserWarning: Found unknown categories in columns [0, 1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "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.06778846153846153\n",
      "MSE (test): 0.12692307692307692\n",
      "MAE (train): 0.06778846153846153\n",
      "MAE (test): 0.12692307692307692\n",
      "R2 (train): 0.6070523702400588\n",
      "R2 (test): 0.30107526881720437\n",
      "STD (train): 0.2521427220700598\n",
      "STD (test): 0.3370600353877945\n",
      "----------------------------------------\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\Users\\goldfest\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\sklearn\\preprocessing\\_encoders.py:242: UserWarning: Found unknown categories in columns [0, 1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "from sklearn import metrics\n",
    "from sklearn.pipeline import Pipeline\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",
    "\n",
    "y_train = np.ravel(y_train)  \n",
    "y_test = np.ravel(y_test)      \n",
    "\n",
    "results = []\n",
    "\n",
    "for model_name in class_models.keys():\n",
    "    print(f\"Model: {model_name}\")\n",
    "    \n",
    "    model = class_models[model_name][\"model\"]\n",
    "    \n",
    "    model_pipeline = Pipeline([(\"pipeline\", pipeline_end), (\"model\", model)])\n",
    "    \n",
    "    model_pipeline.fit(X_train, y_train)\n",
    "\n",
    "    y_train_predict = model_pipeline.predict(X_train)\n",
    "    y_test_predict = model_pipeline.predict(X_test)\n",
    "\n",
    "    class_models[model_name][\"pipeline\"] = model_pipeline\n",
    "    class_models[model_name][\"preds\"] = y_test_predict\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",
    "    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",
    "    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": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: RandomForest\n",
      "MSE (train): 24.028673442957558\n",
      "MSE (test): 68.96006650623248\n",
      "MAE (train): 1.548185999451937\n",
      "MAE (test): 3.372747412240537\n",
      "R2 (train): 0.8231149198653249\n",
      "R2 (test): -1.9013866015383956\n",
      "----------------------------------------\n",
      "Прогнозируемое чистое состояние: 1.3689999999999998\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\Users\\goldfest\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\sklearn\\preprocessing\\_encoders.py:242: UserWarning: Found unknown categories in columns [0, 1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "c:\\Users\\goldfest\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\sklearn\\preprocessing\\_encoders.py:242: UserWarning: Found unknown categories in columns [0, 1, 2] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\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",
    "data = pd.read_csv(\"..//static//csv//Forbes Billionaires.csv\") \n",
    "\n",
    "average_networth = data['Networth'].mean()\n",
    "data['above_average_networth'] = (data['Networth'] > average_networth).astype(int) \n",
    "\n",
    "X = data.drop('Networth', axis=1) \n",
    "y = data['Networth']\n",
    "\n",
    "class_models = {\n",
    "  \"RandomForest\": {\n",
    "    \"model\": RandomForestRegressor(n_estimators=100, random_state=42),\n",
    "  }\n",
    "}\n",
    "\n",
    "num_columns = ['Age']\n",
    "cat_columns = ['Country', 'Source', 'Industry']\n",
    "\n",
    "num_transformer = Pipeline(steps=[\n",
    "  ('imputer', SimpleImputer(strategy='median')),\n",
    "  ('scaler', StandardScaler())\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",
    "preprocessor = ColumnTransformer(\n",
    "  transformers=[\n",
    "    ('num', num_transformer, num_columns),\n",
    "    ('cat', cat_transformer, cat_columns)\n",
    "  ])\n",
    "\n",
    "pipeline_end = Pipeline(steps=[\n",
    "  ('preprocessor', preprocessor),\n",
    "])\n",
    "\n",
    "results = []\n",
    "\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",
    "  X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)\n",
    "\n",
    "  model_pipeline.fit(X_train, y_train)\n",
    "\n",
    "  y_train_predict = model_pipeline.predict(X_train)\n",
    "  y_test_predict = model_pipeline.predict(X_test)\n",
    "\n",
    "  class_models[model_name][\"preds\"] = y_test_predict\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",
    "  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",
    "new_billionaire_data = pd.DataFrame({\n",
    "  'Age': [50],\n",
    "  'Country': ['USA'],\n",
    "  'Source': ['Self Made'], \n",
    "  'Industry': ['Technology'], \n",
    "})\n",
    "\n",
    "predicted_networth = model_pipeline.predict(new_billionaire_data)\n",
    "print(f\"Прогнозируемое чистое состояние: {predicted_networth[0]}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Подбор гиперпараметров методом поиска по сетке"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\Users\\goldfest\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\sklearn\\preprocessing\\_encoders.py:242: UserWarning: Found unknown categories in columns [0, 1] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting 3 folds for each of 36 candidates, totalling 108 fits\n",
      "Лучшие параметры: {'max_depth': 10, 'min_samples_split': 2, 'n_estimators': 200}\n",
      "Лучший результат (MSE): 5.631552208172496\n"
     ]
    }
   ],
   "source": [
    "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, LabelEncoder\n",
    "from sklearn.compose import ColumnTransformer\n",
    "from sklearn.impute import SimpleImputer\n",
    "\n",
    "df = df.dropna()\n",
    "target = df['Networth']\n",
    "\n",
    "features = df.drop(columns=['Networth'])\n",
    "\n",
    "features = features.drop(columns=['Name'])\n",
    "\n",
    "num_columns = features.select_dtypes(include=['number']).columns\n",
    "cat_columns = features.select_dtypes(include=['object']).columns\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",
    "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",
    "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",
    "pipeline_end = Pipeline(\n",
    "    [\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",
    "X_train_processed = pipeline_end.fit_transform(X_train)\n",
    "X_test_processed = pipeline_end.transform(X_test)\n",
    "\n",
    "model = RandomForestRegressor()\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",
    "grid_search = GridSearchCV(estimator=model, param_grid=param_grid,\n",
    "                           scoring='neg_mean_squared_error', cv=3, n_jobs=-1, verbose=2)\n",
    "\n",
    "grid_search.fit(X_train_processed, y_train)\n",
    "\n",
    "print(\"Лучшие параметры:\", grid_search.best_params_)\n",
    "print(\"Лучший результат (MSE):\", -grid_search.best_score_)  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Обучение модели с новыми гиперпараметрами и сравнение новых и старых данных"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\Users\\goldfest\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\sklearn\\preprocessing\\_encoders.py:242: UserWarning: Found unknown categories in columns [0, 1, 2] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting 3 folds for each of 36 candidates, totalling 108 fits\n",
      "Старые параметры: {'max_depth': 30, 'min_samples_split': 2, 'n_estimators': 50}\n",
      "Лучший результат (MSE) на старых параметрах: 76.4137021557455\n",
      "\n",
      "Новые параметры: {'max_depth': 10, 'min_samples_split': 10, 'n_estimators': 200}\n",
      "Лучший результат (MSE) на новых параметрах: 180.57283215031268\n",
      "Среднеквадратическая ошибка (MSE) на тестовых данных: 507.05822479642404\n",
      "Корень среднеквадратичной ошибки (RMSE) на тестовых данных: 22.517953388272748\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, LabelEncoder\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",
    "df = pd.read_csv(\"..//static//csv//Forbes Billionaires.csv\").head(100)\n",
    "\n",
    "df = df.dropna()\n",
    "target = df['Networth']\n",
    "\n",
    "features = df.drop(columns=['Networth'])\n",
    "\n",
    "features = features.drop(columns=['Name'])\n",
    "num_columns = features.select_dtypes(include=['number']).columns\n",
    "cat_columns = features.select_dtypes(include=['object']).columns\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",
    "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",
    "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",
    "pipeline_end = Pipeline(\n",
    "    [\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",
    "X_train_processed = pipeline_end.fit_transform(X_train)\n",
    "X_test_processed = pipeline_end.transform(X_test)\n",
    "\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",
    "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",
    "old_grid_search.fit(X_train_processed, y_train)\n",
    "old_best_params = old_grid_search.best_params_\n",
    "old_best_mse = -old_grid_search.best_score_ \n",
    "new_param_grid = {\n",
    "    'n_estimators': [200],\n",
    "    'max_depth': [10],\n",
    "    'min_samples_split': [10]\n",
    "}\n",
    "\n",
    "new_grid_search = GridSearchCV(estimator=RandomForestRegressor(), \n",
    "                                param_grid=new_param_grid,\n",
    "                                scoring='neg_mean_squared_error', cv=2)\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_  # Меняем знак, так как берем отрицательное значение MSE\n",
    "\n",
    "# Обучение модели с лучшими параметрами для новых значений\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",
    "model_old = RandomForestRegressor(**old_best_params)\n",
    "model_old.fit(X_train_processed, y_train)\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()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Модель, обученная на новых параметрах, показала худший результат (MSE) на кросс-валидации, что указывает на ее меньшую точность по сравнению с моделью, обученной на старых параметрах. Однако, MSE на тестовых данных одинакова для обеих моделей, что говорит о том, что обе модели имеют одинаковую производительность на тестовых данных."
   ]
  }
 ],
 "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.12.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}