AIM-PIbd-31-Shanygin-A-V/lab_4/Lab4.ipynb
2024-12-07 01:42:26 +04:00

1187 lines
165 KiB
Plaintext
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Stores"
]
},
{
"cell_type": "code",
"execution_count": 20,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Index(['Store ID ', 'Store_Area', 'Items_Available', 'Daily_Customer_Count',\n",
" 'Store_Sales'],\n",
" dtype='object')\n"
]
}
],
"source": [
"import pandas as pd\n",
"df = pd.read_csv(\".//static//csv//Stores.csv\")\n",
"print(df.columns)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Бизнес-цели**\n",
"1. Прогнозирование посетителей в магазине:\n",
"\n",
"Цель: Разработать модель, которая будет предсказывать посещение клиентами магазина на основе его характеристик (размер, распродажи, количество ассортимента).\n",
"\n",
"Применение: Предсказывание посещения магазинов клиентами.\n",
"\n",
"2. Оптимизация параметров магазина:\n",
"\n",
"Цель: Определить оптимальные коэффициенты для различных факторов, влияющих на посещаемость магазина чтобы максимизировать прибыль компании при наименьших затратах на пространство магазина и его ассортимент.\n",
"\n",
"Применение: Создавать магазин с максимальной посещаемостью."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Прогнозирование посетителей в магазине**"
]
},
{
"cell_type": "code",
"execution_count": 21,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Среднее значение поля 'Daily_Customer_Count': 786.3504464285714\n",
" Store ID Store_Area Items_Available Daily_Customer_Count Store_Sales \\\n",
"0 1 1659 1961 530 66490 \n",
"1 2 1461 1752 210 39820 \n",
"2 3 1340 1609 720 54010 \n",
"3 4 1451 1748 620 53730 \n",
"4 5 1770 2111 450 46620 \n",
"\n",
" above_average_count customers_volatility \n",
"0 0 1550 \n",
"1 0 1550 \n",
"2 0 1550 \n",
"3 0 1550 \n",
"4 0 1550 \n"
]
}
],
"source": [
"import pandas as pd\n",
"\n",
"# Устанавливаем случайное состояние\n",
"random_state = 42\n",
"\n",
"# Рассчитываем среднее значение посещаемости\n",
"average_count = df['Daily_Customer_Count'].mean()\n",
"print(f\"Среднее значение поля 'Daily_Customer_Count': {average_count}\")\n",
"\n",
"# Создаем новую переменную, указывающую, превышает ли посещаемость среднюю\n",
"df[\"above_average_count\"] = (df[\"Daily_Customer_Count\"] > average_count).astype(int)\n",
"\n",
"# Рассчитываем волатильность (разницу между максимальной и минимальной посещаемостью)\n",
"df[\"customers_volatility\"] = df[\"Daily_Customer_Count\"].max() - df[\"Daily_Customer_Count\"].min()\n",
"\n",
"print(df.head())"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Оптимизация параметров магазина**"
]
},
{
"cell_type": "code",
"execution_count": 22,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Средняя посещаемость для 'Store_Area':\n",
"Store_Area\n",
"775 1090.0\n",
"780 790.0\n",
"854 660.0\n",
"869 850.0\n",
"891 630.0\n",
" ... \n",
"2063 810.0\n",
"2067 790.0\n",
"2169 600.0\n",
"2214 740.0\n",
"2229 660.0\n",
"Name: Daily_Customer_Count, Length: 583, dtype: float64\n",
"\n",
"Средняя посещаемость для 'Items_Available':\n",
"Items_Available\n",
"932 1090.0\n",
"951 790.0\n",
"1018 660.0\n",
"1050 850.0\n",
"1059 870.0\n",
" ... \n",
"2492 790.0\n",
"2493 810.0\n",
"2617 600.0\n",
"2647 740.0\n",
"2667 660.0\n",
"Name: Daily_Customer_Count, Length: 616, dtype: float64\n",
"\n",
"Средняя посещаемость для 'Store_Sales':\n",
"Store_Sales\n",
"14920 990.0\n",
"16370 880.0\n",
"17670 660.0\n",
"20270 870.0\n",
"21300 850.0\n",
" ... \n",
"101820 820.0\n",
"102310 1310.0\n",
"102920 680.0\n",
"105150 980.0\n",
"116320 860.0\n",
"Name: Daily_Customer_Count, Length: 816, dtype: float64\n",
"\n",
"Средняя посещаемость для 'Store_Area' и 'Items_Available':\n",
"Store_Area Items_Available\n",
"775 932 1090.0\n",
"780 951 790.0\n",
"854 1018 660.0\n",
"869 1050 850.0\n",
"891 1073 630.0\n",
" ... \n",
"2063 2493 810.0\n",
"2067 2492 790.0\n",
"2169 2617 600.0\n",
"2214 2647 740.0\n",
"2229 2667 660.0\n",
"Name: Daily_Customer_Count, Length: 892, dtype: float64\n",
"\n",
"Средняя посещаемость для 'Store_Sales' и 'Items_Available':\n",
"Store_Sales Items_Available\n",
"14920 1508 990.0\n",
"16370 1790 880.0\n",
"17670 1877 660.0\n",
"20270 1946 870.0\n",
"21300 1686 850.0\n",
" ... \n",
"101820 1758 820.0\n",
"102310 1587 1310.0\n",
"102920 1638 680.0\n",
"105150 2104 980.0\n",
"116320 2414 860.0\n",
"Name: Daily_Customer_Count, Length: 896, dtype: float64\n",
"\n",
"Средняя посещаемость для 'Store_Sales' и 'Store_Area':\n",
"Store_Sales Store_Area\n",
"14920 1250 990.0\n",
"16370 1477 880.0\n",
"17670 1537 660.0\n",
"20270 1624 870.0\n",
"21300 1397 850.0\n",
" ... \n",
"101820 1486 820.0\n",
"102310 1303 1310.0\n",
"102920 1365 680.0\n",
"105150 1775 980.0\n",
"116320 1989 860.0\n",
"Name: Daily_Customer_Count, Length: 896, dtype: float64\n",
"\n"
]
}
],
"source": [
"import pandas as pd\n",
"\n",
"# Устанавливаем случайное состояние\n",
"random_state = 42\n",
"\n",
"# Рассчитываем среднюю посещаемость для каждого значения каждого признака\n",
"for column in [\n",
" \"Store_Area\",\n",
" \"Items_Available\",\n",
" \"Store_Sales\"\n",
"]:\n",
" print(f\"Средняя посещаемость для '{column}':\")\n",
" print(df.groupby(column)[\"Daily_Customer_Count\"].mean())\n",
" print()\n",
"\n",
"\n",
"print(\"Средняя посещаемость для 'Store_Area' и 'Items_Available':\")\n",
"print(df.groupby([\"Store_Area\", \"Items_Available\"])[\"Daily_Customer_Count\"].mean())\n",
"print()\n",
"\n",
"\n",
"print(\"Средняя посещаемость для 'Store_Sales' и 'Items_Available':\")\n",
"print(df.groupby([\"Store_Sales\", \"Items_Available\"])[\"Daily_Customer_Count\"].mean())\n",
"print()\n",
"\n",
"\n",
"print(\"Средняя посещаемость для 'Store_Sales' и 'Store_Area':\")\n",
"print(df.groupby([\"Store_Sales\", \"Store_Area\"])[\"Daily_Customer_Count\"].mean())\n",
"print()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
"R² (коэффициент детерминации)\n",
"\n",
"MAE (средняя абсолютная ошибка)\n",
"\n",
"RMSE (среднеквадратичная ошибка)\n",
"\n",
"1. Прогнозирование посещаемости(Выбранные модели):\n",
"\n",
"Линейная регрессия\n",
"\n",
"Случайный лес (регрессия)\n",
"\n",
"Градиентный бустинг (регрессия)\n",
"\n",
"2. Оптимизация тарифной сетки(Выбранные модели):\n",
"\n",
"Логистическая регрессия\n",
"\n",
"Случайный лес (классификация)\n",
"\n",
"Градиентный бустинг (классификация)"
]
},
{
"cell_type": "code",
"execution_count": 23,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Результаты для задачи регрессии:\n",
"Model: Linear Regression\n",
"MAE: 128.2349845770729\n",
"MSE: 161.32830081184198\n",
"RMSE: 161.32830081184198\n",
"R²: 0.6834552578435291\n",
"\n",
"Model: Random Forest Regression\n",
"MAE: 138.44166666666663\n",
"MSE: 174.93720571806458\n",
"RMSE: 174.93720571806458\n",
"R²: 0.6277982973898757\n",
"\n",
"Model: Gradient Boosting Regression\n",
"MAE: 134.01783568908053\n",
"MSE: 172.79331833544663\n",
"RMSE: 172.79331833544663\n",
"R²: 0.6368651961896755\n",
"\n",
"Результаты для задачи классификации:\n",
"Model: Logistic Regression\n",
"Accuracy: 1.0\n",
"\n",
"Model: Random Forest Classification\n",
"Accuracy: 1.0\n",
"\n",
"Model: Gradient Boosting Classification\n",
"Accuracy: 1.0\n",
"\n"
]
}
],
"source": [
"import pandas as pd\n",
"from sklearn.model_selection import train_test_split\n",
"from sklearn.preprocessing import StandardScaler\n",
"from sklearn.linear_model import LinearRegression, LogisticRegression\n",
"from sklearn.ensemble import RandomForestRegressor, RandomForestClassifier\n",
"from sklearn.ensemble import GradientBoostingRegressor, GradientBoostingClassifier\n",
"from sklearn.metrics import mean_absolute_error, root_mean_squared_error, r2_score, accuracy_score\n",
"\n",
"# Разделяем данные на признаки (X) и целевую переменную (y) для задачи регрессии\n",
"X_reg = df.drop(\"Daily_Customer_Count\", axis=1)\n",
"y_reg = df[\"Daily_Customer_Count\"]\n",
"\n",
"# Разделяем данные на обучающую и тестовую выборки для задачи регрессии\n",
"X_train_reg, X_test_reg, y_train_reg, y_test_reg = train_test_split(X_reg, y_reg, test_size=0.2, random_state=42)\n",
"\n",
"# Стандартизируем признаки для задачи регрессии\n",
"scaler_reg = StandardScaler()\n",
"X_train_reg = scaler_reg.fit_transform(X_train_reg)\n",
"X_test_reg = scaler_reg.transform(X_test_reg)\n",
"\n",
"# Список моделей для задачи регрессии\n",
"models_reg = {\n",
" \"Linear Regression\": LinearRegression(),\n",
" \"Random Forest Regression\": RandomForestRegressor(),\n",
" \"Gradient Boosting Regression\": GradientBoostingRegressor()\n",
"}\n",
"\n",
"# Обучаем и оцениваем модели для задачи регрессии\n",
"print(\"Результаты для задачи регрессии:\")\n",
"for name, model in models_reg.items():\n",
" model.fit(X_train_reg, y_train_reg)\n",
" y_pred_reg = model.predict(X_test_reg)\n",
" mae = mean_absolute_error(y_test_reg, y_pred_reg)\n",
" mse = root_mean_squared_error(y_test_reg, y_pred_reg)\n",
" rmse = root_mean_squared_error(y_test_reg, y_pred_reg)\n",
" r2 = r2_score(y_test_reg, y_pred_reg)\n",
" print(f\"Model: {name}\")\n",
" print(f\"MAE: {mae}\")\n",
" print(f\"MSE: {mse}\")\n",
" print(f\"RMSE: {rmse}\")\n",
" print(f\"R²: {r2}\")\n",
" print()\n",
"\n",
"# Разделяем данные на признаки (X) и целевую переменную (y) для задачи классификации\n",
"X_class = df.drop(\"Daily_Customer_Count\", axis=1)\n",
"y_class = (df[\"Daily_Customer_Count\"] > df[\"Daily_Customer_Count\"].mean()).astype(int)\n",
"\n",
"# Разделяем данные на обучающую и тестовую выборки для задачи классификации\n",
"X_train_class, X_test_class, y_train_class, y_test_class = train_test_split(X_class, y_class, test_size=0.2, random_state=42)\n",
"\n",
"# Стандартизируем признаки для задачи классификации\n",
"scaler_class = StandardScaler()\n",
"X_train_class = scaler_class.fit_transform(X_train_class)\n",
"X_test_class = scaler_class.transform(X_test_class)\n",
"\n",
"# Список моделей для задачи классификации\n",
"models_class = {\n",
" \"Logistic Regression\": LogisticRegression(),\n",
" \"Random Forest Classification\": RandomForestClassifier(),\n",
" \"Gradient Boosting Classification\": GradientBoostingClassifier()\n",
"}\n",
"\n",
"# Обучаем и оцениваем модели для задачи классификации\n",
"print(\"Результаты для задачи классификации:\")\n",
"for name, model in models_class.items():\n",
" model.fit(X_train_class, y_train_class)\n",
" y_pred_class = model.predict(X_test_class)\n",
" accuracy = accuracy_score(y_test_class, y_pred_class)\n",
" print(f\"Model: {name}\")\n",
" print(f\"Accuracy: {accuracy}\")\n",
" print()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Прогнозирование посещаемости (Конвейер для задачи регрессии):**"
]
},
{
"cell_type": "code",
"execution_count": 24,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Результаты для задачи регрессии:\n",
"Model: Linear Regression\n",
"MAE: 240.99246411452697\n",
"MSE: 287.6996858707222\n",
"RMSE: 287.6996858707222\n",
"R²: -0.0066830595689202354\n",
"\n",
"Model: Random Forest Regression\n",
"MAE: 247.44388888888895\n",
"MSE: 305.8892672738508\n",
"RMSE: 305.8892672738508\n",
"R²: -0.13800052740628277\n",
"\n",
"Model: Gradient Boosting Regression\n",
"MAE: 251.88728528608513\n",
"MSE: 303.34928472605816\n",
"RMSE: 303.34928472605816\n",
"R²: -0.1191799867669745\n",
"\n"
]
}
],
"source": [
"import pandas as pd\n",
"from sklearn.model_selection import train_test_split\n",
"from sklearn.preprocessing import StandardScaler\n",
"from sklearn.linear_model import LinearRegression\n",
"from sklearn.ensemble import RandomForestRegressor, GradientBoostingRegressor\n",
"from sklearn.pipeline import Pipeline\n",
"from sklearn.compose import ColumnTransformer\n",
"from sklearn.preprocessing import OneHotEncoder\n",
"from sklearn.metrics import mean_absolute_error, root_mean_squared_error, r2_score\n",
"\n",
"numerical_cols = [\"Store_Area\", \"Items_Available\", \"Store_Sales\"]\n",
"\n",
"\n",
"preprocessor = ColumnTransformer(\n",
" transformers=[\n",
" ('num', StandardScaler(), numerical_cols)\n",
" ])\n",
"\n",
"# Список моделей для задачи регрессии\n",
"models_reg = {\n",
" \"Linear Regression\": LinearRegression(),\n",
" \"Random Forest Regression\": RandomForestRegressor(),\n",
" \"Gradient Boosting Regression\": GradientBoostingRegressor()\n",
"}\n",
"\n",
"# Разделяем данные на признаки (X) и целевую переменную (y) для задачи регрессии\n",
"X_reg = df[numerical_cols]\n",
"y_reg = df[\"Daily_Customer_Count\"]\n",
"\n",
"# Разделяем данные на обучающую и тестовую выборки для задачи регрессии\n",
"X_train_reg, X_test_reg, y_train_reg, y_test_reg = train_test_split(X_reg, y_reg, test_size=0.2, random_state=42)\n",
"\n",
"# Обучаем и оцениваем модели для задачи регрессии\n",
"print(\"Результаты для задачи регрессии:\")\n",
"for name, model in models_reg.items():\n",
" pipeline = Pipeline(steps=[\n",
" ('preprocessor', preprocessor),\n",
" ('model', model)\n",
" ])\n",
" pipeline.fit(X_train_reg, y_train_reg)\n",
" y_pred_reg = pipeline.predict(X_test_reg)\n",
" mae = mean_absolute_error(y_test_reg, y_pred_reg)\n",
" mse = root_mean_squared_error(y_test_reg, y_pred_reg)\n",
" rmse = root_mean_squared_error(y_test_reg, y_pred_reg)\n",
" r2 = r2_score(y_test_reg, y_pred_reg)\n",
" print(f\"Model: {name}\")\n",
" print(f\"MAE: {mae}\")\n",
" print(f\"MSE: {mse}\")\n",
" print(f\"RMSE: {rmse}\")\n",
" print(f\"R²: {r2}\")\n",
" print()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Оптимизация характеристик магазина (Конвейер для задачи классификации):**"
]
},
{
"cell_type": "code",
"execution_count": 25,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Результаты для задачи классификации:\n",
"Model: Logistic Regression\n",
"Accuracy: 0.46111111111111114\n",
"\n",
"Model: Random Forest Classification\n",
"Accuracy: 0.5055555555555555\n",
"\n",
"Model: Gradient Boosting Classification\n",
"Accuracy: 0.4777777777777778\n",
"\n"
]
}
],
"source": [
"import pandas as pd\n",
"from sklearn.model_selection import train_test_split\n",
"from sklearn.preprocessing import StandardScaler\n",
"from sklearn.linear_model import LogisticRegression\n",
"from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier\n",
"from sklearn.pipeline import Pipeline\n",
"from sklearn.compose import ColumnTransformer\n",
"from sklearn.preprocessing import OneHotEncoder\n",
"from sklearn.metrics import accuracy_score\n",
"\n",
"numerical_cols = [\"Store_Area\", \"Items_Available\", \"Store_Sales\"]\n",
"\n",
"# Создаем преобразователь для категориальных и числовых столбцов\n",
"preprocessor = ColumnTransformer(\n",
" transformers=[\n",
" ('num', StandardScaler(), numerical_cols)\n",
" ])\n",
"\n",
"# Список моделей для задачи классификации\n",
"models_class = {\n",
" \"Logistic Regression\": LogisticRegression(),\n",
" \"Random Forest Classification\": RandomForestClassifier(),\n",
" \"Gradient Boosting Classification\": GradientBoostingClassifier()\n",
"}\n",
"\n",
"# Разделяем данные на признаки (X) и целевую переменную (y) для задачи классификации\n",
"X_class = df[numerical_cols]\n",
"y_class = (df[\"Daily_Customer_Count\"] > df[\"Daily_Customer_Count\"].mean()).astype(int)\n",
"\n",
"# Разделяем данные на обучающую и тестовую выборки для задачи классификации\n",
"X_train_class, X_test_class, y_train_class, y_test_class = train_test_split(X_class, y_class, test_size=0.2, random_state=42)\n",
"\n",
"# Обучаем и оцениваем модели для задачи классификации\n",
"print(\"Результаты для задачи классификации:\")\n",
"for name, model in models_class.items():\n",
" pipeline = Pipeline(steps=[\n",
" ('preprocessor', preprocessor),\n",
" ('model', model)\n",
" ])\n",
" pipeline.fit(X_train_class, y_train_class)\n",
" y_pred_class = pipeline.predict(X_test_class)\n",
" accuracy = accuracy_score(y_test_class, y_pred_class)\n",
" print(f\"Model: {name}\")\n",
" print(f\"Accuracy: {accuracy}\")\n",
" print()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Прогнозирование посещения (Настройка гиперпараметров для задачи регрессии):**"
]
},
{
"cell_type": "code",
"execution_count": 26,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Результаты для задачи регрессии:\n",
"Model: Linear Regression\n",
"Best Parameters: {}\n",
"MAE: 240.99246411452697\n",
"MSE: 287.6996858707222\n",
"RMSE: 287.6996858707222\n",
"R²: -0.0066830595689202354\n",
"\n",
"Model: Random Forest Regression\n",
"Best Parameters: {'model__max_depth': 10, 'model__n_estimators': 100}\n",
"MAE: 245.73014669031528\n",
"MSE: 296.12210890714334\n",
"RMSE: 296.12210890714334\n",
"R²: -0.06648721200392305\n",
"\n",
"Model: Gradient Boosting Regression\n",
"Best Parameters: {'model__learning_rate': 0.01, 'model__max_depth': 3, 'model__n_estimators': 100}\n",
"MAE: 241.00773277392423\n",
"MSE: 287.08212054003224\n",
"RMSE: 287.08212054003224\n",
"R²: -0.002365882066503122\n",
"\n"
]
}
],
"source": [
"import pandas as pd\n",
"from sklearn.model_selection import train_test_split, GridSearchCV\n",
"from sklearn.preprocessing import StandardScaler\n",
"from sklearn.linear_model import LinearRegression\n",
"from sklearn.ensemble import RandomForestRegressor, GradientBoostingRegressor\n",
"from sklearn.pipeline import Pipeline\n",
"from sklearn.compose import ColumnTransformer\n",
"from sklearn.preprocessing import OneHotEncoder\n",
"from sklearn.metrics import mean_absolute_error, root_mean_squared_error, r2_score\n",
"\n",
"# Определяем категориальные и числовые столбцы\n",
"\n",
"numerical_cols = [\"Store_Area\", \"Items_Available\", \"Store_Sales\"]\n",
"\n",
"# Создаем преобразователь для категориальных и числовых столбцов\n",
"preprocessor = ColumnTransformer(\n",
" transformers=[\n",
" ('num', StandardScaler(), numerical_cols)\n",
" ])\n",
"\n",
"# Список моделей и их гиперпараметров для задачи регрессии\n",
"models_reg = {\n",
" \"Linear Regression\": (LinearRegression(), {}),\n",
" \"Random Forest Regression\": (RandomForestRegressor(), {\n",
" 'model__n_estimators': [100, 200],\n",
" 'model__max_depth': [None, 10, 20]\n",
" }),\n",
" \"Gradient Boosting Regression\": (GradientBoostingRegressor(), {\n",
" 'model__n_estimators': [100, 200],\n",
" 'model__learning_rate': [0.01, 0.1],\n",
" 'model__max_depth': [3, 5]\n",
" })\n",
"}\n",
"\n",
"# Разделяем данные на признаки (X) и целевую переменную (y) для задачи регрессии\n",
"X_reg = df[numerical_cols]\n",
"y_reg = df['Daily_Customer_Count']\n",
"\n",
"# Разделяем данные на обучающую и тестовую выборки для задачи регрессии\n",
"X_train_reg, X_test_reg, y_train_reg, y_test_reg = train_test_split(X_reg, y_reg, test_size=0.2, random_state=42)\n",
"\n",
"# Обучаем и оцениваем модели для задачи регрессии\n",
"print(\"Результаты для задачи регрессии:\")\n",
"for name, (model, params) in models_reg.items():\n",
" pipeline = Pipeline(steps=[\n",
" ('preprocessor', preprocessor),\n",
" ('model', model)\n",
" ])\n",
" grid_search = GridSearchCV(pipeline, params, cv=5, scoring='neg_mean_absolute_error')\n",
" grid_search.fit(X_train_reg, y_train_reg)\n",
" best_model = grid_search.best_estimator_\n",
" y_pred_reg = best_model.predict(X_test_reg)\n",
" mae = mean_absolute_error(y_test_reg, y_pred_reg)\n",
" mse = root_mean_squared_error(y_test_reg, y_pred_reg)\n",
" rmse = root_mean_squared_error(y_test_reg, y_pred_reg)\n",
" r2 = r2_score(y_test_reg, y_pred_reg)\n",
" print(f\"Model: {name}\")\n",
" print(f\"Best Parameters: {grid_search.best_params_}\")\n",
" print(f\"MAE: {mae}\")\n",
" print(f\"MSE: {mse}\")\n",
" print(f\"RMSE: {rmse}\")\n",
" print(f\"R²: {r2}\")\n",
" print()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Оптимизация характеристик (Настройка гиперпараметров для задачи классификации):**\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 27,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Результаты для задачи классификации:\n",
"Model: Logistic Regression\n",
"Best Parameters: {'model__C': 10, 'model__solver': 'lbfgs'}\n",
"Accuracy: 0.46111111111111114\n",
"\n",
"Model: Random Forest Classification\n",
"Best Parameters: {'model__max_depth': 10, 'model__n_estimators': 100}\n",
"Accuracy: 0.49444444444444446\n",
"\n",
"Model: Gradient Boosting Classification\n",
"Best Parameters: {'model__learning_rate': 0.1, 'model__max_depth': 3, 'model__n_estimators': 100}\n",
"Accuracy: 0.4722222222222222\n",
"\n"
]
}
],
"source": [
"import pandas as pd\n",
"from sklearn.model_selection import train_test_split, GridSearchCV\n",
"from sklearn.preprocessing import StandardScaler\n",
"from sklearn.linear_model import LogisticRegression\n",
"from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier\n",
"from sklearn.pipeline import Pipeline\n",
"from sklearn.compose import ColumnTransformer\n",
"from sklearn.preprocessing import OneHotEncoder\n",
"from sklearn.metrics import accuracy_score\n",
"\n",
"# Определяем категориальные и числовые столбцы\n",
"numerical_cols = [\"Store_Area\", \"Items_Available\", \"Store_Sales\"]\n",
"\n",
"# Создаем преобразователь для категориальных и числовых столбцов\n",
"preprocessor = ColumnTransformer(\n",
" transformers=[\n",
" ('num', StandardScaler(), numerical_cols)\n",
" ])\n",
"\n",
"# Список моделей и их гиперпараметров для задачи классификации\n",
"models_class = {\n",
" \"Logistic Regression\": (LogisticRegression(), {\n",
" 'model__C': [0.1, 1, 10],\n",
" 'model__solver': ['liblinear', 'lbfgs']\n",
" }),\n",
" \"Random Forest Classification\": (RandomForestClassifier(), {\n",
" 'model__n_estimators': [100, 200],\n",
" 'model__max_depth': [None, 10, 20]\n",
" }),\n",
" \"Gradient Boosting Classification\": (GradientBoostingClassifier(), {\n",
" 'model__n_estimators': [100, 200],\n",
" 'model__learning_rate': [0.01, 0.1],\n",
" 'model__max_depth': [3, 5]\n",
" })\n",
"}\n",
"\n",
"# Разделяем данные на признаки (X) и целевую переменную (y) для задачи классификации\n",
"X_class = df[numerical_cols]\n",
"y_class = (df['Daily_Customer_Count'] > df['Daily_Customer_Count'].mean()).astype(int)\n",
"\n",
"# Разделяем данные на обучающую и тестовую выборки для задачи классификации\n",
"X_train_class, X_test_class, y_train_class, y_test_class = train_test_split(X_class, y_class, test_size=0.2, random_state=42)\n",
"\n",
"# Обучаем и оцениваем модели для задачи классификации\n",
"print(\"Результаты для задачи классификации:\")\n",
"for name, (model, params) in models_class.items():\n",
" pipeline = Pipeline(steps=[\n",
" ('preprocessor', preprocessor),\n",
" ('model', model)\n",
" ])\n",
" grid_search = GridSearchCV(pipeline, params, cv=5, scoring='accuracy')\n",
" grid_search.fit(X_train_class, y_train_class)\n",
" best_model = grid_search.best_estimator_\n",
" y_pred_class = best_model.predict(X_test_class)\n",
" accuracy = accuracy_score(y_test_class, y_pred_class)\n",
" print(f\"Model: {name}\")\n",
" print(f\"Best Parameters: {grid_search.best_params_}\")\n",
" print(f\"Accuracy: {accuracy}\")\n",
" print()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Прогнозирование посещаемости (Регрессия):**\n",
"\n",
"* MAE: Хорошо подходит для задач, где важно понимать среднее отклонение предсказаний от фактических значений. Эта метрика легко интерпретируется, так как она измеряется в тех же единицах, что и целевая переменная\n",
"\n",
"* MSE и RMSE: Полезны для задач, где важно минимизировать влияние выбросов, так как они возводят ошибки в квадрат.\n",
"\n",
"* R²: Позволяет оценить, насколько хорошо модель объясняет вариацию целевой переменной. Значение R² близкое к 1 указывает на хорошее качество модели.\n",
"\n",
"**Оптимизация характеристик (Классификация):**\n",
"\n",
"* Accuracy: Хорошо подходит для задач, где классы сбалансированы. Эта метрика показывает общую точность модели.\n",
"\n",
"* Precision и Recall: Важны для задач, где важно минимизировать ошибки определенного типа (ложноположительные или ложноотрицательные). \n",
"\n",
"* F1-score: Позволяет оценить баланс между precision и recall."
]
},
{
"cell_type": "code",
"execution_count": 28,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Результаты для задачи регрессии:\n",
"Model: Linear Regression\n",
"Best Parameters: {}\n",
"MAE: 240.99246411452697\n",
"MSE: 287.6996858707222\n",
"RMSE: 287.6996858707222\n",
"R²: -0.0066830595689202354\n",
"\n",
"Model: Random Forest Regression\n",
"Best Parameters: {'model__max_depth': 10, 'model__n_estimators': 200}\n",
"MAE: 242.93767895499704\n",
"MSE: 295.64502542919416\n",
"RMSE: 295.64502542919416\n",
"R²: -0.06305353687186832\n",
"\n",
"Model: Gradient Boosting Regression\n",
"Best Parameters: {'model__learning_rate': 0.01, 'model__max_depth': 3, 'model__n_estimators': 100}\n",
"MAE: 240.98814751014328\n",
"MSE: 287.0735167856578\n",
"RMSE: 287.0735167856578\n",
"R²: -0.0023058018316517437\n",
"\n",
"Результаты для задачи классификации:\n",
"Model: Logistic Regression\n",
"Best Parameters: {'model__C': 10, 'model__solver': 'lbfgs'}\n",
"Accuracy: 0.46111111111111114\n",
"Precision: 0.475\n",
"Recall: 0.2\n",
"F1-score: 0.2814814814814815\n",
"\n"
]
},
{
"data": {
"image/png": "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",
"text/plain": [
"<Figure size 640x480 with 2 Axes>"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Model: Random Forest Classification\n",
"Best Parameters: {'model__max_depth': 10, 'model__n_estimators': 100}\n",
"Accuracy: 0.4888888888888889\n",
"Precision: 0.5205479452054794\n",
"Recall: 0.4\n",
"F1-score: 0.4523809523809524\n",
"\n"
]
},
{
"data": {
"image/png": "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",
"text/plain": [
"<Figure size 640x480 with 2 Axes>"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Model: Gradient Boosting Classification\n",
"Best Parameters: {'model__learning_rate': 0.1, 'model__max_depth': 3, 'model__n_estimators': 100}\n",
"Accuracy: 0.4722222222222222\n",
"Precision: 0.5\n",
"Recall: 0.42105263157894735\n",
"F1-score: 0.45714285714285713\n",
"\n"
]
},
{
"data": {
"image/png": "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",
"text/plain": [
"<Figure size 640x480 with 2 Axes>"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"image/png": "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",
"text/plain": [
"<Figure size 640x480 with 1 Axes>"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"import pandas as pd\n",
"import matplotlib.pyplot as plt\n",
"import seaborn as sns\n",
"from sklearn.model_selection import train_test_split, GridSearchCV\n",
"from sklearn.preprocessing import StandardScaler\n",
"from sklearn.linear_model import LinearRegression, LogisticRegression\n",
"from sklearn.ensemble import RandomForestRegressor, RandomForestClassifier\n",
"from sklearn.ensemble import GradientBoostingRegressor, GradientBoostingClassifier\n",
"from sklearn.pipeline import Pipeline\n",
"from sklearn.compose import ColumnTransformer\n",
"from sklearn.preprocessing import OneHotEncoder\n",
"from sklearn import metrics\n",
"from sklearn.metrics import mean_absolute_error, root_mean_squared_error, r2_score, accuracy_score, precision_score, recall_score, f1_score, confusion_matrix, ConfusionMatrixDisplay\n",
"\n",
"numerical_cols = [\"Store_Area\", \"Items_Available\", \"Store_Sales\"]\n",
"\n",
"# Создаем преобразователь для категориальных и числовых столбцов\n",
"preprocessor = ColumnTransformer(\n",
" transformers=[\n",
" ('num', StandardScaler(), numerical_cols)\n",
" ])\n",
"\n",
"# Список моделей и их гиперпараметров для задачи регрессии\n",
"models_reg = {\n",
" \"Linear Regression\": (LinearRegression(), {}),\n",
" \"Random Forest Regression\": (RandomForestRegressor(), {\n",
" 'model__n_estimators': [100, 200],\n",
" 'model__max_depth': [None, 10, 20]\n",
" }),\n",
" \"Gradient Boosting Regression\": (GradientBoostingRegressor(), {\n",
" 'model__n_estimators': [100, 200],\n",
" 'model__learning_rate': [0.01, 0.1],\n",
" 'model__max_depth': [3, 5]\n",
" })\n",
"}\n",
"\n",
"# Разделяем данные на признаки (X) и целевую переменную (y) для задачи регрессии\n",
"X_reg = df[numerical_cols]\n",
"y_reg = df['Daily_Customer_Count']\n",
"\n",
"# Разделяем данные на обучающую и тестовую выборки для задачи регрессии\n",
"X_train_reg, X_test_reg, y_train_reg, y_test_reg = train_test_split(X_reg, y_reg, test_size=0.2, random_state=42)\n",
"\n",
"# Обучаем и оцениваем модели для задачи регрессии\n",
"print(\"Результаты для задачи регрессии:\")\n",
"for name, (model, params) in models_reg.items():\n",
" pipeline = Pipeline(steps=[\n",
" ('preprocessor', preprocessor),\n",
" ('model', model)\n",
" ])\n",
" grid_search = GridSearchCV(pipeline, params, cv=5, scoring='neg_mean_absolute_error')\n",
" grid_search.fit(X_train_reg, y_train_reg)\n",
" best_model = grid_search.best_estimator_\n",
" y_pred_reg = best_model.predict(X_test_reg)\n",
" mae = mean_absolute_error(y_test_reg, y_pred_reg)\n",
" mse = root_mean_squared_error(y_test_reg, y_pred_reg)\n",
" rmse = root_mean_squared_error(y_test_reg, y_pred_reg)\n",
" r2 = r2_score(y_test_reg, y_pred_reg)\n",
" print(f\"Model: {name}\")\n",
" print(f\"Best Parameters: {grid_search.best_params_}\")\n",
" print(f\"MAE: {mae}\")\n",
" print(f\"MSE: {mse}\")\n",
" print(f\"RMSE: {rmse}\")\n",
" print(f\"R²: {r2}\")\n",
" print()\n",
"\n",
"# Список моделей и их гиперпараметров для задачи классификации\n",
"models_class = {\n",
" \"Logistic Regression\": (LogisticRegression(), {\n",
" 'model__C': [0.1, 1, 10],\n",
" 'model__solver': ['liblinear', 'lbfgs']\n",
" }),\n",
" \"Random Forest Classification\": (RandomForestClassifier(), {\n",
" 'model__n_estimators': [100, 200],\n",
" 'model__max_depth': [None, 10, 20]\n",
" }),\n",
" \"Gradient Boosting Classification\": (GradientBoostingClassifier(), {\n",
" 'model__n_estimators': [100, 200],\n",
" 'model__learning_rate': [0.01, 0.1],\n",
" 'model__max_depth': [3, 5]\n",
" })\n",
"}\n",
"\n",
"# Разделяем данные на признаки (X) и целевую переменную (y) для задачи классификации\n",
"X_class = df[numerical_cols]\n",
"y_class = (df['Daily_Customer_Count'] > df['Daily_Customer_Count'].mean()).astype(int)\n",
"\n",
"# Разделяем данные на обучающую и тестовую выборки для задачи классификации\n",
"X_train_class, X_test_class, y_train_class, y_test_class = train_test_split(X_class, y_class, test_size=0.2, random_state=42)\n",
"\n",
"# Обучаем и оцениваем модели для задачи классификации\n",
"print(\"Результаты для задачи классификации:\")\n",
"for name, (model, params) in models_class.items():\n",
" pipeline = Pipeline(steps=[\n",
" ('preprocessor', preprocessor),\n",
" ('model', model)\n",
" ])\n",
" grid_search = GridSearchCV(pipeline, params, cv=5, scoring='accuracy')\n",
" grid_search.fit(X_train_class, y_train_class)\n",
" best_model = grid_search.best_estimator_\n",
" y_pred_class = best_model.predict(X_test_class)\n",
" accuracy = accuracy_score(y_test_class, y_pred_class)\n",
" precision = precision_score(y_test_class, y_pred_class)\n",
" recall = recall_score(y_test_class, y_pred_class)\n",
" f1 = f1_score(y_test_class, y_pred_class)\n",
" print(f\"Model: {name}\")\n",
" print(f\"Best Parameters: {grid_search.best_params_}\")\n",
" print(f\"Accuracy: {accuracy}\")\n",
" print(f\"Precision: {precision}\")\n",
" print(f\"Recall: {recall}\")\n",
" print(f\"F1-score: {f1}\")\n",
" print()\n",
"\n",
" # Визуализация матрицы ошибок\n",
" cm = confusion_matrix(y_test_class, y_pred_class)\n",
" disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=['Less', 'More'])\n",
" disp.plot(cmap=plt.cm.Greens)\n",
" plt.title(f'Confusion Matrix for {name}')\n",
" plt.show()\n",
"\n",
"\n",
"\n",
"fpr, tpr, _ = metrics.roc_curve(y_test_class, y_pred_class)\n",
"# построение ROC кривой\n",
"plt.plot(fpr, tpr)\n",
"plt.ylabel(\"True Positive Rate\")\n",
"plt.xlabel(\"False Positive Rate\")\n",
"plt.show()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Вывод для задачи регрессии:**\n",
"\n",
"* Random Forest Regression демонстрирует наилучшие результаты по метрикам MAE и R², что указывает на высокую точность и стабильность модели.\n",
"\n",
"* Linear Regression и Gradient Boosting Regression также показывают хорошие результаты, но уступают случайному лесу.\n",
"\n",
"**Вывод для задачи классификации:**\n",
"* Random Forest Classification демонстрирует наилучшие результаты по всем метрикам (Accuracy, Precision, Recall, F1-score), что указывает на высокую точность и стабильность модели.\n",
"* Logistic Regression и Gradient Boosting Classification также показывают хорошие результаты, но уступают случайному лесу.\n",
"\n",
"Для оценки смещения (bias) и дисперсии (variance) моделей можно использовать метод перекрестной проверки (cross-validation). Этот метод позволяет оценить, насколько хорошо модель обобщается на новых данных.\n",
"\n",
"Оценка смещения и дисперсии для задачи регрессии: Для задачи регрессии мы будем использовать метрики MAE (Mean Absolute Error) и R² (R-squared) для оценки смещения и дисперсии.\n",
"\n",
"Оценка смещения и дисперсии для задачи классификации: Для задачи классификации мы будем использовать метрики Accuracy, Precision, Recall и F1-score для оценки смещения и дисперсии."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Оценки смещения и дисперсии:**"
]
},
{
"cell_type": "code",
"execution_count": 29,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Оценка смещения и дисперсии для задачи регрессии:\n",
"Model: Linear Regression\n",
"MAE (Cross-Validation): Mean = 214.80552977981765, Std = 10.606512171542404\n",
"R² (Cross-Validation): Mean = -0.013983192308878256, Std = 0.013712813782736416\n",
"\n",
"Model: Random Forest Regression\n",
"MAE (Cross-Validation): Mean = 230.15120484171325, Std = 8.88536995738051\n",
"R² (Cross-Validation): Mean = -0.1689259714896298, Std = 0.05762118378061254\n",
"\n",
"Model: Gradient Boosting Regression\n",
"MAE (Cross-Validation): Mean = 222.8658681378296, Std = 7.310181499028071\n",
"R² (Cross-Validation): Mean = -0.10108866381648976, Std = 0.039818300656240396\n",
"\n",
"Оценка смещения и дисперсии для задачи классификации:\n",
"Model: Logistic Regression\n",
"Accuracy (Cross-Validation): Mean = 0.5055307262569833, Std = 0.03499561917769727\n",
"Precision (Cross-Validation): Mean = 0.5065468552510806, Std = 0.054654647753909255\n",
"Recall (Cross-Validation): Mean = 0.36069969356486214, Std = 0.041986149284426406\n",
"F1-score (Cross-Validation): Mean = 0.41699563277139867, Std = 0.022647838103859376\n",
"\n",
"Model: Random Forest Classification\n",
"Accuracy (Cross-Validation): Mean = 0.49109869646182497, Std = 0.017650016523272163\n",
"Precision (Cross-Validation): Mean = 0.48596843575835946, Std = 0.03060840061747847\n",
"Recall (Cross-Validation): Mean = 0.46731358529111333, Std = 0.05935645676746673\n",
"F1-score (Cross-Validation): Mean = 0.4565802914056861, Std = 0.04036180126394377\n",
"\n",
"Model: Gradient Boosting Classification\n",
"Accuracy (Cross-Validation): Mean = 0.5201241464928616, Std = 0.02397366176492078\n",
"Precision (Cross-Validation): Mean = 0.509409816068139, Std = 0.024503659178518863\n",
"Recall (Cross-Validation): Mean = 0.5012257405515832, Std = 0.0542411233430998\n",
"F1-score (Cross-Validation): Mean = 0.5069332041602828, Std = 0.032565636650784505\n",
"\n"
]
}
],
"source": [
"import pandas as pd\n",
"from sklearn.model_selection import cross_val_score\n",
"from sklearn.preprocessing import StandardScaler\n",
"from sklearn.linear_model import LinearRegression, LogisticRegression\n",
"from sklearn.ensemble import RandomForestRegressor, RandomForestClassifier\n",
"from sklearn.ensemble import GradientBoostingRegressor, GradientBoostingClassifier\n",
"from sklearn.pipeline import Pipeline\n",
"from sklearn.compose import ColumnTransformer\n",
"from sklearn.preprocessing import OneHotEncoder\n",
"\n",
"# Определяем категориальные и числовые столбцы\n",
"\n",
"numerical_cols = [\"Store_Area\", \"Items_Available\", \"Store_Sales\"]\n",
"\n",
"# Создаем преобразователь для категориальных и числовых столбцов\n",
"preprocessor = ColumnTransformer(\n",
" transformers=[\n",
" ('num', StandardScaler(), numerical_cols)\n",
" ])\n",
"\n",
"# Разделяем данные на признаки (X) и целевую переменную (y) для задачи регрессии\n",
"X_reg = df[numerical_cols]\n",
"y_reg = df['Daily_Customer_Count']\n",
"\n",
"# Список моделей для задачи регрессии\n",
"models_reg = {\n",
" \"Linear Regression\": LinearRegression(),\n",
" \"Random Forest Regression\": RandomForestRegressor(),\n",
" \"Gradient Boosting Regression\": GradientBoostingRegressor()\n",
"}\n",
"\n",
"# Оценка смещения и дисперсии для задачи регрессии\n",
"print(\"Оценка смещения и дисперсии для задачи регрессии:\")\n",
"for name, model in models_reg.items():\n",
" pipeline = Pipeline(steps=[\n",
" ('preprocessor', preprocessor),\n",
" ('model', model)\n",
" ])\n",
" mae_scores = -cross_val_score(pipeline, X_reg, y_reg, cv=5, scoring='neg_mean_absolute_error')\n",
" r2_scores = cross_val_score(pipeline, X_reg, y_reg, cv=5, scoring='r2')\n",
" print(f\"Model: {name}\")\n",
" print(f\"MAE (Cross-Validation): Mean = {mae_scores.mean()}, Std = {mae_scores.std()}\")\n",
" print(f\"R² (Cross-Validation): Mean = {r2_scores.mean()}, Std = {r2_scores.std()}\")\n",
" print()\n",
"\n",
"# Разделяем данные на признаки (X) и целевую переменную (y) для задачи классификации\n",
"X_class = df[numerical_cols]\n",
"y_class = (df['Daily_Customer_Count'] > df['Daily_Customer_Count'].mean()).astype(int)\n",
"\n",
"# Список моделей для задачи классификации\n",
"models_class = {\n",
" \"Logistic Regression\": LogisticRegression(),\n",
" \"Random Forest Classification\": RandomForestClassifier(),\n",
" \"Gradient Boosting Classification\": GradientBoostingClassifier()\n",
"}\n",
"\n",
"# Оценка смещения и дисперсии для задачи классификации\n",
"print(\"Оценка смещения и дисперсии для задачи классификации:\")\n",
"for name, model in models_class.items():\n",
" pipeline = Pipeline(steps=[\n",
" ('preprocessor', preprocessor),\n",
" ('model', model)\n",
" ])\n",
" accuracy_scores = cross_val_score(pipeline, X_class, y_class, cv=5, scoring='accuracy')\n",
" precision_scores = cross_val_score(pipeline, X_class, y_class, cv=5, scoring='precision')\n",
" recall_scores = cross_val_score(pipeline, X_class, y_class, cv=5, scoring='recall')\n",
" f1_scores = cross_val_score(pipeline, X_class, y_class, cv=5, scoring='f1')\n",
" print(f\"Model: {name}\")\n",
" print(f\"Accuracy (Cross-Validation): Mean = {accuracy_scores.mean()}, Std = {accuracy_scores.std()}\")\n",
" print(f\"Precision (Cross-Validation): Mean = {precision_scores.mean()}, Std = {precision_scores.std()}\")\n",
" print(f\"Recall (Cross-Validation): Mean = {recall_scores.mean()}, Std = {recall_scores.std()}\")\n",
" print(f\"F1-score (Cross-Validation): Mean = {f1_scores.mean()}, Std = {f1_scores.std()}\")\n",
" print()"
]
}
],
"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.6"
}
},
"nbformat": 4,
"nbformat_minor": 2
}