{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "### Начало лабораторной работы" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Index(['Unnamed: 0', 'Name', 'Brand', 'Model', 'Battery capacity (mAh)',\n", " 'Screen size (inches)', 'Touchscreen', 'Resolution x', 'Resolution y',\n", " 'Processor', 'RAM (MB)', 'Internal storage (GB)', 'Rear camera',\n", " 'Front camera', 'Operating system', 'Wi-Fi', 'Bluetooth', 'GPS',\n", " 'Number of SIMs', '3G', '4G/ LTE', 'Price'],\n", " dtype='object')\n" ] }, { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
Unnamed: 0NameBrandModelBattery capacity (mAh)Screen size (inches)TouchscreenResolution xResolution yProcessor...Rear cameraFront cameraOperating systemWi-FiBluetoothGPSNumber of SIMs3G4G/ LTEPrice
00OnePlus 7T Pro McLaren EditionOnePlus7T Pro McLaren Edition40856.67Yes144031208...48.016.0AndroidYesYesYes2YesYes58998
11Realme X2 ProRealmeX2 Pro40006.50Yes108024008...64.016.0AndroidYesYesYes2YesYes27999
22iPhone 11 Pro MaxAppleiPhone 11 Pro Max39696.50Yes124226886...12.012.0iOSYesYesYes2YesYes106900
33iPhone 11AppleiPhone 1131106.10Yes82817926...12.012.0iOSYesYesYes2YesYes62900
44LG G8X ThinQLGG8X ThinQ40006.40Yes108023408...12.032.0AndroidYesYesYes1NoNo49990
55OnePlus 7TOnePlus7T38006.55Yes108024008...48.016.0AndroidYesYesNo2YesYes34930
66OnePlus 7T ProOnePlus7T Pro40856.67Yes144031208...48.016.0AndroidYesYesYes2YesYes52990
77Samsung Galaxy Note 10+SamsungGalaxy Note 10+43006.80Yes144030408...12.010.0AndroidYesYesYes2YesYes79699
88Asus ROG Phone 2AsusROG Phone 260006.59Yes108023408...48.024.0AndroidYesYesYes1YesYes37999
99Xiaomi Redmi K20 ProXiaomiRedmi K20 Pro40006.39Yes108023408...48.020.0AndroidYesYesYes2NoNo23190
\n", "

10 rows × 22 columns

\n", "
" ], "text/plain": [ " Unnamed: 0 Name Brand \\\n", "0 0 OnePlus 7T Pro McLaren Edition OnePlus \n", "1 1 Realme X2 Pro Realme \n", "2 2 iPhone 11 Pro Max Apple \n", "3 3 iPhone 11 Apple \n", "4 4 LG G8X ThinQ LG \n", "5 5 OnePlus 7T OnePlus \n", "6 6 OnePlus 7T Pro OnePlus \n", "7 7 Samsung Galaxy Note 10+ Samsung \n", "8 8 Asus ROG Phone 2 Asus \n", "9 9 Xiaomi Redmi K20 Pro Xiaomi \n", "\n", " Model Battery capacity (mAh) Screen size (inches) \\\n", "0 7T Pro McLaren Edition 4085 6.67 \n", "1 X2 Pro 4000 6.50 \n", "2 iPhone 11 Pro Max 3969 6.50 \n", "3 iPhone 11 3110 6.10 \n", "4 G8X ThinQ 4000 6.40 \n", "5 7T 3800 6.55 \n", "6 7T Pro 4085 6.67 \n", "7 Galaxy Note 10+ 4300 6.80 \n", "8 ROG Phone 2 6000 6.59 \n", "9 Redmi K20 Pro 4000 6.39 \n", "\n", " Touchscreen Resolution x Resolution y Processor ... Rear camera \\\n", "0 Yes 1440 3120 8 ... 48.0 \n", "1 Yes 1080 2400 8 ... 64.0 \n", "2 Yes 1242 2688 6 ... 12.0 \n", "3 Yes 828 1792 6 ... 12.0 \n", "4 Yes 1080 2340 8 ... 12.0 \n", "5 Yes 1080 2400 8 ... 48.0 \n", "6 Yes 1440 3120 8 ... 48.0 \n", "7 Yes 1440 3040 8 ... 12.0 \n", "8 Yes 1080 2340 8 ... 48.0 \n", "9 Yes 1080 2340 8 ... 48.0 \n", "\n", " Front camera Operating system Wi-Fi Bluetooth GPS Number of SIMs 3G \\\n", "0 16.0 Android Yes Yes Yes 2 Yes \n", "1 16.0 Android Yes Yes Yes 2 Yes \n", "2 12.0 iOS Yes Yes Yes 2 Yes \n", "3 12.0 iOS Yes Yes Yes 2 Yes \n", "4 32.0 Android Yes Yes Yes 1 No \n", "5 16.0 Android Yes Yes No 2 Yes \n", "6 16.0 Android Yes Yes Yes 2 Yes \n", "7 10.0 Android Yes Yes Yes 2 Yes \n", "8 24.0 Android Yes Yes Yes 1 Yes \n", "9 20.0 Android Yes Yes Yes 2 No \n", "\n", " 4G/ LTE Price \n", "0 Yes 58998 \n", "1 Yes 27999 \n", "2 Yes 106900 \n", "3 Yes 62900 \n", "4 No 49990 \n", "5 Yes 34930 \n", "6 Yes 52990 \n", "7 Yes 79699 \n", "8 Yes 37999 \n", "9 No 23190 \n", "\n", "[10 rows x 22 columns]" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "import pandas as pd\n", "df = pd.read_csv(\"..//static//csv//ndtv_data_final.csv\")\n", "print(df.columns)\n", "display(df.head(10))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Регрессия\n", "\n", "Цель: Разработать модель регрессии, которая будет предсказывать цену мобильного телефона на основе его технических характеристик и функциональных особенностей.\n", "\n", "Применение:\n", "\n", "Производители и продавцы мобильных телефонов: Модель может помочь в установлении справедливой цены для новых моделей, основываясь на их технических характеристиках, что может быть полезно для ценообразования и конкуренции на рынке.\n", "\n", "Потребители: Модель может помочь пользователям принимать более обоснованные решения при покупке, сравнивая цены и характеристики различных моделей.\n", "\n", "Рыночные аналитики: Модель может быть использована для анализа тенденций на рынке мобильных телефонов, выявления факторов, влияющих на цену, и прогнозирования будущих изменений.\n", "\n", "Исследования в области технологий: Модель может помочь в изучении влияния различных технических характеристик на цену и популярность моделей." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Удаление выбросов" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Размер данных до удаления выбросов: (1359, 21)\n", "Размер данных после удаления выбросов: (1256, 21)\n" ] } ], "source": [ "import pandas as pd\n", "from scipy import stats\n", "\n", "# Загружаем набор данных\n", "df = pd.read_csv(\"..//static//csv//ndtv_data_final.csv\")\n", "\n", "# Удаление пустого столбца по имени\n", "df = df.drop('Unnamed: 0', axis=1)\n", "\n", "# Выбор числовых признаков для анализа выбросов\n", "numeric_features = [\n", " 'Battery capacity (mAh)', 'Screen size (inches)', 'Resolution x', \n", " 'Resolution y', 'Processor', 'RAM (MB)', 'Internal storage (GB)', \n", " 'Rear camera', 'Front camera', 'Number of SIMs', 'Price'\n", "]\n", "\n", "# Вычисление Z-оценок для числовых признаков\n", "z_scores = stats.zscore(df[numeric_features])\n", "\n", "# Определение порога для выбросов\n", "threshold = 3\n", "\n", "# Вывод размеров данных до удаления выбросов\n", "print(\"Размер данных до удаления выбросов:\", df.shape)\n", "\n", "# Удаление строк, содержащих выбросы\n", "df = df[(z_scores < threshold).all(axis=1)]\n", "\n", "# Вывод размеров данных после удаления выбросов\n", "print(\"Размер данных после удаления выбросов:\", df.shape)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Подготовка данных и оценка базовой модели" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Размер обучающей выборки: (1004, 18)\n", "Размер тестовой выборки: (252, 18)\n", "Baseline MAE: 4662.689511794094\n", "Baseline MSE: 50560680.710365206\n", "Baseline R²: -0.001378207894705552\n" ] } ], "source": [ "import pandas as pd\n", "from sklearn.model_selection import train_test_split\n", "from sklearn.metrics import mean_absolute_error, mean_squared_error, r2_score\n", "\n", "\n", "# Выбор признаков и целевой переменной\n", "features = [\n", " 'Brand', 'Battery capacity (mAh)',\n", " 'Screen size (inches)', 'Touchscreen', 'Resolution x', 'Resolution y',\n", " 'Processor', 'RAM (MB)', 'Internal storage (GB)', 'Rear camera',\n", " 'Front camera', 'Operating system', 'Wi-Fi', 'Bluetooth', 'GPS',\n", " 'Number of SIMs', '3G', '4G/ LTE'\n", "]\n", "target = 'Price'\n", "\n", "global X_train, X_test, y_train, y_test\n", "X_train, X_test, y_train, y_test = train_test_split(df[features], df[target], test_size=0.2, random_state=42)\n", "\n", "print(\"Размер обучающей выборки:\", X_train.shape)\n", "print(\"Размер тестовой выборки:\", X_test.shape)\n", "\n", "# Базовые предсказания (среднее значение целевой переменной)\n", "baseline_predictions = [y_train.mean()] * len(y_test)\n", "\n", "# Оценка базовой модели\n", "print('Baseline MAE:', mean_absolute_error(y_test, baseline_predictions))\n", "print('Baseline MSE:', mean_squared_error(y_test, baseline_predictions))\n", "print('Baseline R²:', r2_score(y_test, baseline_predictions))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Обучение и оценка моделей" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Model: Linear Regression trained.\n", "MAE: 3251.7122571814075\n", "MSE: 25623200.493888523\n", "R²: 0.4925203887566195\n", "--------------------------------------------------\n", "Model: Decision Tree trained.\n", "MAE: 4112.809523809524\n", "MSE: 56543100.29960317\n", "R²: -0.11986285887206449\n", "--------------------------------------------------\n", "Model: Gradient Boosting trained.\n", "MAE: 2793.2991365668017\n", "MSE: 23739724.17710429\n", "R²: 0.5298235285129411\n", "--------------------------------------------------\n" ] } ], "source": [ "import pandas as pd\n", "from scipy import stats\n", "from sklearn.model_selection import train_test_split, RandomizedSearchCV\n", "from sklearn.preprocessing import StandardScaler, OneHotEncoder\n", "from sklearn.compose import ColumnTransformer\n", "from sklearn.pipeline import Pipeline\n", "from sklearn.linear_model import LinearRegression\n", "from sklearn.tree import DecisionTreeRegressor\n", "from sklearn.ensemble import GradientBoostingRegressor\n", "from sklearn.metrics import mean_absolute_error, mean_squared_error, r2_score\n", "\n", "# Выбор признаков и целевой переменной\n", "categorical_features = [\n", " 'Brand', 'Touchscreen', 'Operating system', 'Wi-Fi', \n", " 'Bluetooth', 'GPS', '3G', '4G/ LTE'\n", "]\n", "numeric_features = [\n", " 'Battery capacity (mAh)', 'Screen size (inches)', 'Resolution x', \n", " 'Resolution y', 'Processor', 'RAM (MB)', 'Internal storage (GB)', 'Rear camera', \n", " 'Front camera', 'Number of SIMs'\n", "]\n", "target = 'Price'\n", "\n", "# Препроцессор для обработки числовых и категориальных признаков\n", "preprocessor = ColumnTransformer(\n", " transformers=[\n", " ('num', StandardScaler(), numeric_features), # Масштабирование числовых признаков\n", " ('cat', OneHotEncoder(handle_unknown='ignore'), categorical_features) # Однократная кодировка категориальных признаков\n", " ]\n", ")\n", "\n", "# Создание пайплайнов для моделей\n", "pipeline_linear_regression = Pipeline(steps=[\n", " ('preprocessor', preprocessor),\n", " ('regressor', LinearRegression())\n", "])\n", "\n", "pipeline_decision_tree = Pipeline(steps=[\n", " ('preprocessor', preprocessor),\n", " ('regressor', DecisionTreeRegressor(random_state=42))\n", "])\n", "\n", "pipeline_gradient_boosting = Pipeline(steps=[\n", " ('preprocessor', preprocessor),\n", " ('regressor', GradientBoostingRegressor(random_state=42))\n", "])\n", "\n", "# Список моделей для сравнения\n", "pipelines = [\n", " ('Linear Regression', pipeline_linear_regression),\n", " ('Decision Tree', pipeline_decision_tree),\n", " ('Gradient Boosting', pipeline_gradient_boosting)\n", "]\n", "\n", "# Обучение моделей и вывод результатов\n", "for name, pipeline in pipelines:\n", " pipeline.fit(X_train, y_train)\n", " predictions = pipeline.predict(X_test)\n", " print(f\"Model: {name} trained.\")\n", " print(f\"MAE: {mean_absolute_error(y_test, predictions)}\")\n", " print(f\"MSE: {mean_squared_error(y_test, predictions)}\")\n", " print(f\"R²: {r2_score(y_test, predictions)}\")\n", " print(\"-\" * 50)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Линейная регрессия улучшила качество предсказаний по сравнению с базовой моделью, но показала меньшую эффективность, чем градиентный бустинг\n", "\n", "* MAE уменьшился на 1410.98 (30% улучшение).\n", "\n", "* MSE уменьшился на 24937480.22 (49% улучшение).\n", "\n", "* R² стал положительным (0.4925), что означает, что модель объясняет 49.25% изменчивости цены.\n", "\n", "Дерево решений оказалось наименее эффективным среди всех моделей, показав худшие результаты даже по сравнению с базовой моделью.\n", "\n", "* MAE увеличился на 450.12 (9.6% ухудшение).\n", "\n", "* MSE увеличился на 5982419.59 (11.8% ухудшение).\n", "\n", "* R² стал еще ниже (-0.1199), что указывает на то, что модель работает хуже, чем базовая.\n", "\n", "Градиентный бустинг показал лучшие результаты среди всех моделей:\n", "\n", "* MAE уменьшился на 1869.39 (40% улучшение) по сравнению с базовой моделью.\n", "\n", "* MSE уменьшился на 26820956.53 (53% улучшение) по сравнению с базовой моделью.\n", "\n", "* R² достиг 0.5298, что означает, что модель объясняет 52.98% изменчивости цены.\n", "\n", "Таким образом, градиентный бустинг является наиболее подходящей моделью для предсказания цены мобильных телефонов на основе выбранных признаков." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Классификация \n", "\n", "Цель: Целью классификации является разработка модели, которая будет предсказывать категорию цены мобильного телефона на основе его технических характеристик и функциональных особенностей.\n", "\n", "Применение классификации:\n", "\n", "1. Рыночная аналитика:\n", "\n", "* Помогает производителям и продавцам телефонов определять целевую аудиторию для конкретных моделей.\n", "\n", "* Позволяет анализировать конкуренцию в разных ценовых сегментах.\n", "\n", "2. Потребительские рекомендации:\n", "\n", "* Помогает пользователям выбирать телефоны, соответствующие их бюджету и требованиям.\n", "\n", "* Упрощает процесс сравнения телефонов в рамках одной ценовой категории." ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Размер обучающей выборки: (1004, 18)\n", "Размер тестовой выборки: (252, 18)\n" ] } ], "source": [ "import pandas as pd\n", "from sklearn.model_selection import train_test_split\n", "\n", "# Выбор признаков и целевой переменной\n", "features = [\n", " 'Brand', 'Battery capacity (mAh)',\n", " 'Screen size (inches)', 'Touchscreen', 'Resolution x', 'Resolution y',\n", " 'Processor', 'RAM (MB)', 'Internal storage (GB)', 'Rear camera',\n", " 'Front camera', 'Operating system', 'Wi-Fi', 'Bluetooth', 'GPS',\n", " 'Number of SIMs', '3G', '4G/ LTE'\n", "]\n", "target = 'Price'\n", "\n", "# Разделение данных на обучающую и тестовую выборки\n", "X_train, X_test, y_train, y_test = train_test_split(df[features], df[target], test_size=0.2, random_state=42)\n", "\n", "print(\"Размер обучающей выборки:\", X_train.shape)\n", "print(\"Размер тестовой выборки:\", X_test.shape)" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "PriceCategory\n", "1 946\n", "0 946\n", "Name: count, dtype: int64\n", "Гиперпараметры для логистической регрессии:\n", "Accuracy: 0.8760\n", "Precision: 0.8784\n", "Recall: 0.8760\n", "F1-Score: 0.8762\n", "ROC-AUC: 0.9521\n", "Гиперпараметры для случайного леса:\n", "Accuracy: 0.9393\n", "Precision: 0.9395\n", "Recall: 0.9393\n", "F1-Score: 0.9392\n", "ROC-AUC: 0.9833\n", "Гиперпараметры для градиентного бустинга:\n", "Accuracy: 0.9261\n", "Precision: 0.9261\n", "Recall: 0.9261\n", "F1-Score: 0.9261\n", "ROC-AUC: 0.9777\n", "\n", "Результаты моделей:\n", "\n", "Logistic Regression:\n", "Accuracy: 0.8760\n", "Precision: 0.8784\n", "Recall: 0.8760\n", "F1: 0.8762\n", "Roc_auc: 0.9521\n", "\n", "Random Forest:\n", "Accuracy: 0.9393\n", "Precision: 0.9395\n", "Recall: 0.9393\n", "F1: 0.9392\n", "Roc_auc: 0.9833\n", "\n", "Gradient Boosting:\n", "Accuracy: 0.9261\n", "Precision: 0.9261\n", "Recall: 0.9261\n", "F1: 0.9261\n", "Roc_auc: 0.9777\n" ] } ], "source": [ "import pandas as pd\n", "from imblearn.over_sampling import SMOTE\n", "from sklearn.model_selection import train_test_split\n", "from sklearn.preprocessing import OneHotEncoder, LabelEncoder\n", "from sklearn.compose import ColumnTransformer\n", "from sklearn.pipeline import Pipeline\n", "from sklearn.preprocessing import StandardScaler\n", "from sklearn.linear_model import LogisticRegression\n", "from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier\n", "from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, roc_auc_score\n", "from scipy.stats import uniform, randint\n", "from sklearn.model_selection import RandomizedSearchCV\n", "\n", "# Выбор признаков и целевой переменной\n", "features = [\n", " 'Brand', 'Battery capacity (mAh)', 'Screen size (inches)', 'Touchscreen', \n", " 'Resolution x', 'Resolution y', 'Processor', 'RAM (MB)', 'Internal storage (GB)', \n", " 'Rear camera', 'Front camera', 'Operating system', 'Wi-Fi', 'Bluetooth', 'GPS', \n", " 'Number of SIMs', '3G', '4G/ LTE'\n", "]\n", "target = 'PriceCategory' # Целевая переменная: категория цены\n", "\n", "# Преобразование целевой переменной в категории (например, бюджетные, средний класс, премиум)\n", "bins = [0, 10000, 60000, float('inf')]\n", "labels = ['Budget', 'Mid-Range', 'Premium']\n", "df['PriceCategory'] = pd.cut(df['Price'], bins=bins, labels=labels)\n", "\n", "# Преобразование категорий в числа\n", "label_encoder = LabelEncoder()\n", "df[target] = label_encoder.fit_transform(df[target])\n", "\n", "# Определение категориальных и числовых признаков\n", "categorical_features = [\n", " 'Brand', 'Touchscreen', 'Operating system', 'Wi-Fi', \n", " 'Bluetooth', 'GPS', '3G', '4G/ LTE'\n", "]\n", "numeric_features = [\n", " 'Battery capacity (mAh)', 'Processor', 'Screen size (inches)', 'Resolution x', \n", " 'Resolution y', 'RAM (MB)', 'Internal storage (GB)', 'Rear camera', \n", " 'Front camera', 'Number of SIMs'\n", "]\n", "\n", "# Препроцессор для обработки числовых и категориальных признаков\n", "categorical_transformer = Pipeline(steps=[\n", " ('onehot', OneHotEncoder(handle_unknown='ignore'))\n", "])\n", "\n", "numeric_transformer = Pipeline(steps=[\n", " ('scaler', StandardScaler())\n", "])\n", "\n", "preprocessor = ColumnTransformer(\n", " transformers=[\n", " ('num', numeric_transformer, numeric_features),\n", " ('cat', categorical_transformer, categorical_features)\n", " ])\n", "\n", "# Применение препроцессора\n", "X = preprocessor.fit_transform(df[features])\n", "y = df[target]\n", "\n", "# Балансировка классов с помощью SMOTE\n", "smote = SMOTE(random_state=42)\n", "X_resampled, y_resampled = smote.fit_resample(X, y)\n", "\n", "print(pd.Series(y_resampled).value_counts())\n", "\n", "# Разделение данных на обучающую и тестовую выборки\n", "X_train, X_test, y_train, y_test = train_test_split(X_resampled, y_resampled, test_size=0.2, random_state=42)\n", "\n", "# Функция для оценки модели\n", "def evaluate_model(model, X_test, y_test):\n", " y_pred = model.predict(X_test)\n", " y_pred_proba = model.predict_proba(X_test)[:, 1]\n", " \n", " accuracy = accuracy_score(y_test, y_pred)\n", " precision = precision_score(y_test, y_pred, average='weighted') \n", " recall = recall_score(y_test, y_pred, average='weighted') \n", " f1 = f1_score(y_test, y_pred, average='weighted') \n", " roc_auc = roc_auc_score(y_test, y_pred_proba, multi_class='ovr')\n", " \n", " print(f\"Accuracy: {accuracy:.4f}\")\n", " print(f\"Precision: {precision:.4f}\")\n", " print(f\"Recall: {recall:.4f}\")\n", " print(f\"F1-Score: {f1:.4f}\")\n", " print(f\"ROC-AUC: {roc_auc:.4f}\")\n", " \n", " return {\n", " 'accuracy': accuracy,\n", " 'precision': precision,\n", " 'recall': recall,\n", " 'f1': f1,\n", " 'roc_auc': roc_auc\n", " }\n", "\n", "# Логистическая регрессия\n", "print(\"Гиперпараметры для логистической регрессии:\")\n", "logreg_param_dist = {\n", " 'classifier__C': uniform(loc=0, scale=4),\n", " 'classifier__penalty': ['l1', 'l2'],\n", " 'classifier__solver': ['liblinear', 'saga']\n", "}\n", "\n", "logreg_pipeline = Pipeline([\n", " ('classifier', LogisticRegression(max_iter=1000, random_state=42))\n", "])\n", "\n", "logreg_random_search = RandomizedSearchCV(logreg_pipeline, param_distributions=logreg_param_dist, n_iter=50, cv=5, random_state=42, n_jobs=-1)\n", "logreg_random_search.fit(X_train, y_train)\n", "logreg_best_model = logreg_random_search.best_estimator_\n", "logreg_results = evaluate_model(logreg_best_model, X_test, y_test)\n", "\n", "# Случайный лес\n", "print(\"Гиперпараметры для случайного леса:\")\n", "rf_param_dist = {\n", " 'classifier__n_estimators': randint(100, 1000),\n", " 'classifier__max_depth': [None] + list(randint(10, 100).rvs(10)),\n", " 'classifier__min_samples_split': randint(2, 20),\n", " 'classifier__min_samples_leaf': randint(1, 20),\n", " 'classifier__bootstrap': [True, False]\n", "}\n", "\n", "rf_pipeline = Pipeline([\n", " ('classifier', RandomForestClassifier(random_state=42))\n", "])\n", "\n", "rf_random_search = RandomizedSearchCV(rf_pipeline, param_distributions=rf_param_dist, n_iter=50, cv=5, random_state=42, n_jobs=-1)\n", "rf_random_search.fit(X_train, y_train)\n", "rf_best_model = rf_random_search.best_estimator_\n", "rf_results = evaluate_model(rf_best_model, X_test, y_test)\n", "\n", "# Градиентный бустинг\n", "print(\"Гиперпараметры для градиентного бустинга:\")\n", "gb_param_dist = {\n", " 'classifier__n_estimators': randint(100, 1000),\n", " 'classifier__learning_rate': uniform(0.01, 0.5),\n", " 'classifier__max_depth': [None] + list(randint(10, 100).rvs(10)),\n", " 'classifier__min_samples_split': randint(2, 20),\n", " 'classifier__min_samples_leaf': randint(1, 20),\n", " 'classifier__subsample': uniform(0.5, 0.5)\n", "}\n", "\n", "gb_pipeline = Pipeline([\n", " ('classifier', GradientBoostingClassifier(random_state=42))\n", "])\n", "\n", "gb_random_search = RandomizedSearchCV(gb_pipeline, param_distributions=gb_param_dist, n_iter=50, cv=5, random_state=42, n_jobs=-1)\n", "gb_random_search.fit(X_train, y_train)\n", "gb_best_model = gb_random_search.best_estimator_\n", "gb_results = evaluate_model(gb_best_model, X_test, y_test)\n", "\n", "# Вывод результатов\n", "print(\"\\nРезультаты моделей:\")\n", "print(\"\\nLogistic Regression:\")\n", "for metric, value in logreg_results.items():\n", " print(f\"{metric.capitalize()}: {value:.4f}\")\n", "\n", "print(\"\\nRandom Forest:\")\n", "for metric, value in rf_results.items():\n", " print(f\"{metric.capitalize()}: {value:.4f}\")\n", "\n", "print(\"\\nGradient Boosting:\")\n", "for metric, value in gb_results.items():\n", " print(f\"{metric.capitalize()}: {value:.4f}\")" ] }, { "cell_type": "code", "execution_count": 46, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Logistic Regression Metrics:\n", "Accuracy: 0.8760\n", "Precision: 0.8784\n", "Recall: 0.8760\n", "F1-Score: 0.8762\n", "ROC-AUC: 0.9521\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "Random Forest Metrics:\n", "Accuracy: 0.9393\n", "Precision: 0.9395\n", "Recall: 0.9393\n", "F1-Score: 0.9392\n", "ROC-AUC: 0.9833\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "Gradient Boosting Metrics:\n", "Accuracy: 0.9261\n", "Precision: 0.9261\n", "Recall: 0.9261\n", "F1-Score: 0.9261\n", "ROC-AUC: 0.9777\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "import seaborn as sns\n", "import matplotlib.pyplot as plt\n", "from sklearn.metrics import confusion_matrix, roc_curve, auc, roc_auc_score, accuracy_score, precision_score, recall_score, f1_score\n", "from sklearn.preprocessing import label_binarize\n", "import numpy as np\n", "\n", "# Функция для построения матрицы ошибок\n", "def plot_confusion_matrix(y_true, y_pred, title):\n", " cm = confusion_matrix(y_true, y_pred)\n", " sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', cbar=False)\n", " plt.title(title)\n", " plt.xlabel('Предсказанные значения')\n", " plt.ylabel('Истинные значения')\n", " plt.show()\n", "\n", "# Функция для оценки и визуализации модели\n", "def evaluate_and_plot_model(model, X_test, y_test, model_name, class_names):\n", " y_pred = model.predict(X_test)\n", " y_pred_proba = model.predict_proba(X_test)[:, 1]\n", " # Метрики\n", " accuracy = accuracy_score(y_test, y_pred)\n", " precision = precision_score(y_test, y_pred, average='weighted')\n", " recall = recall_score(y_test, y_pred, average='weighted')\n", " f1 = f1_score(y_test, y_pred, average='weighted')\n", " roc_auc = roc_auc_score(y_test, y_pred_proba, multi_class='ovr', average='weighted')\n", " \n", " print(f\"{model_name} Metrics:\")\n", " print(f\"Accuracy: {accuracy:.4f}\")\n", " print(f\"Precision: {precision:.4f}\")\n", " print(f\"Recall: {recall:.4f}\")\n", " print(f\"F1-Score: {f1:.4f}\")\n", " print(f\"ROC-AUC: {roc_auc:.4f}\")\n", " \n", " # Визуализация\n", " plot_confusion_matrix(y_test, y_pred, f'Confusion Matrix for {model_name}')\n", "\n", "# Пример использования\n", "class_names = ['Budget', 'Mid-Range', 'Premium']\n", "evaluate_and_plot_model(logreg_best_model, X_test, y_test, 'Logistic Regression', class_names)\n", "evaluate_and_plot_model(rf_best_model, X_test, y_test, 'Random Forest', class_names)\n", "evaluate_and_plot_model(gb_best_model, X_test, y_test, 'Gradient Boosting', class_names)" ] } ], "metadata": { "kernelspec": { "display_name": "aimenv", "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 }