From fadc98a28a34909d67276aa762f638a08fdef784 Mon Sep 17 00:00:00 2001 From: revengel66 Date: Sat, 30 Nov 2024 21:28:28 +0300 Subject: [PATCH] lab4 ready --- lab_4/lab4_class.ipynb | 2322 ++++++++++++++++++++++++++++++++++++++++ lab_4/lab4_reg.ipynb | 967 +++++++++++++++++ utils.py | 79 ++ 3 files changed, 3368 insertions(+) create mode 100644 lab_4/lab4_class.ipynb create mode 100644 lab_4/lab4_reg.ipynb create mode 100644 utils.py diff --git a/lab_4/lab4_class.ipynb b/lab_4/lab4_class.ipynb new file mode 100644 index 0000000..2d6f4ea --- /dev/null +++ b/lab_4/lab4_class.ipynb @@ -0,0 +1,2322 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Лабораторная работа №3\n", + "\n", + "## Набор данных Students Performance in Exams (Успеваемость студентов на экзаменах)\n", + "\n", + "Выгрузка данных из CSV файла в датафрейм" + ] + }, + { + "cell_type": "code", + "execution_count": 674, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import numpy as np\n", + "from sklearn import set_config\n", + "\n", + "set_config(transform_output=\"pandas\")\n", + "\n", + "random_state=9\n", + "# Загрузка данных\n", + "df = pd.read_csv(\"..//..//static//csv//StudentsPerformance.csv\")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Описание набора \n", + "\n", + "Контекст\n", + "Оценки, полученные студентами\n", + "\n", + "Содержание\n", + "Этот набор данных состоит из оценок, полученных учащимися по различным предметам.\n", + "\n", + "Вдохновение\n", + "Понять влияние происхождения родителей, подготовки к тестированию и т. д. на успеваемость учащихся." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Анализ содержимого\n", + "\n", + "*Объекты наблюдения:* студенты, участвующие в экзаменах.\n", + "\n", + "*Атрибуты объектов:* \n", + "\n", + "1. gender — пол: определяет гендерную принадлежность студента (мужской, женский). \n", + "2. race/ethnicity — этническая принадлежность: группа, к которой относится студент (например, различные расовые/этнические категории). \n", + "3. parental level of education — уровень образования родителей(например, среднее образование, высшее образование и т.д.). \n", + "4. lunch — тип обеда: информация о том, получает ли студент бесплатный или платный обед. \n", + "5. test preparation course — курс подготовки к тесту\n", + "6. math score — результаты экзаменов по математике.\n", + "7. reading score — результаты экзаменов по чтению.\n", + "8. writing score — результаты экзаменов по письму.\n", + "\n", + "\n", + "### Бизнес-цель:\n", + "\n", + "**Цель**: Разработка модели, которая будет классифицировать студентов на основе их предсказанных баллов в одну из категорий: High, Medium, Low. \n", + "\n", + "**Эффект**: Это позволит образовательным учреждениям не только выявлять студентов с низкими результатами, но и более точно классифицировать их на разные группы. Например, те, кто попадает в группу \"High\", могут получить более сложные задания, а те, кто в группе \"Low\", могут потребовать дополнительной помощи.\n", + "\n", + "\n", + "### Техническая цель\n", + "\n", + "**Цель**: Разработка классификационной модели, которая будет работать с целевым признаком \"total_score_discrete\", классифицируя студентов по трем категориям (High, Medium, Low). \n", + "\n", + "**Подход**: Для этой задачи можно использовать алгоритмы классификации, такие как логистическая регрессия, деревья решений или случайные леса. Модели должны учитывать категориальные переменные и их влияние на категориальный целевой признак. Методы переклассификации будут оценивать, в какую категорию попадает студент на основе его характеристик.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Конструирование признаков для решения задач\n", + "\n", + "Можно создать новый признак, который будет представлять общую успеваемость студента. Например, можно суммировать баллы по всем предметам и создать общий балл. \n", + "\n", + "Далее используем дискретизацию числового признака (преобразование баллов в категории) для обучения модели, которая будет работать с дискретными данными, а не с непрерывными.\n", + "\n", + "Категории:\n", + "\n", + "\"Low\", \"Medium\", \"High\" для баллов\n" + ] + }, + { + "cell_type": "code", + "execution_count": 675, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.model_selection import train_test_split\n", + "from sklearn.preprocessing import StandardScaler\n", + "\n", + "# Создание новых признаков\n", + "# - Общий балл\n", + "df['total_score'] = df['math score'] + df['reading score'] + df['writing score']\n", + "\n", + "# - Категоризация баллов по математике, чтению и письму\n", + "def discretize_score(score):\n", + " if score < 200:\n", + " return 0\n", + " elif 200 <= score < 250:\n", + " return 1\n", + " else:\n", + " return 2\n", + "df['total_score_discrete'] = df['total_score'].apply(lambda x: discretize_score(x))\n", + "\n", + "df = df.drop(columns=['math score', 'reading score', 'writing score','total_score'])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Выберем три модели для задач классификации\n", + "\n", + "1. Логистическая регрессия (Logistic Regression) — базовая модель для классификации.\n", + "\n", + "2. Дерево решений (Decision Tree) — модель, которая хорошо справляется с выявлением сложных закономерностей.\n", + "\n", + "3. Градиентный бустинг (Gradient Boosting) — мощная ансамблевая модель, обеспечивающая высокое качество предсказаний.\n", + "\n", + "Модели выбраны исходя из того, что они предоставляют разные подходы к решению задачи, и это позволит сравнить эффективность различных методов." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Разделение набора данных на обучающую и тестовые выборки (80/20) для задачи классификации и создание ориентира\n", + "\n", + "Целевой признак -- total_score_discrete" + ] + }, + { + "cell_type": "code", + "execution_count": 676, + "metadata": {}, + "outputs": [], + "source": [ + "from utils import split_stratified_into_train_val_test\n", + "\n", + "X_train, X_val, X_test, y_train, y_val, y_test = split_stratified_into_train_val_test(\n", + " df, stratify_colname=\"total_score_discrete\", frac_train=0.80, frac_val=0, frac_test=0.20, random_state=random_state\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Аугментация данных для целевого признака в обучающей выборке" + ] + }, + { + "cell_type": "code", + "execution_count": 677, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Количество данных в y_train до RandomOverSampling: 800\n", + "Количество данных в X_train до RandomOverSampling: 800\n", + "Количество данных в y_train после RandomOverSampling: 1065\n", + "Количество данных в X_train после RandomOverSampling: 1065\n" + ] + } + ], + "source": [ + "from imblearn.over_sampling import RandomOverSampler\n", + "\n", + "\n", + "print(\"Количество данных в y_train до RandomOverSampling:\", len(y_train))\n", + "print(\"Количество данных в X_train до RandomOverSampling:\", len(X_train))\n", + "\n", + "# Объединяем исходные данные и \"шумные\" данные для увеличения обучающей выборки\n", + "X_train_combined = np.vstack([X_train, X_train])\n", + "y_train_combined = np.hstack([y_train, y_train]) # Убедитесь, что y_train повторяется для новых данных\n", + "\n", + "# Применение oversampling и undersampling\n", + "ros = RandomOverSampler(random_state=42)\n", + "X_train, y_train = ros.fit_resample(X_train, y_train)\n", + "\n", + "\n", + "print(\"Количество данных в y_train после RandomOverSampling:\", len(y_train))\n", + "print(\"Количество данных в X_train после RandomOverSampling:\", len(X_train))\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Формирование конвейера" + ] + }, + { + "cell_type": "code", + "execution_count": 678, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.compose import ColumnTransformer\n", + "from sklearn.discriminant_analysis import StandardScaler\n", + "from sklearn.impute import SimpleImputer\n", + "from sklearn.pipeline import Pipeline\n", + "from sklearn.preprocessing import OneHotEncoder\n", + "\n", + "\n", + "columns_to_drop = [\"total_score_discrete\"]\n", + "num_columns = [\n", + " column\n", + " for column in df.columns\n", + " if column not in columns_to_drop and df[column].dtype != \"object\"\n", + "]\n", + "cat_columns = [\n", + " column\n", + " for column in df.columns\n", + " if column not in columns_to_drop and df[column].dtype == \"object\"\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", + "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", + " force_int_remainder_cols=False \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" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Настройка гиперпараметров для каждой модели и обучение\n", + "\n", + "Для каждой модели важно настроить гиперпараметры, чтобы достичь наилучших результатов. Мы будем использовать GridSearchCV для выполнения кросс-валидации и выбора оптимальных гиперпараметров для каждой модели.\n", + "\n", + "##### 1. Логистическая регрессия\n", + "Для логистической регрессии мы настроим гиперпараметры регуляризации C и оптимизатор." + ] + }, + { + "cell_type": "code", + "execution_count": 679, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "d:\\5semestr\\AIM\\aimvenv\\Lib\\site-packages\\sklearn\\compose\\_column_transformer.py:1623: FutureWarning: \n", + "The format of the columns of the 'remainder' transformer in ColumnTransformer.transformers_ will change in version 1.7 to match the format of the other transformers.\n", + "At the moment the remainder columns are stored as indices (of type int). With the same ColumnTransformer configuration, in the future they will be stored as column names (of type str).\n", + "To use the new behavior now and suppress this warning, use ColumnTransformer(force_int_remainder_cols=False).\n", + "\n", + " warnings.warn(\n" + ] + }, + { + "data": { + "text/html": [ + "
GridSearchCV(cv=5,\n",
+       "             estimator=Pipeline(steps=[('features_preprocessing',\n",
+       "                                        ColumnTransformer(force_int_remainder_cols=False,\n",
+       "                                                          remainder='passthrough',\n",
+       "                                                          transformers=[('prepocessing_num',\n",
+       "                                                                         Pipeline(steps=[('imputer',\n",
+       "                                                                                          SimpleImputer(strategy='median')),\n",
+       "                                                                                         ('scaler',\n",
+       "                                                                                          StandardScaler())]),\n",
+       "                                                                         []),\n",
+       "                                                                        ('prepocessing_cat',\n",
+       "                                                                         Pipeline(steps=[('imputer',\n",
+       "                                                                                          SimpleImputer(fill_value='unkno...\n",
+       "                                                                          'preparation '\n",
+       "                                                                          'course'])],\n",
+       "                                                          verbose_feature_names_out=False)),\n",
+       "                                       ('drop_columns',\n",
+       "                                        ColumnTransformer(remainder='passthrough',\n",
+       "                                                          transformers=[('drop_columns',\n",
+       "                                                                         'drop',\n",
+       "                                                                         ['total_score_discrete'])],\n",
+       "                                                          verbose_feature_names_out=False)),\n",
+       "                                       ('model',\n",
+       "                                        LogisticRegression(max_iter=1000,\n",
+       "                                                           random_state=9))]),\n",
+       "             n_jobs=-1,\n",
+       "             param_grid={'model__C': [0.1, 1, 10],\n",
+       "                         'model__solver': ['liblinear', 'saga']})
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + ], + "text/plain": [ + "GridSearchCV(cv=5,\n", + " estimator=Pipeline(steps=[('features_preprocessing',\n", + " ColumnTransformer(force_int_remainder_cols=False,\n", + " remainder='passthrough',\n", + " transformers=[('prepocessing_num',\n", + " Pipeline(steps=[('imputer',\n", + " SimpleImputer(strategy='median')),\n", + " ('scaler',\n", + " StandardScaler())]),\n", + " []),\n", + " ('prepocessing_cat',\n", + " Pipeline(steps=[('imputer',\n", + " SimpleImputer(fill_value='unkno...\n", + " 'preparation '\n", + " 'course'])],\n", + " verbose_feature_names_out=False)),\n", + " ('drop_columns',\n", + " ColumnTransformer(remainder='passthrough',\n", + " transformers=[('drop_columns',\n", + " 'drop',\n", + " ['total_score_discrete'])],\n", + " verbose_feature_names_out=False)),\n", + " ('model',\n", + " LogisticRegression(max_iter=1000,\n", + " random_state=9))]),\n", + " n_jobs=-1,\n", + " param_grid={'model__C': [0.1, 1, 10],\n", + " 'model__solver': ['liblinear', 'saga']})" + ] + }, + "execution_count": 679, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from sklearn.linear_model import LogisticRegression\n", + "from sklearn.model_selection import GridSearchCV\n", + "from sklearn.pipeline import Pipeline\n", + "\n", + "# Модель логистической регрессии\n", + "logistic_model = LogisticRegression(max_iter=1000, random_state=random_state)\n", + "\n", + "# Создаём пайплайн, который сначала применяет preprocessing, а потом обучает модель\n", + "logistic_pipeline = Pipeline([\n", + " (\"features_preprocessing\", features_preprocessing),\n", + " (\"drop_columns\", drop_columns),\n", + " (\"model\", logistic_model) # Здесь добавляем модель в пайплайн\n", + "])\n", + "\n", + "# Параметры для настройки\n", + "logistic_param_grid = {\n", + " 'model__C': [0.1, 1, 10], # Регуляризация\n", + " 'model__solver': ['liblinear', 'saga'] # Алгоритм оптимизации\n", + "}\n", + "\n", + "# Настройка гиперпараметров с использованием GridSearchCV\n", + "logistic_search = GridSearchCV(logistic_pipeline, logistic_param_grid, cv=5, n_jobs=-1)\n", + "\n", + "# Обучаем модель\n", + "logistic_search.fit(X_train, y_train.values.ravel())\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### 2. Дерево решений\n", + "\n", + "Для дерева решений мы будем настраивать гиперпараметры, такие как максимальная глубина и минимальное количество объектов для разделения.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 680, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "d:\\5semestr\\AIM\\aimvenv\\Lib\\site-packages\\sklearn\\compose\\_column_transformer.py:1623: FutureWarning: \n", + "The format of the columns of the 'remainder' transformer in ColumnTransformer.transformers_ will change in version 1.7 to match the format of the other transformers.\n", + "At the moment the remainder columns are stored as indices (of type int). With the same ColumnTransformer configuration, in the future they will be stored as column names (of type str).\n", + "To use the new behavior now and suppress this warning, use ColumnTransformer(force_int_remainder_cols=False).\n", + "\n", + " warnings.warn(\n" + ] + }, + { + "data": { + "text/html": [ + "
GridSearchCV(cv=5,\n",
+       "             estimator=Pipeline(steps=[('features_preprocessing',\n",
+       "                                        ColumnTransformer(force_int_remainder_cols=False,\n",
+       "                                                          remainder='passthrough',\n",
+       "                                                          transformers=[('prepocessing_num',\n",
+       "                                                                         Pipeline(steps=[('imputer',\n",
+       "                                                                                          SimpleImputer(strategy='median')),\n",
+       "                                                                                         ('scaler',\n",
+       "                                                                                          StandardScaler())]),\n",
+       "                                                                         []),\n",
+       "                                                                        ('prepocessing_cat',\n",
+       "                                                                         Pipeline(steps=[('imputer',\n",
+       "                                                                                          SimpleImputer(fill_value='unkno...\n",
+       "                                                          verbose_feature_names_out=False)),\n",
+       "                                       ('drop_columns',\n",
+       "                                        ColumnTransformer(remainder='passthrough',\n",
+       "                                                          transformers=[('drop_columns',\n",
+       "                                                                         'drop',\n",
+       "                                                                         ['total_score_discrete'])],\n",
+       "                                                          verbose_feature_names_out=False)),\n",
+       "                                       ('model',\n",
+       "                                        DecisionTreeClassifier(random_state=9))]),\n",
+       "             n_jobs=-1,\n",
+       "             param_grid={'model__max_depth': [5, 10, None],\n",
+       "                         'model__min_samples_leaf': [1, 2, 4],\n",
+       "                         'model__min_samples_split': [2, 5, 10]})
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + ], + "text/plain": [ + "GridSearchCV(cv=5,\n", + " estimator=Pipeline(steps=[('features_preprocessing',\n", + " ColumnTransformer(force_int_remainder_cols=False,\n", + " remainder='passthrough',\n", + " transformers=[('prepocessing_num',\n", + " Pipeline(steps=[('imputer',\n", + " SimpleImputer(strategy='median')),\n", + " ('scaler',\n", + " StandardScaler())]),\n", + " []),\n", + " ('prepocessing_cat',\n", + " Pipeline(steps=[('imputer',\n", + " SimpleImputer(fill_value='unkno...\n", + " verbose_feature_names_out=False)),\n", + " ('drop_columns',\n", + " ColumnTransformer(remainder='passthrough',\n", + " transformers=[('drop_columns',\n", + " 'drop',\n", + " ['total_score_discrete'])],\n", + " verbose_feature_names_out=False)),\n", + " ('model',\n", + " DecisionTreeClassifier(random_state=9))]),\n", + " n_jobs=-1,\n", + " param_grid={'model__max_depth': [5, 10, None],\n", + " 'model__min_samples_leaf': [1, 2, 4],\n", + " 'model__min_samples_split': [2, 5, 10]})" + ] + }, + "execution_count": 680, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from sklearn.tree import DecisionTreeClassifier\n", + "\n", + "from sklearn.linear_model import LogisticRegression\n", + "from sklearn.model_selection import GridSearchCV\n", + "from sklearn.pipeline import Pipeline\n", + "\n", + "# Модель дерева решений\n", + "decision_tree_model = DecisionTreeClassifier(random_state=random_state)\n", + "\n", + "# Создаём пайплайн, который сначала применяет preprocessing, а потом обучает модель\n", + "decision_tree_pipeline = Pipeline([\n", + " (\"features_preprocessing\", features_preprocessing),\n", + " (\"drop_columns\", drop_columns),\n", + " (\"model\", decision_tree_model) # Здесь добавляем модель в пайплайн\n", + "])\n", + "\n", + "# Параметры для настройки\n", + "tree_param_grid = {\n", + " 'model__max_depth': [5, 10, None], # Глубина дерева\n", + " 'model__min_samples_split': [2, 5, 10], # Минимальное количество объектов для разделения\n", + " 'model__min_samples_leaf': [1, 2, 4], # Минимальное количество объектов в листе\n", + "}\n", + "\n", + "tree_search = GridSearchCV(decision_tree_pipeline, tree_param_grid, cv=5, n_jobs=-1)\n", + "\n", + "# Обучаем модель\n", + "tree_search.fit(X_train, y_train.values.ravel())\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### 3. Градиентный бустинг\n", + "\n", + "Для градиентного бустинга будем настраивать параметры, такие как количество деревьев и скорость обучения." + ] + }, + { + "cell_type": "code", + "execution_count": 681, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "d:\\5semestr\\AIM\\aimvenv\\Lib\\site-packages\\sklearn\\compose\\_column_transformer.py:1623: FutureWarning: \n", + "The format of the columns of the 'remainder' transformer in ColumnTransformer.transformers_ will change in version 1.7 to match the format of the other transformers.\n", + "At the moment the remainder columns are stored as indices (of type int). With the same ColumnTransformer configuration, in the future they will be stored as column names (of type str).\n", + "To use the new behavior now and suppress this warning, use ColumnTransformer(force_int_remainder_cols=False).\n", + "\n", + " warnings.warn(\n" + ] + }, + { + "data": { + "text/html": [ + "
GridSearchCV(cv=5,\n",
+       "             estimator=Pipeline(steps=[('features_preprocessing',\n",
+       "                                        ColumnTransformer(force_int_remainder_cols=False,\n",
+       "                                                          remainder='passthrough',\n",
+       "                                                          transformers=[('prepocessing_num',\n",
+       "                                                                         Pipeline(steps=[('imputer',\n",
+       "                                                                                          SimpleImputer(strategy='median')),\n",
+       "                                                                                         ('scaler',\n",
+       "                                                                                          StandardScaler())]),\n",
+       "                                                                         []),\n",
+       "                                                                        ('prepocessing_cat',\n",
+       "                                                                         Pipeline(steps=[('imputer',\n",
+       "                                                                                          SimpleImputer(fill_value='unkno...\n",
+       "                                                          verbose_feature_names_out=False)),\n",
+       "                                       ('drop_columns',\n",
+       "                                        ColumnTransformer(remainder='passthrough',\n",
+       "                                                          transformers=[('drop_columns',\n",
+       "                                                                         'drop',\n",
+       "                                                                         ['total_score_discrete'])],\n",
+       "                                                          verbose_feature_names_out=False)),\n",
+       "                                       ('model',\n",
+       "                                        GradientBoostingClassifier(random_state=9))]),\n",
+       "             n_jobs=-1,\n",
+       "             param_grid={'model__learning_rate': [0.05, 0.1, 0.2],\n",
+       "                         'model__max_depth': [3, 5],\n",
+       "                         'model__n_estimators': [100, 200]})
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + ], + "text/plain": [ + "GridSearchCV(cv=5,\n", + " estimator=Pipeline(steps=[('features_preprocessing',\n", + " ColumnTransformer(force_int_remainder_cols=False,\n", + " remainder='passthrough',\n", + " transformers=[('prepocessing_num',\n", + " Pipeline(steps=[('imputer',\n", + " SimpleImputer(strategy='median')),\n", + " ('scaler',\n", + " StandardScaler())]),\n", + " []),\n", + " ('prepocessing_cat',\n", + " Pipeline(steps=[('imputer',\n", + " SimpleImputer(fill_value='unkno...\n", + " verbose_feature_names_out=False)),\n", + " ('drop_columns',\n", + " ColumnTransformer(remainder='passthrough',\n", + " transformers=[('drop_columns',\n", + " 'drop',\n", + " ['total_score_discrete'])],\n", + " verbose_feature_names_out=False)),\n", + " ('model',\n", + " GradientBoostingClassifier(random_state=9))]),\n", + " n_jobs=-1,\n", + " param_grid={'model__learning_rate': [0.05, 0.1, 0.2],\n", + " 'model__max_depth': [3, 5],\n", + " 'model__n_estimators': [100, 200]})" + ] + }, + "execution_count": 681, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from sklearn.ensemble import GradientBoostingClassifier\n", + "\n", + "# Модель градиентного бустинга\n", + "gradient_boosting_model = GradientBoostingClassifier(random_state=random_state)\n", + "\n", + "# Создаём пайплайн, который сначала применяет preprocessing, а потом обучает модель\n", + "gradient_boosting_pipeline = Pipeline([\n", + " (\"features_preprocessing\", features_preprocessing),\n", + " (\"drop_columns\", drop_columns),\n", + " (\"model\", gradient_boosting_model) # Здесь добавляем модель в пайплайн\n", + "])\n", + "\n", + "# Параметры для настройки\n", + "gb_param_grid = {\n", + " 'model__n_estimators': [100, 200], # Количество деревьев\n", + " 'model__learning_rate': [0.05, 0.1, 0.2], # Темп обучения\n", + " 'model__max_depth': [3, 5], # Глубина деревьев\n", + "}\n", + "\n", + "gb_search = GridSearchCV(gradient_boosting_pipeline, gb_param_grid, cv=5, n_jobs=-1)\n", + "\n", + "# Обучаем модель\n", + "gb_search.fit(X_train, y_train.values.ravel())\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Оценка качества моделей\n", + "\n", + "Для оценки качества моделей будем использовать следующие метрики:\n", + "\n", + "Accuracy — это базовая метрика, которая подходит для сбалансированных данных. Она поможет понять, какой процент всех предсказаний был верным.\n", + "\n", + "Precision и Recall — эти метрики важны, когда данные могут быть несбалансированными. Для многоклассовых задач важно использовать macro-average, что означает вычисление этих метрик для каждого класса и усреднение.\n", + "\n", + "F1-Score — хорошая метрика для задач с несбалансированными классами, так как она учитывает и точность, и полноту. Это важно, если ложные положительные и ложные отрицательные ошибки одинаково важны.\n", + "\n", + "ROC AUC — используется для оценки качества модели в контексте разделения классов, особенно если у нас есть вероятности для каждого класса. Это даст дополнительную информацию о том, насколько хорошо модель различает классы.\n", + "\n", + "MCC — это особенно полезно для оценки качества модели в случае несбалансированных данных. Это метрика, которая дает более сбалансированное представление о том, как модель предсказывает все классы." + ] + }, + { + "cell_type": "code", + "execution_count": 682, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Accuracy: 0.4550\n", + "Precision (macro): 0.4669\n", + "Recall (macro): 0.5094\n", + "F1-Score (macro): 0.4323\n", + "ROC AUC (macro): 0.6811\n", + "MCC: 0.2188\n", + "Confusion Matrix:\n", + "[[51 12 26]\n", + " [30 20 33]\n", + " [ 3 5 20]]\n" + ] + } + ], + "source": [ + "from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, roc_auc_score, confusion_matrix, matthews_corrcoef\n", + "\n", + "# Получаем предсказания\n", + "y_pred = logistic_search.predict(X_test)\n", + "\n", + "# Оценка качества модели\n", + "accuracy = accuracy_score(y_test, y_pred)\n", + "precision = precision_score(y_test, y_pred, average='macro') # Для многоклассовой задачи используем macro\n", + "recall = recall_score(y_test, y_pred, average='macro')\n", + "f1 = f1_score(y_test, y_pred, average='macro')\n", + "roc_auc = roc_auc_score(y_test, logistic_search.predict_proba(X_test), multi_class='ovr', average='macro')\n", + "mcc = matthews_corrcoef(y_test, y_pred)\n", + "\n", + "# Матрица ошибок\n", + "conf_matrix = confusion_matrix(y_test, y_pred)\n", + "\n", + "# Печать метрик\n", + "print(f\"Accuracy: {accuracy:.4f}\")\n", + "print(f\"Precision (macro): {precision:.4f}\")\n", + "print(f\"Recall (macro): {recall:.4f}\")\n", + "print(f\"F1-Score (macro): {f1:.4f}\")\n", + "print(f\"ROC AUC (macro): {roc_auc:.4f}\")\n", + "print(f\"MCC: {mcc:.4f}\")\n", + "print(f\"Confusion Matrix:\\n{conf_matrix}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 683, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Accuracy: 0.4050\n", + "Precision (macro): 0.3830\n", + "Recall (macro): 0.4010\n", + "F1-Score (macro): 0.3819\n", + "ROC AUC (macro): 0.5808\n", + "MCC: 0.0763\n", + "Confusion Matrix:\n", + "[[41 32 16]\n", + " [30 29 24]\n", + " [ 8 9 11]]\n" + ] + } + ], + "source": [ + "from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, roc_auc_score, confusion_matrix, matthews_corrcoef\n", + "\n", + "# Получаем предсказания\n", + "y_pred = tree_search.predict(X_test)\n", + "\n", + "# Оценка качества модели\n", + "accuracy = accuracy_score(y_test, y_pred)\n", + "precision = precision_score(y_test, y_pred, average='macro') # Для многоклассовой задачи используем macro\n", + "recall = recall_score(y_test, y_pred, average='macro')\n", + "f1 = f1_score(y_test, y_pred, average='macro')\n", + "roc_auc = roc_auc_score(y_test, tree_search.predict_proba(X_test), multi_class='ovr', average='macro')\n", + "mcc = matthews_corrcoef(y_test, y_pred)\n", + "\n", + "# Матрица ошибок\n", + "conf_matrix = confusion_matrix(y_test, y_pred)\n", + "\n", + "# Печать метрик\n", + "print(f\"Accuracy: {accuracy:.4f}\")\n", + "print(f\"Precision (macro): {precision:.4f}\")\n", + "print(f\"Recall (macro): {recall:.4f}\")\n", + "print(f\"F1-Score (macro): {f1:.4f}\")\n", + "print(f\"ROC AUC (macro): {roc_auc:.4f}\")\n", + "print(f\"MCC: {mcc:.4f}\")\n", + "print(f\"Confusion Matrix:\\n{conf_matrix}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 684, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Accuracy: 0.4100\n", + "Precision (macro): 0.3873\n", + "Recall (macro): 0.3889\n", + "F1-Score (macro): 0.3783\n", + "ROC AUC (macro): 0.5806\n", + "MCC: 0.0895\n", + "Confusion Matrix:\n", + "[[42 30 17]\n", + " [25 31 27]\n", + " [ 7 12 9]]\n" + ] + } + ], + "source": [ + "from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, roc_auc_score, confusion_matrix, matthews_corrcoef\n", + "\n", + "# Получаем предсказания\n", + "y_pred = gb_search.predict(X_test)\n", + "\n", + "# Оценка качества модели\n", + "accuracy = accuracy_score(y_test, y_pred)\n", + "precision = precision_score(y_test, y_pred, average='macro') # Для многоклассовой задачи используем macro\n", + "recall = recall_score(y_test, y_pred, average='macro')\n", + "f1 = f1_score(y_test, y_pred, average='macro')\n", + "roc_auc = roc_auc_score(y_test, gb_search.predict_proba(X_test), multi_class='ovr', average='macro')\n", + "mcc = matthews_corrcoef(y_test, y_pred)\n", + "\n", + "# Матрица ошибок\n", + "conf_matrix = confusion_matrix(y_test, y_pred)\n", + "\n", + "# Печать метрик\n", + "print(f\"Accuracy: {accuracy:.4f}\")\n", + "print(f\"Precision (macro): {precision:.4f}\")\n", + "print(f\"Recall (macro): {recall:.4f}\")\n", + "print(f\"F1-Score (macro): {f1:.4f}\")\n", + "print(f\"ROC AUC (macro): {roc_auc:.4f}\")\n", + "print(f\"MCC: {mcc:.4f}\")\n", + "print(f\"Confusion Matrix:\\n{conf_matrix}\")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Логистическая регрессия показывает наилучшие результаты по большинству метрик, включая точность, полноту, F1-Score и ROC AUC. Она также имеет лучший MCC, что говорит о лучшем качестве предсказаний с учетом всех классов. Хотя все модели показывают относительно низкие значения, логистическая регрессия явно выделяется среди других.\n", + "\n", + "Лучшей моделью является логистическая регрессия на основе анализа метрик." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Оценка смещения и дисперсии лучшей модели (логистическая регрессия)." + ] + }, + { + "cell_type": "code", + "execution_count": 685, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Средняя точность на обучающих данных (кросс-валидация): 0.5023474178403756\n", + "Точность на обучающей выборке: 0.536150234741784\n", + "Точность на тестовой выборке: 0.47\n", + "Смещение (Bias): 0.53\n", + "Дисперсия (Variance): 0.000581895126628314\n" + ] + } + ], + "source": [ + "from sklearn.model_selection import cross_val_score\n", + "from sklearn.metrics import accuracy_score\n", + "from sklearn.model_selection import KFold\n", + "\n", + "# Кросс-валидация на обучающих данных\n", + "kf = KFold(n_splits=5, shuffle=True, random_state=random_state)\n", + "train_accuracies = cross_val_score(logistic_pipeline, X_train, y_train.values.ravel(), cv=kf, scoring=\"accuracy\")\n", + "\n", + "# Прогнозирование на обучающих и тестовых данных\n", + "logistic_pipeline.fit(X_train, y_train.values.ravel())\n", + "train_accuracy = accuracy_score(y_train, logistic_pipeline.predict(X_train))\n", + "test_accuracy = accuracy_score(y_test, logistic_pipeline.predict(X_test))\n", + "\n", + "# Смещение (Bias)\n", + "bias = 1 - test_accuracy # Ошибка на тестовой выборке\n", + "\n", + "# Дисперсия (Variance)\n", + "variance = np.var(train_accuracies) # Дисперсия на обучающей выборке\n", + "\n", + "# Выводим результаты\n", + "print(f\"Средняя точность на обучающих данных (кросс-валидация): {np.mean(train_accuracies)}\")\n", + "print(f\"Точность на обучающей выборке: {train_accuracy}\")\n", + "print(f\"Точность на тестовой выборке: {test_accuracy}\")\n", + "print(f\"Смещение (Bias): {bias}\")\n", + "print(f\"Дисперсия (Variance): {variance}\")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Оценка модели: \n", + "\n", + "Смещение высокое (Bias = 53%) — это указывает на недообучение модели. Модель не может хорошо предсказать целевой признак на тестовых данных, что означает, что она слишком простая для данного набора данных или её регуляризация слишком сильна.\n", + "\n", + "Дисперсия низкая (Variance = 0.00058) — это также подтверждает, что модель не переобучена. Она не слишком чувствительна к изменениям в обучающих данных." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "aimvenv", + "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.6" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/lab_4/lab4_reg.ipynb b/lab_4/lab4_reg.ipynb new file mode 100644 index 0000000..d9ac935 --- /dev/null +++ b/lab_4/lab4_reg.ipynb @@ -0,0 +1,967 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Лабораторная работа №3\n", + "\n", + "## Набор данных Students Performance in Exams (Успеваемость студентов на экзаменах)\n", + "\n", + "Выгрузка данных из CSV файла в датафрейм" + ] + }, + { + "cell_type": "code", + "execution_count": 178, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "# Загрузка данных\n", + "df = pd.read_csv(\"..//..//static//csv//StudentsPerformance.csv\")\n", + "\n", + "random_state=9" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Описание набора \n", + "\n", + "Контекст\n", + "Оценки, полученные студентами\n", + "\n", + "Содержание\n", + "Этот набор данных состоит из оценок, полученных учащимися по различным предметам.\n", + "\n", + "Вдохновение\n", + "Понять влияние происхождения родителей, подготовки к тестированию и т. д. на успеваемость учащихся." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Анализ содержимого\n", + "\n", + "*Объекты наблюдения:* студенты, участвующие в экзаменах.\n", + "\n", + "*Атрибуты объектов:* \n", + "\n", + "1. gender — пол: определяет гендерную принадлежность студента (мужской, женский). \n", + "2. race/ethnicity — этническая принадлежность: группа, к которой относится студент (например, различные расовые/этнические категории). \n", + "3. parental level of education — уровень образования родителей(например, среднее образование, высшее образование и т.д.). \n", + "4. lunch — тип обеда: информация о том, получает ли студент бесплатный или платный обед. \n", + "5. test preparation course — курс подготовки к тесту\n", + "6. math score — результаты экзаменов по математике.\n", + "7. reading score — результаты экзаменов по чтению.\n", + "8. writing score — результаты экзаменов по письму.\n", + "\n", + "\n", + "### Бизнес-цель:\n", + "\n", + "**Цель**: Прогнозирование успеваемости студентов на основе различных факторов, таких как пол, раса/этническая принадлежность, уровень образования родителей, тип обеда и участие в подготовительных курсах. \n", + "\n", + "**Эффект**: Предсказание результатов студентов позволяет выявить тех, кто может столкнуться с трудностями в учебе. Это дает возможность образовательным учреждениям предпринимать превентивные меры: например, организовывать дополнительные занятия, персонализированные консультации, улучшать условия обучения и даже вмешиваться на более ранних стадиях, чтобы повысить общий уровень успеваемости.\n", + "\n", + "\n", + "### Техническая цель\n", + "**Цель**: Создание регрессионной модели, которая будет предсказывать общий балл студентов (или другой числовой показатель успеваемости) на основе категориальных и числовых данных. Это потребует использования методов линейной или нелинейной регрессии для определения зависимости между признаками (пол, уровень образования родителей и т.д.) и итоговым баллом. \n", + "\n", + "**Подход**: Для решения задачи нужно использовать числовые признаки, такие как \"math score\", \"reading score\", \"writing score\", и выполнить их агрегацию (например, суммирование или среднее), чтобы построить прогноз для общего балла. Модели, такие как линейная регрессия или регрессия на основе деревьев решений, подойдут для этого. у которых ожидаются низкие результаты на экзаменах, тем самым повышая их шансы на успешную сдачу экзаменов.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Конструирование признаков для решения задач\n", + "\n", + "Можно создать новый признак, который будет представлять общую успеваемость студента. Например, можно суммировать баллы по всем предметам и создать общий балл. \n" + ] + }, + { + "cell_type": "code", + "execution_count": 179, + "metadata": {}, + "outputs": [], + "source": [ + "df['total_score'] = df['math score'] + df['reading score'] + df['writing score']\n", + "df = df.drop(columns=['math score', 'reading score', 'writing score'])\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Выберем три модели для задач регрессии\n", + "\n", + "1. Линейная регрессия служит базовой моделью, чтобы понять, насколько линейны зависимости между признаками и целевой переменной. Это важный шаг для проверки простых гипотез.\n", + "\n", + "2. Случайный лес используется для обработки данных с более сложными зависимостями, когда данные могут содержать нелинейные связи, которые линейная регрессия не может уловить.\n", + "\n", + "3. Градиентный бустинг — это более сложная модель, которая позволяет добиться высокой точности, особенно при наличии сложных закономерностей в данных. Он может предложить лучшее качество прогноза при оптимальной настройке гиперпараметров.\n", + "\n", + "Эти три модели дадут нам хорошее сочетание простоты (линейная регрессия), гибкости (случайный лес) и мощности (градиентный бустинг), что позволит тщательно исследовать зависимости и добиться хорошего качества предсказаний." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Разделение набора данных на обучающую и тестовые выборки (80/20) для задачи регрессии и создание ориентира\n", + "\n", + "Целевой признак -- total_score" + ] + }, + { + "cell_type": "code", + "execution_count": 180, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.model_selection import train_test_split\n", + "\n", + "# Разбиение на признаки и целевую переменную\n", + "X = df.drop(columns=[\"total_score\"]) # Признаки\n", + "y = df[\"total_score\"] # Целевая переменная\n", + "\n", + "# Разбиение на обучающую и тестовую выборки\n", + "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=random_state)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Формирование конвейера" + ] + }, + { + "cell_type": "code", + "execution_count": 181, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.compose import ColumnTransformer\n", + "from sklearn.discriminant_analysis import StandardScaler\n", + "from sklearn.impute import SimpleImputer\n", + "from sklearn.pipeline import Pipeline\n", + "from sklearn.preprocessing import OneHotEncoder\n", + "\n", + "# Пайплайн для обработки признаков\n", + "columns_to_drop = [\"total_score\"]\n", + "num_columns = [column for column in X.columns if X[column].dtype != \"object\"]\n", + "cat_columns = [column for column in X.columns if X[column].dtype == \"object\"]\n", + "\n", + "# Обработчики для числовых и категориальных признаков\n", + "num_imputer = SimpleImputer(strategy=\"median\")\n", + "num_scaler = StandardScaler()\n", + "preprocessing_num = Pipeline([(\"imputer\", num_imputer), (\"scaler\", num_scaler)])\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([(\"imputer\", cat_imputer), (\"encoder\", cat_encoder)])\n", + "\n", + "# Обрабатываем признаки\n", + "features_preprocessing = ColumnTransformer(\n", + " transformers=[\n", + " (\"prepocessing_num\", preprocessing_num, num_columns),\n", + " (\"prepocessing_cat\", preprocessing_cat, cat_columns),\n", + " ],\n", + " remainder=\"passthrough\"\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Настройка гиперпараметров для каждой модели и обучение" + ] + }, + { + "cell_type": "code", + "execution_count": 182, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
GridSearchCV(cv=5,\n",
+       "             estimator=Pipeline(steps=[('features_preprocessing',\n",
+       "                                        ColumnTransformer(remainder='passthrough',\n",
+       "                                                          transformers=[('prepocessing_num',\n",
+       "                                                                         Pipeline(steps=[('imputer',\n",
+       "                                                                                          SimpleImputer(strategy='median')),\n",
+       "                                                                                         ('scaler',\n",
+       "                                                                                          StandardScaler())]),\n",
+       "                                                                         []),\n",
+       "                                                                        ('prepocessing_cat',\n",
+       "                                                                         Pipeline(steps=[('imputer',\n",
+       "                                                                                          SimpleImputer(fill_value='unknown',\n",
+       "                                                                                                        strategy='constant')),\n",
+       "                                                                                         ('enc...\n",
+       "                                                                                          OneHotEncoder(drop='first',\n",
+       "                                                                                                        handle_unknown='ignore',\n",
+       "                                                                                                        sparse_output=False))]),\n",
+       "                                                                         ['gender',\n",
+       "                                                                          'race/ethnicity',\n",
+       "                                                                          'parental '\n",
+       "                                                                          'level '\n",
+       "                                                                          'of '\n",
+       "                                                                          'education',\n",
+       "                                                                          'lunch',\n",
+       "                                                                          'test '\n",
+       "                                                                          'preparation '\n",
+       "                                                                          'course'])])),\n",
+       "                                       ('model',\n",
+       "                                        GradientBoostingRegressor(random_state=9))]),\n",
+       "             n_jobs=-1,\n",
+       "             param_grid={'model__learning_rate': [0.01, 0.1, 0.2],\n",
+       "                         'model__max_depth': [3, 5, 7],\n",
+       "                         'model__n_estimators': [50, 100, 200]})
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + ], + "text/plain": [ + "GridSearchCV(cv=5,\n", + " estimator=Pipeline(steps=[('features_preprocessing',\n", + " ColumnTransformer(remainder='passthrough',\n", + " transformers=[('prepocessing_num',\n", + " Pipeline(steps=[('imputer',\n", + " SimpleImputer(strategy='median')),\n", + " ('scaler',\n", + " StandardScaler())]),\n", + " []),\n", + " ('prepocessing_cat',\n", + " Pipeline(steps=[('imputer',\n", + " SimpleImputer(fill_value='unknown',\n", + " strategy='constant')),\n", + " ('enc...\n", + " OneHotEncoder(drop='first',\n", + " handle_unknown='ignore',\n", + " sparse_output=False))]),\n", + " ['gender',\n", + " 'race/ethnicity',\n", + " 'parental '\n", + " 'level '\n", + " 'of '\n", + " 'education',\n", + " 'lunch',\n", + " 'test '\n", + " 'preparation '\n", + " 'course'])])),\n", + " ('model',\n", + " GradientBoostingRegressor(random_state=9))]),\n", + " n_jobs=-1,\n", + " param_grid={'model__learning_rate': [0.01, 0.1, 0.2],\n", + " 'model__max_depth': [3, 5, 7],\n", + " 'model__n_estimators': [50, 100, 200]})" + ] + }, + "execution_count": 182, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from sklearn.linear_model import LinearRegression\n", + "from sklearn.ensemble import RandomForestRegressor\n", + "from sklearn.ensemble import GradientBoostingRegressor\n", + "from sklearn.model_selection import GridSearchCV\n", + "from sklearn.pipeline import Pipeline\n", + "\n", + "# 1. Линейная регрессия\n", + "linear_model = LinearRegression()\n", + "\n", + "# Параметры для настройки\n", + "linear_param_grid = {\n", + " 'model__fit_intercept': [True, False], # Использовать ли свободный член\n", + "}\n", + "\n", + "# 2. Случайный лес\n", + "rf_model = RandomForestRegressor(random_state=random_state)\n", + "\n", + "# Параметры для настройки\n", + "rf_param_grid = {\n", + " 'model__n_estimators': [50, 100, 200],\n", + " 'model__max_depth': [None, 10, 20],\n", + " 'model__min_samples_split': [2, 5],\n", + " 'model__min_samples_leaf': [1, 2],\n", + " 'model__max_features': ['sqrt', 'log2'], # Заменить 'auto' на 'sqrt'\n", + "}\n", + "\n", + "# 3. Градиентный бустинг\n", + "gb_model = GradientBoostingRegressor(random_state=random_state)\n", + "\n", + "# Параметры для настройки\n", + "gb_param_grid = {\n", + " 'model__n_estimators': [50, 100, 200], # Количество деревьев\n", + " 'model__learning_rate': [0.01, 0.1, 0.2], # Темп обучения\n", + " 'model__max_depth': [3, 5, 7], # Максимальная глубина деревьев\n", + "}\n", + "\n", + "# Создание пайплайна для линейной регрессии\n", + "linear_pipeline = Pipeline([\n", + " (\"features_preprocessing\", features_preprocessing),\n", + " (\"model\", linear_model)\n", + "])\n", + "\n", + "# Создание пайплайна для случайного леса\n", + "rf_pipeline = Pipeline([\n", + " (\"features_preprocessing\", features_preprocessing),\n", + " (\"model\", rf_model)\n", + "])\n", + "\n", + "# Создание пайплайна для градиентного бустинга\n", + "gb_pipeline = Pipeline([\n", + " (\"features_preprocessing\", features_preprocessing),\n", + " (\"model\", gb_model)\n", + "])\n", + "\n", + "# Настройка гиперпараметров с использованием GridSearchCV\n", + "linear_search = GridSearchCV(linear_pipeline, linear_param_grid, cv=5, n_jobs=-1)\n", + "rf_search = GridSearchCV(rf_pipeline, rf_param_grid, cv=5, n_jobs=-1)\n", + "gb_search = GridSearchCV(gb_pipeline, gb_param_grid, cv=5, n_jobs=-1)\n", + "\n", + "# Обучение моделей\n", + "linear_search.fit(X_train, y_train.values.ravel()) # Преобразуем y_train в одномерный массив\n", + "rf_search.fit(X_train, y_train.values.ravel()) # Преобразуем y_train в одномерный массив\n", + "gb_search.fit(X_train, y_train.values.ravel()) # Преобразуем y_train в одномерный массив\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Оценка качества моделей\n", + "\n", + "Для оценки качества моделей будем использовать следующие метрики:\n", + "\n", + "R^2 — это классическая метрика для оценки качества модели в регрессии. Она покажет, насколько хорошо модель объясняет данные, и полезна, чтобы понять, имеет ли смысл использовать модель.\n", + "\n", + "MAE и MSE — они дают представление о точности модели и масштабах ошибок. MAE поможет понять средний уровень ошибки, а MSE и RMSE — сосредоточатся на более крупных ошибках, что может быть критично для задач, где крупные ошибки имеют большое значение.\n", + "\n", + "RMSE полезна в контексте конкретных приложений, когда важно понять ошибку в тех же единицах, что и целевая переменная, особенно если данные в регрессии имеют четкую физическую или экономическую интерпретацию." + ] + }, + { + "cell_type": "code", + "execution_count": 183, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Linear Regression - R^2: 0.25121834623887884, MAE: 30.509764831673372, MSE: 1399.0220694458058, RMSE: 37.403503438124694\n", + "Random Forest - R^2: 0.19039682481837739, MAE: 31.82764043548629, MSE: 1512.6608723426755, RMSE: 38.89294116343833\n", + "Gradient Boosting - R^2: 0.19994717344160973, MAE: 31.688226363085978, MSE: 1494.8170210307603, RMSE: 38.66286359067006\n" + ] + } + ], + "source": [ + "from sklearn.metrics import mean_absolute_error, mean_squared_error, r2_score\n", + "\n", + "# Прогнозы для каждой модели\n", + "y_pred_linear = linear_search.predict(X_test)\n", + "y_pred_rf = rf_search.predict(X_test)\n", + "y_pred_gb = gb_search.predict(X_test)\n", + "\n", + "# R^2\n", + "r2_linear = r2_score(y_test, y_pred_linear)\n", + "r2_rf = r2_score(y_test, y_pred_rf)\n", + "r2_gb = r2_score(y_test, y_pred_gb)\n", + "\n", + "# MAE\n", + "mae_linear = mean_absolute_error(y_test, y_pred_linear)\n", + "mae_rf = mean_absolute_error(y_test, y_pred_rf)\n", + "mae_gb = mean_absolute_error(y_test, y_pred_gb)\n", + "\n", + "# MSE\n", + "mse_linear = mean_squared_error(y_test, y_pred_linear)\n", + "mse_rf = mean_squared_error(y_test, y_pred_rf)\n", + "mse_gb = mean_squared_error(y_test, y_pred_gb)\n", + "\n", + "# RMSE\n", + "rmse_linear = mse_linear ** 0.5\n", + "rmse_rf = mse_rf ** 0.5\n", + "rmse_gb = mse_gb ** 0.5\n", + "\n", + "# Вывод результатов\n", + "print(f\"Linear Regression - R^2: {r2_linear}, MAE: {mae_linear}, MSE: {mse_linear}, RMSE: {rmse_linear}\")\n", + "print(f\"Random Forest - R^2: {r2_rf}, MAE: {mae_rf}, MSE: {mse_rf}, RMSE: {rmse_rf}\")\n", + "print(f\"Gradient Boosting - R^2: {r2_gb}, MAE: {mae_gb}, MSE: {mse_gb}, RMSE: {rmse_gb}\")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Линейная регрессия: По всем метрикам (R^2, MAE, MSE, RMSE) линейная регрессия показывает лучшие результаты. Она объясняет большую часть вариации в данных и имеет наименьшие ошибки как в абсолютных величинах, так и в квадратных отклонениях.\n", + "\n", + "Random Forest и Gradient Boosting: Эти модели показывают худшие результаты по сравнению с линейной регрессией, как по объяснению вариации данных, так и по величине ошибок." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Оценка смещения и дисперсии лучшей модели (линейная регрессия)." + ] + }, + { + "cell_type": "code", + "execution_count": 184, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Смещение (Bias): 0.13896485197494712\n", + "Дисперсия (Variance): 432.34643616182956\n", + "RMSE: 37.95928016105437\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "from sklearn.model_selection import cross_val_predict, KFold\n", + "from sklearn.metrics import mean_squared_error\n", + "\n", + "# Количество фолдов для кросс-валидации\n", + "n_splits = 5\n", + "kf = KFold(n_splits=n_splits, shuffle=True, random_state=42)\n", + "\n", + "# Прогнозы с использованием кросс-валидации с конвейером\n", + "y_pred = cross_val_predict(linear_pipeline, X_train, y_train.values.ravel(), cv=kf)\n", + "\n", + "# Среднее значение целевой переменной\n", + "y_true_mean = np.mean(y_train)\n", + "\n", + "# Смещение: разница между средним предсказанием модели и средним значением целевой переменной\n", + "bias = np.mean(y_pred) - y_true_mean\n", + "\n", + "# Дисперсия: среднее отклонение предсказаний от среднего предсказания\n", + "variance = np.mean((y_pred - np.mean(y_pred)) ** 2)\n", + "\n", + "# Средняя ошибка (для контекста)\n", + "mse = mean_squared_error(y_train, y_pred)\n", + "rmse = np.sqrt(mse)\n", + "\n", + "# Выводим результаты\n", + "print(f\"Смещение (Bias): {bias}\")\n", + "print(f\"Дисперсия (Variance): {variance}\")\n", + "print(f\"RMSE: {rmse}\")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Смещение и дисперсия вместе составляют основную часть ошибки модели. Смещение (bias) относительно невелико, но модель имеет достаточно высокую дисперсию. Это означает, что модель может страдать от переобучения (overfitting), то есть она слишком хорошо подгоняется под обучающие данные и не обобщает информацию на новые данные. В таких случаях модель может показывать хорошие результаты на обучающих данных, но её способность предсказывать для новых, невиданных данных может быть ограничена.\n", + "\n", + "RMSE также указывает на наличие значительных ошибок в предсказаниях, и, вероятно, модель нуждается в улучшении. " + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "aimvenv", + "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.6" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/utils.py b/utils.py new file mode 100644 index 0000000..cb8c396 --- /dev/null +++ b/utils.py @@ -0,0 +1,79 @@ +from typing import Tuple + +import pandas as pd +from pandas import DataFrame +from sklearn.model_selection import train_test_split + + +def split_stratified_into_train_val_test( + df_input, + stratify_colname="y", + frac_train=0.6, + frac_val=0.15, + frac_test=0.25, + random_state=None, +) -> Tuple[DataFrame, DataFrame, DataFrame, DataFrame, DataFrame, DataFrame]: + """ + Splits a Pandas dataframe into three subsets (train, val, and test) + following fractional ratios provided by the user, where each subset is + stratified by the values in a specific column (that is, each subset has + the same relative frequency of the values in the column). It performs this + splitting by running train_test_split() twice. + + Parameters + ---------- + df_input : Pandas dataframe + Input dataframe to be split. + stratify_colname : str + The name of the column that will be used for stratification. Usually + this column would be for the label. + frac_train : float + frac_val : float + frac_test : float + The ratios with which the dataframe will be split into train, val, and + test data. The values should be expressed as float fractions and should + sum to 1.0. + random_state : int, None, or RandomStateInstance + Value to be passed to train_test_split(). + + Returns + ------- + df_train, df_val, df_test : + Dataframes containing the three splits. + """ + + if frac_train + frac_val + frac_test != 1.0: + raise ValueError( + "fractions %f, %f, %f do not add up to 1.0" + % (frac_train, frac_val, frac_test) + ) + + if stratify_colname not in df_input.columns: + raise ValueError("%s is not a column in the dataframe" % (stratify_colname)) + + X = df_input # Contains all columns. + y = df_input[ + [stratify_colname] + ] # Dataframe of just the column on which to stratify. + + # Split original dataframe into train and temp dataframes. + df_train, df_temp, y_train, y_temp = train_test_split( + X, y, stratify=y, test_size=(1.0 - frac_train), random_state=random_state + ) + + if frac_val <= 0: + assert len(df_input) == len(df_train) + len(df_temp) + return df_train, pd.DataFrame(), df_temp, y_train, pd.DataFrame(), y_temp + + # Split the temp dataframe into val and test dataframes. + relative_frac_test = frac_test / (frac_val + frac_test) + df_val, df_test, y_val, y_test = train_test_split( + df_temp, + y_temp, + stratify=y_temp, + test_size=relative_frac_test, + random_state=random_state, + ) + + assert len(df_input) == len(df_train) + len(df_val) + len(df_test) + return df_train, df_val, df_test, y_train, y_val, y_test -- 2.25.1