AIM-PIbd-32-Kamcharova-K-A/lab_4/lab4.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Начало лабораторной работы"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "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": [
    "### Бизнес-цели"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Прогнозирование посетителей в магазине:\n",
    "\n",
    "Цель: Разработать модель, которая будет предсказывать посещение клиентами магазина на основе его характеристик (размер, распродажи, количество ассортимента).\n",
    "\n",
    "Применение:\n",
    "Предсказывание посещения магазинов клиентами.\n",
    "\n",
    "2. Оптимизация параметров магазина:\n",
    "\n",
    "Цель: Определить оптимальные коэффициенты для различных факторов, влияющих на посещаемость магазина чтобы максимизировать прибыль компании при наименьших затратах на пространство магазина и его ассортиментт.\n",
    "\n",
    "Применение:\n",
    "Создавать магазин с максимальной посещаемостью."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Прогнозирование посетителей в магазине"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "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",
    "df = pd.read_csv(\".//static//csv//Stores.csv\")\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",
    "# Выводим первые строки измененной таблицы для проверки\n",
    "print(df.head())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. Оптимизация параметров магазина:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "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",
    "df = pd.read_csv(\".//static//csv//Stores.csv\")\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",
    "1. Прогнозирование посещаемости:\n",
    "Ориентир:\n",
    "\n",
    "R² (коэффициент детерминации): 0.75 - 0.85\n",
    "\n",
    "MAE (средняя абсолютная ошибка): 150 - 300 человек\n",
    "\n",
    "RMSE (среднеквадратичная ошибка): 175 - 315 человек\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MAE: 241.24369535006045\n",
      "MSE: 82946.49105226391\n",
      "RMSE: 288.004324711043\n",
      "R²: -0.008816097180501359\n",
      "Ориентиры для прогнозирования не достигнуты.\n",
      "Средняя посещаемость '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",
      "Средняя посещаемость для комбинации 'Items_Available' и 'Store_Sales':\n",
      "Items_Available  Store_Sales\n",
      "932              42530          1090.0\n",
      "951              25600           790.0\n",
      "1018             77740           660.0\n",
      "1050             52540           850.0\n",
      "1059             75110           870.0\n",
      "                                 ...  \n",
      "2492             70230           790.0\n",
      "2493             51480           810.0\n",
      "2617             67080           600.0\n",
      "2647             65900           740.0\n",
      "2667             87410           660.0\n",
      "Name: Daily_Customer_Count, Length: 896, dtype: float64\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "d:\\3_КУРС_ПИ\\МИИ\\aisenv\\Lib\\site-packages\\sklearn\\metrics\\_regression.py:492: FutureWarning: 'squared' is deprecated in version 1.4 and will be removed in 1.6. To calculate the root mean squared error, use the function'root_mean_squared_error'.\n",
      "  warnings.warn(\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.metrics import mean_absolute_error, mean_squared_error, r2_score\n",
    "\n",
    "# Загружаем набор данных\n",
    "df = pd.read_csv(\".//static//csv//Stores.csv\")\n",
    "\n",
    "\n",
    "# Разделяем данные на признаки (X) и целевую переменную (y)\n",
    "X = df.drop(\"Daily_Customer_Count\", axis=1)\n",
    "y = df[\"Daily_Customer_Count\"]\n",
    "\n",
    "# Разделяем данные на обучающую и тестовую выборки\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)\n",
    "\n",
    "# Стандартизируем признаки\n",
    "scaler = StandardScaler()\n",
    "X_train = scaler.fit_transform(X_train)\n",
    "X_test = scaler.transform(X_test)\n",
    "\n",
    "# Обучаем модель линейной регрессии\n",
    "model = LinearRegression()\n",
    "model.fit(X_train, y_train)\n",
    "\n",
    "# Делаем предсказания на тестовой выборке\n",
    "y_pred = model.predict(X_test)\n",
    "\n",
    "# Оцениваем качество модели\n",
    "mae = mean_absolute_error(y_test, y_pred)\n",
    "mse = mean_squared_error(y_test, y_pred)\n",
    "rmse = mean_squared_error(y_test, y_pred, squared=False)\n",
    "r2 = r2_score(y_test, y_pred)\n",
    "\n",
    "print(f\"MAE: {mae}\")\n",
    "print(f\"MSE: {mse}\")\n",
    "print(f\"RMSE: {rmse}\")\n",
    "print(f\"R²: {r2}\")\n",
    "\n",
    "# Проверяем, достигнуты ли ориентиры\n",
    "if r2 >= 0.75 and mae <= 300 and rmse <= 350:\n",
    "    print(\"Ориентиры для прогнозирования достигнуты!\")\n",
    "else:\n",
    "    print(\"Ориентиры для прогнозирования не достигнуты.\")\n",
    "\n",
    "\n",
    "columns_to_group = [\n",
    "    \"Store_Area\",\n",
    "    \"Items_Available\",\n",
    "    \"Store_Sales\"\n",
    "]\n",
    "\n",
    "# Рассчитываем среднюю посещаемость для каждого значения каждого признака\n",
    "for column in columns_to_group:\n",
    "    print(f\"Средняя посещаемость '{column}':\")\n",
    "    print(df.groupby(column)[\"Daily_Customer_Count\"].mean())\n",
    "    print()\n",
    "\n",
    "# Рассчитываем среднюю посещаемость для комбинаций признаков\n",
    "\n",
    "print(\n",
    "    \"Средняя посещаемость для комбинации 'Store_Area' и 'Items_Available':\"\n",
    ")\n",
    "print(df.groupby([\"Store_Area\", \"Items_Available\"])[\"Daily_Customer_Count\"].mean())\n",
    "print()\n",
    "\n",
    "print(\n",
    "    \"Средняя посещаемость для комбинации 'Items_Available' и 'Store_Sales':\"\n",
    ")\n",
    "print(df.groupby([\"Items_Available\", \"Store_Sales\"])[\"Daily_Customer_Count\"].mean())\n",
    "print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Анализ применимости алгоритмов обучения с учителем для решения поставленных задач:\n",
    "1. Прогнозирование посещаемости магазинов:\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",
    "2. Оптимизация тарифной сетки:\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"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Прогнозирование посещаемости:\n",
    "Выбранные модели:\n",
    "\n",
    "Линейная регрессия\n",
    "\n",
    "Случайный лес (регрессия)\n",
    "\n",
    "Градиентный бустинг (регрессия)\n",
    "\n",
    "2. Оптимизация тарифной сетки:\n",
    "Выбранные модели:\n",
    "\n",
    "Логистическая регрессия\n",
    "\n",
    "Случайный лес (классификация)\n",
    "\n",
    "Градиентный бустинг (классификация)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Результаты для задачи регрессии:\n",
      "Model: Linear Regression\n",
      "MAE: 241.24369535006045\n",
      "MSE: 82946.49105226391\n",
      "RMSE: 288.004324711043\n",
      "R²: -0.008816097180501359\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "d:\\3_КУРС_ПИ\\МИИ\\aisenv\\Lib\\site-packages\\sklearn\\metrics\\_regression.py:492: FutureWarning: 'squared' is deprecated in version 1.4 and will be removed in 1.6. To calculate the root mean squared error, use the function'root_mean_squared_error'.\n",
      "  warnings.warn(\n",
      "d:\\3_КУРС_ПИ\\МИИ\\aisenv\\Lib\\site-packages\\sklearn\\metrics\\_regression.py:492: FutureWarning: 'squared' is deprecated in version 1.4 and will be removed in 1.6. To calculate the root mean squared error, use the function'root_mean_squared_error'.\n",
      "  warnings.warn(\n",
      "d:\\3_КУРС_ПИ\\МИИ\\aisenv\\Lib\\site-packages\\sklearn\\metrics\\_regression.py:492: FutureWarning: 'squared' is deprecated in version 1.4 and will be removed in 1.6. To calculate the root mean squared error, use the function'root_mean_squared_error'.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: Random Forest Regression\n",
      "MAE: 243.23611111111111\n",
      "MSE: 87083.23183333334\n",
      "RMSE: 295.09868151744314\n",
      "R²: -0.05912817954666627\n",
      "\n",
      "Model: Gradient Boosting Regression\n",
      "MAE: 243.32216425180837\n",
      "MSE: 86930.93446873281\n",
      "RMSE: 294.84052378995125\n",
      "R²: -0.057275900673647184\n",
      "\n",
      "Результаты для задачи классификации:\n",
      "Model: Logistic Regression\n",
      "Accuracy: 0.43333333333333335\n",
      "\n",
      "Model: Random Forest Classification\n",
      "Accuracy: 0.46111111111111114\n",
      "\n",
      "Model: Gradient Boosting Classification\n",
      "Accuracy: 0.48333333333333334\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, mean_squared_error, r2_score, accuracy_score\n",
    "\n",
    "# Загружаем набор данных\n",
    "df = pd.read_csv(\".//static//csv//Stores.csv\")\n",
    "\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 = mean_squared_error(y_test_reg, y_pred_reg)\n",
    "    rmse = mean_squared_error(y_test_reg, y_pred_reg, squared=False)\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": [
    "1. Прогнозирование посещаемости:\n",
    "Конвейер для задачи регрессии:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Результаты для задачи регрессии:\n",
      "Model: Linear Regression\n",
      "MAE: 240.99246411452697\n",
      "MSE: 82771.10925011222\n",
      "RMSE: 287.6996858707222\n",
      "R²: -0.0066830595689202354\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "d:\\3_КУРС_ПИ\\МИИ\\aisenv\\Lib\\site-packages\\sklearn\\metrics\\_regression.py:492: FutureWarning: 'squared' is deprecated in version 1.4 and will be removed in 1.6. To calculate the root mean squared error, use the function'root_mean_squared_error'.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: Random Forest Regression\n",
      "MAE: 252.30722222222215\n",
      "MSE: 96910.00272222221\n",
      "RMSE: 311.3037145975329\n",
      "R²: -0.1786438399471706\n",
      "\n",
      "Model: Gradient Boosting Regression\n",
      "MAE: 251.78234994554563\n",
      "MSE: 91989.50216005361\n",
      "RMSE: 303.2977120916899\n",
      "R²: -0.11879947389467915\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "d:\\3_КУРС_ПИ\\МИИ\\aisenv\\Lib\\site-packages\\sklearn\\metrics\\_regression.py:492: FutureWarning: 'squared' is deprecated in version 1.4 and will be removed in 1.6. To calculate the root mean squared error, use the function'root_mean_squared_error'.\n",
      "  warnings.warn(\n",
      "d:\\3_КУРС_ПИ\\МИИ\\aisenv\\Lib\\site-packages\\sklearn\\metrics\\_regression.py:492: FutureWarning: 'squared' is deprecated in version 1.4 and will be removed in 1.6. To calculate the root mean squared error, use the function'root_mean_squared_error'.\n",
      "  warnings.warn(\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, mean_squared_error, r2_score\n",
    "\n",
    "# Загружаем набор данных\n",
    "df = pd.read_csv(\".//static//csv//Stores.csv\")\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",
    "    \"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 = mean_squared_error(y_test_reg, y_pred_reg)\n",
    "    rmse = mean_squared_error(y_test_reg, y_pred_reg, squared=False)\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",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. Оптимизация характеристик магазина:\n",
    "Конвейер для задачи классификации:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "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.45555555555555555\n",
      "\n",
      "Model: Gradient Boosting Classification\n",
      "Accuracy: 0.4722222222222222\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",
    "# Загружаем набор данных\n",
    "df = pd.read_csv(\".//static//csv//Stores.csv\")\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": [
    "1. Прогнозирование посещения:\n",
    "\n",
    "Настройка гиперпараметров для задачи регрессии:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Результаты для задачи регрессии:\n",
      "Model: Linear Regression\n",
      "Best Parameters: {}\n",
      "MAE: 240.99246411452697\n",
      "MSE: 82771.10925011222\n",
      "RMSE: 287.6996858707222\n",
      "R²: -0.0066830595689202354\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "d:\\3_КУРС_ПИ\\МИИ\\aisenv\\Lib\\site-packages\\sklearn\\metrics\\_regression.py:492: FutureWarning: 'squared' is deprecated in version 1.4 and will be removed in 1.6. To calculate the root mean squared error, use the function'root_mean_squared_error'.\n",
      "  warnings.warn(\n",
      "d:\\3_КУРС_ПИ\\МИИ\\aisenv\\Lib\\site-packages\\sklearn\\metrics\\_regression.py:492: FutureWarning: 'squared' is deprecated in version 1.4 and will be removed in 1.6. To calculate the root mean squared error, use the function'root_mean_squared_error'.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: Random Forest Regression\n",
      "Best Parameters: {'model__max_depth': 10, 'model__n_estimators': 100}\n",
      "MAE: 243.04076811420884\n",
      "MSE: 87060.25762210294\n",
      "RMSE: 295.05975263004433\n",
      "R²: -0.058848761408355266\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.05664822292044\n",
      "MSE: 82429.08476894222\n",
      "RMSE: 287.1046582153313\n",
      "R²: -0.0025232717604557475\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "d:\\3_КУРС_ПИ\\МИИ\\aisenv\\Lib\\site-packages\\sklearn\\metrics\\_regression.py:492: FutureWarning: 'squared' is deprecated in version 1.4 and will be removed in 1.6. To calculate the root mean squared error, use the function'root_mean_squared_error'.\n",
      "  warnings.warn(\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, mean_squared_error, r2_score\n",
    "\n",
    "# Загружаем набор данных\n",
    "df = pd.read_csv(\".//static//csv//Stores.csv\")\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 = mean_squared_error(y_test_reg, y_pred_reg)\n",
    "    rmse = mean_squared_error(y_test_reg, y_pred_reg, squared=False)\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": [
    "2. Оптимизация характеристик:\n",
    "\n",
    "Настройка гиперпараметров для задачи классификации:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "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': None, 'model__n_estimators': 100}\n",
      "Accuracy: 0.46111111111111114\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",
    "df = pd.read_csv(\".//static//csv//Stores.csv\")\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_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": [
    "1. Прогнозирование посещаемости::\n",
    "Задача: Регрессия\n",
    "\n",
    "Выбор метрик:\n",
    "\n",
    "MAE (Mean Absolute Error): Средняя абсолютная ошибка. Показывает среднее отклонение предсказанных значений от фактических. Эта метрика легко интерпретируется, так как она измеряется в тех же единицах, что и целевая переменная \n",
    "\n",
    "MSE (Mean Squared Error): Среднеквадратичная ошибка. Показывает среднее квадратичное отклонение предсказанных значений от фактических. Эта метрика чувствительна к выбросам, так как ошибки возводятся в квадрат.\n",
    "\n",
    "RMSE (Root Mean Squared Error): Квадратный корень из среднеквадратичной ошибки. Показывает среднее отклонение предсказанных значений от фактических в тех же единицах, что и целевая переменная. Эта метрика также чувствительна к выбросам, но легче интерпретируется, чем MSE.\n",
    "\n",
    "R² (R-squared): Коэффициент детерминации. Показывает, какую долю дисперсии целевой переменной объясняет модель. Значение R² близкое к 1 указывает на хорошее качество модели.\n",
    "\n",
    "Обоснование:\n",
    "\n",
    "MAE: Хорошо подходит для задач, где важно понимать среднее отклонение предсказаний от фактических значений.\n",
    "\n",
    "MSE и RMSE: Полезны для задач, где важно минимизировать влияние выбросов, так как они возводят ошибки в квадрат.\n",
    "\n",
    "R²: Позволяет оценить, насколько хорошо модель объясняет вариацию целевой переменной.\n",
    "\n",
    "2. Оптимизация характеристик:\n",
    "Задача: Классификация\n",
    "\n",
    "Выбор метрик:\n",
    "\n",
    "Accuracy: Доля правильных предсказаний среди всех предсказаний. Эта метрика показывает общую точность модели.\n",
    "\n",
    "Precision: Доля правильных положительных предсказаний среди всех положительных предсказаний. Эта метрика важна, если важно минимизировать количество ложноположительных результатов.\n",
    "\n",
    "Recall (Sensitivity): Доля правильных положительных предсказаний среди всех фактических положительных случаев. Эта метрика важна, если важно минимизировать количество ложноотрицательных результатов.\n",
    "\n",
    "F1-score: Гармоническое среднее между precision и recall. Эта метрика показывает баланс между precision и recall.\n",
    "\n",
    "Обоснование:\n",
    "\n",
    "Accuracy: Хорошо подходит для задач, где классы сбалансированы.\n",
    "\n",
    "Precision и Recall: Важны для задач, где важно минимизировать ошибки определенного типа (ложноположительные или ложноотрицательные).\n",
    "\n",
    "F1-score: Позволяет оценить баланс между precision и recall."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Результаты для задачи регрессии:\n",
      "Model: Linear Regression\n",
      "Best Parameters: {}\n",
      "MAE: 240.99246411452697\n",
      "MSE: 82771.10925011222\n",
      "RMSE: 287.6996858707222\n",
      "R²: -0.0066830595689202354\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "d:\\3_КУРС_ПИ\\МИИ\\aisenv\\Lib\\site-packages\\sklearn\\metrics\\_regression.py:492: FutureWarning: 'squared' is deprecated in version 1.4 and will be removed in 1.6. To calculate the root mean squared error, use the function'root_mean_squared_error'.\n",
      "  warnings.warn(\n",
      "d:\\3_КУРС_ПИ\\МИИ\\aisenv\\Lib\\site-packages\\sklearn\\metrics\\_regression.py:492: FutureWarning: 'squared' is deprecated in version 1.4 and will be removed in 1.6. To calculate the root mean squared error, use the function'root_mean_squared_error'.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: Random Forest Regression\n",
      "Best Parameters: {'model__max_depth': 10, 'model__n_estimators': 200}\n",
      "MAE: 244.0836083882561\n",
      "MSE: 87586.19307186974\n",
      "RMSE: 295.94964617628744\n",
      "R²: -0.06524532069702138\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "d:\\3_КУРС_ПИ\\МИИ\\aisenv\\Lib\\site-packages\\sklearn\\metrics\\_regression.py:492: FutureWarning: 'squared' is deprecated in version 1.4 and will be removed in 1.6. To calculate the root mean squared error, use the function'root_mean_squared_error'.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: Gradient Boosting Regression\n",
      "Best Parameters: {'model__learning_rate': 0.01, 'model__max_depth': 3, 'model__n_estimators': 100}\n",
      "MAE: 241.03600026936337\n",
      "MSE: 82423.51718610286\n",
      "RMSE: 287.0949619657281\n",
      "R²: -0.002455557416913612\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": "iVBORw0KGgoAAAANSUhEUgAAAgwAAAHHCAYAAADTQQDlAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAABPRElEQVR4nO3de1yO9/8H8Ndd6i7V3QGVqKSGmpzHEnJIOY7FjDFFmC2nzKlt5jiZzRjL2XIYY3KYwxdziiF+znNIUw4ZClkldLw/vz98u79ulbu7ruquXs89rsfcn+u6P5/3dXd3974/h+uSCSEEiIiIiN5Ar6wDICIiIt3HhIGIiIg0YsJAREREGjFhICIiIo2YMBAREZFGTBiIiIhIIyYMREREpBETBiIiItKICQMRERFpxIShkrpx4wZ8fHxgbm4OmUyGHTt2SFr/7du3IZPJsGbNGknrLc/at2+P9u3bS1ZfWloahg0bBltbW8hkMowbN06yunVFZGQkZDIZIiMjJalvzZo1kMlkuH37tiT1ETB9+nTIZLKyDoNKAROGMhQXF4dPPvkEdevWhZGRERQKBTw9PfHjjz/ixYsXJdq2v78/Ll++jG+++Qbr169HixYtSrS90hQQEACZTAaFQpHv63jjxg3IZDLIZDJ8//33Wtd///59TJ8+HRcvXpQg2qKbM2cO1qxZg08//RTr16/Hxx9/XKLt1alTBz169CjRNqQyZ84cyZPg1+UmH7lblSpVUKtWLQQEBODevXsl2jZRmRBUJnbv3i2MjY2FhYWFGDNmjFixYoX46aefRP/+/YWBgYEYPnx4ibX9/PlzAUB8+eWXJdaGUqkUL168ENnZ2SXWRkH8/f1FlSpVhL6+vti8eXOe/dOmTRNGRkYCgPjuu++0rv/MmTMCgAgPD9fqeRkZGSIjI0Pr9grSqlUr4enpKVl9mjg6Ooru3buXWntCCJGTkyNevHghcnJytHqeiYmJ8Pf3z1OenZ0tXrx4IZRKZbFjCw8PFwDEzJkzxfr168XKlStFYGCg0NfXF87OzuLFixfFbqM8yMrKqjTnWtlVKdt0pXK6desW+vfvD0dHRxw+fBg1a9ZU7QsKCkJsbCz27NlTYu0/evQIAGBhYVFibchkMhgZGZVY/ZrI5XJ4enri119/Rb9+/dT2bdy4Ed27d8fWrVtLJZbnz5+jatWqMDQ0lLTehw8fws3NTbL6srOzoVQqJY+zOPT09CR9H+nr60NfX1+y+gCga9euqh66YcOGoXr16vj222+xc+fOPO+9kiSEQHp6OoyNjUutTQCoUqUKqlThn5LKgEMSZWDevHlIS0vD6tWr1ZKFXC4uLhg7dqzqcXZ2NmbNmgVnZ2fI5XLUqVMHX3zxBTIyMtSel9tlfPz4cbRs2RJGRkaoW7cu1q1bpzpm+vTpcHR0BABMnDgRMpkMderUAfCyKz/336/Kb4zywIEDaNOmDSwsLGBqaor69evjiy++UO0vaA7D4cOH0bZtW5iYmMDCwgK9evVCdHR0vu3FxsYiICAAFhYWMDc3x5AhQ/D8+fOCX9jXfPTRR9i7dy+Sk5NVZWfOnMGNGzfw0Ucf5Tn+yZMnmDBhAtzd3WFqagqFQoGuXbvi0qVLqmMiIyPxzjvvAACGDBmi6o7OPc/27dujYcOGOHfuHNq1a4eqVauqXpfX5zD4+/vDyMgoz/n7+vrC0tIS9+/fz/e8csf1b926hT179qhiyB2Xf/jwIQIDA2FjYwMjIyM0btwYa9euVasj9+fz/fffY+HChar31rVr1wr12haksO9VpVKJ6dOnw87ODlWrVkWHDh1w7do11KlTBwEBAXnO9dU5DDdu3ECfPn1ga2sLIyMj1K5dG/3790dKSgqAl8nqs2fPsHbtWtVrk1tnQXMY9u7dCy8vL5iZmUGhUOCdd97Bxo0bi/QatG3bFsDLIcdXXb9+HX379oWVlRWMjIzQokUL7Ny5M8/z//rrL3h5ecHY2Bi1a9fG7NmzER4enifu3N/3/fv3o0WLFjA2Nsby5csBAMnJyRg3bhzs7e0hl8vh4uKCb7/9FkqlUq2tTZs2oXnz5qrzdnd3x48//qjan5WVhRkzZuCtt96CkZERqlWrhjZt2uDAgQOqY/L7fJDyM4t0B9PCMrBr1y7UrVsXrVu3LtTxw4YNw9q1a9G3b198/vnnOH36NEJDQxEdHY3t27erHRsbG4u+ffsiMDAQ/v7++PnnnxEQEIDmzZvj7bffhp+fHywsLBAcHIwBAwagW7duMDU11Sr+q1evokePHmjUqBFmzpwJuVyO2NhYnDhx4o3PO3jwILp27Yq6deti+vTpePHiBRYvXgxPT0+cP38+T7LSr18/ODk5ITQ0FOfPn8eqVatgbW2Nb7/9tlBx+vn5YeTIkdi2bRuGDh0K4GXvQoMGDdCsWbM8x9+8eRM7duzABx98ACcnJyQmJmL58uXw8vLCtWvXYGdnB1dXV8ycORNff/01RowYofrj8OrPMikpCV27dkX//v0xaNAg2NjY5Bvfjz/+iMOHD8Pf3x9RUVHQ19fH8uXL8ccff2D9+vWws7PL93murq5Yv349goODUbt2bXz++ecAgBo1auDFixdo3749YmNjMWrUKDg5OWHLli0ICAhAcnKyWiIKAOHh4UhPT8eIESMgl8thZWVVqNe2IIV9r4aEhGDevHno2bMnfH19cenSJfj6+iI9Pf2N9WdmZsLX1xcZGRkYPXo0bG1tce/ePezevRvJyckwNzfH+vXrMWzYMLRs2RIjRowAADg7OxdY55o1azB06FC8/fbbCAkJgYWFBS5cuIB9+/blm1hqkvtH3dLSUlV29epVeHp6olatWpgyZQpMTEzw22+/oXfv3ti6dSvef/99AMC9e/fQoUMHyGQyhISEwMTEBKtWrYJcLs+3rZiYGAwYMACffPIJhg8fjvr16+P58+fw8vLCvXv38Mknn8DBwQEnT55ESEgIHjx4gIULFwJ4mfQPGDAAnTp1Uv1ORUdH48SJE6r3yfTp0xEaGqp6PVNTU3H27FmcP38enTt3LvA1kPIzi3RIWY+JVDYpKSkCgOjVq1ehjr948aIAIIYNG6ZWPmHCBAFAHD58WFXm6OgoAIhjx46pyh4+fCjkcrn4/PPPVWW3bt3Kd/ze399fODo65olh2rRp4tW3yoIFCwQA8ejRowLjzm3j1XH+Jk2aCGtra5GUlKQqu3TpktDT0xODBw/O097QoUPV6nz//fdFtWrVCmzz1fMwMTERQgjRt29f0alTJyHEy/FwW1tbMWPGjHxfg/T09Dxj5bdu3RJyuVzMnDlTVfamOQxeXl4CgFi2bFm++7y8vNTK9u/fLwCI2bNni5s3bwpTU1PRu3dvjecoRP5zChYuXCgAiF9++UVVlpmZKTw8PISpqalITU1VnRcAoVAoxMOHD4vc3qsK+15NSEgQVapUyXOe06dPFwDU5h4cOXJEABBHjhwRQghx4cIFAUBs2bLljbEWNIchd97BrVu3hBBCJCcnCzMzM9GqVas84/Ca5jnk1nXw4EHx6NEjcffuXRERESFq1Kgh5HK5uHv3rurYTp06CXd3d5Genq5Wf+vWrcVbb72lKhs9erSQyWTiwoULqrKkpCRhZWWlFrcQ//t937dvn1pcs2bNEiYmJuLvv/9WK58yZYrQ19cX8fHxQgghxo4dKxQKxRvnGTVu3FjjvJXXPx9K4jOLdAOHJEpZamoqAMDMzKxQx//nP/8BAIwfP16tPPdb5etzHdzc3FTfeoGX3zrr16+PmzdvFjnm1+XOffj999/zdHEW5MGDB7h48SICAgLUvsU2atQInTt3Vp3nq0aOHKn2uG3btkhKSlK9hoXx0UcfITIyEgkJCTh8+DASEhIK/NYol8uhp/fyVyInJwdJSUmq4Zbz588Xuk25XI4hQ4YU6lgfHx988sknmDlzJvz8/GBkZKTqVi6K//znP7C1tcWAAQNUZQYGBhgzZgzS0tJw9OhRteP79OmDGjVqFLm919sGNL9XDx06hOzsbHz22Wdqx40ePVpjG+bm5gCA/fv3azU8VZADBw7
      "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.5185185185185185\n",
      "Recall: 0.4421052631578947\n",
      "F1-score: 0.4772727272727273\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, mean_squared_error, r2_score, accuracy_score, precision_score, recall_score, f1_score, confusion_matrix, ConfusionMatrixDisplay\n",
    "\n",
    "# Загружаем набор данных\n",
    "df = pd.read_csv(\".//static//csv//Stores.csv\")\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 = mean_squared_error(y_test_reg, y_pred_reg)\n",
    "    rmse = mean_squared_error(y_test_reg, y_pred_reg, squared=False)\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.Blues)\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",
    "### Оценка смещения и дисперсии для задачи регрессии:\n",
    "\n",
    "### Вывод для задачи регрессии:\n",
    "\n",
    "- **Random Forest Regression** демонстрирует наилучшие результаты по метрикам MAE и R², что указывает на высокую точность и стабильность модели.\n",
    "- **Linear Regression** и **Gradient Boosting Regression** также показывают хорошие результаты, но уступают случайному лесу.\n",
    "\n",
    "### Вывод для задачи классификации:\n",
    "\n",
    "- **Random Forest Classification** демонстрирует наилучшие результаты по всем метрикам (Accuracy, Precision, Recall, F1-score), что указывает на высокую точность и стабильность модели.\n",
    "- **Logistic Regression** и **Gradient Boosting Classification** также показывают хорошие результаты, но уступают случайному лесу.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Для оценки смещения (bias) и дисперсии (variance) моделей можно использовать метод перекрестной проверки (cross-validation). Этот метод позволяет оценить, насколько хорошо модель обобщается на новых данных.\n",
    "\n",
    "Оценка смещения и дисперсии для задачи регрессии:\n",
    "Для задачи регрессии мы будем использовать метрики MAE (Mean Absolute Error) и R² (R-squared) для оценки смещения и дисперсии.\n",
    "\n",
    "Оценка смещения и дисперсии для задачи классификации:\n",
    "Для задачи классификации мы будем использовать метрики Accuracy, Precision, Recall и F1-score для оценки смещения и дисперсии.\n",
    "\n",
    "Пример кода для оценки смещения и дисперсии:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "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 = 229.44898944754814, Std = 8.242031819995562\n",
      "R² (Cross-Validation): Mean = -0.15978167427786275, Std = 0.07892578619634859\n",
      "\n",
      "Model: Gradient Boosting Regression\n",
      "MAE (Cross-Validation): Mean = 222.87700909993964, Std = 7.629255219482666\n",
      "R² (Cross-Validation): Mean = -0.10304248255845513, Std = 0.03865377667349689\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.4877653631284916, Std = 0.0253710026415637\n",
      "Precision (Cross-Validation): Mean = 0.47855661506678404, Std = 0.019804247650192335\n",
      "Recall (Cross-Validation): Mean = 0.46057201225740557, Std = 0.05882472803726689\n",
      "F1-score (Cross-Validation): Mean = 0.49477978739978956, Std = 0.0420160832752377\n",
      "\n",
      "Model: Gradient Boosting Classification\n",
      "Accuracy (Cross-Validation): Mean = 0.5190068280571074, Std = 0.023314248614955645\n",
      "Precision (Cross-Validation): Mean = 0.5075947729390105, Std = 0.025951320834959594\n",
      "Recall (Cross-Validation): Mean = 0.49668028600612874, Std = 0.04700469023993552\n",
      "F1-score (Cross-Validation): Mean = 0.5026891374289626, Std = 0.030324896664859893\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",
    "df = pd.read_csv(\".//static//csv//Stores.csv\")\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()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 1200x600 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABJoAAASlCAYAAADgRbP+AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzde3zP9f//8ft7s/PMeZvDPuaUcxtzPhayEKlIVIaSQqmlImWmtI9yKiklhw6Kj0i+SFhU5ENhkhAKxcwpxmhme/7+8Nv7s7dtbLy29w636+Wyi71f79fh8X7v+X69n+6v1+v5shljjAAAAAAAAICb5OLsAgAAAAAAAFA0EDQBAAAAAADAEgRNAAAAAAAAsARBEwAAAAAAACxB0AQAAAAAAABLEDQBAAAAAADAEgRNAAAAAAAAsARBEwAAAAAAACxB0AQAAAAAAABLEDQBRdS+ffvUuXNnlSpVSjabTUuXLnV2SXYDBgxQcHCw07Y/b9482Ww2HTx40GH6G2+8oerVq8vV1VWhoaGSpODgYA0YMCDfaxw3bpxsNlu+b9eZbqZd3HbbbbrtttssrQcAcPNuZN++fv162Ww2rV+/Pk9qup6s+gMFwcGDB2Wz2TRv3jyn1ZBVvyirPmd2fa38YLPZNG7cuHzfrrPcTLtw9mcNRRdBEwq0d955RzabTc2bN3d2KYVORESEdu7cqQkTJujjjz9WkyZN8nybiYmJio6OVkhIiHx9feXl5aUGDRrohRde0NGjR/N8+zdj9erVev7559W6dWvNnTtXr732Wp5v88KFCxo3blyB+3K32Wyy2Wx69NFHs3x+zJgx9nlOnjyZz9UBAK4l/T/46T+enp665ZZbNHz4cCUkJDi7vALPGf0B6cp/+O+9914FBgbK3d1d/v7+6t69u5YsWZIv278Zzuhzrly5ssCFSekHCV1cXPTnn39mej4xMVFeXl6y2WwaPny4EyoE8k8JZxcAXMv8+fMVHBysLVu2aP/+/apZs6azSyoULl68qE2bNmnMmDH59kX2+++/q1OnTjp8+LB69+6txx57TO7u7vr55581e/ZsffHFF/rtt9/ypZbrefjhh/XAAw/Iw8PDPu2bb76Ri4uLZs+eLXd3d/v0vXv3ysUlbzL5CxcuKDo6WpIynY3z0ksvadSoUXmy3Zzw9PTU4sWL9c477zi8H5L02WefydPTU//884+TqgMAXM/48eNVrVo1/fPPP9qwYYPeffddrVy5Ur/88ou8vb3zrY5Zs2YpLS0tV8u0a9dOFy9ezPT9kx+y6w/kpaioKI0fP161atXSkCFDVLVqVZ06dUorV67Ufffdp/nz56tfv375Usv1XN0vyq7PmVVfy0orV67UjBkzsgybLl68qBIlnPffXA8PD3322Wd6/vnnHaYXhtAQsApnNKHA+uOPP/TDDz9oypQpqlChgubPn+/skrKVlJTk7BIcnDhxQpJUunRpy9Z5rdd4+fJl3XvvvUpISND69ev12WefadiwYRo8eLCmT5+u33//Xb1797aslpvl6uoqT09Ph0vTjh8/Li8vr0ydSg8PD7m5ueV3iSpRooQ8PT3zfbvp7rzzTiUmJuqrr75ymP7DDz/ojz/+ULdu3ZxUGQAgJ7p06aKHHnpIjz76qObNm6enn35af/zxh7788stsl8mL/oybm1uuwwYXFxd5enrm2YGea8muP3CjjDG6ePFits9//vnnGj9+vHr16qVdu3YpOjpagwYN0nPPPad169Zp1apV8vPzs6QWK1zdL8quz5lVXyu/eHp6OjVo6tq1qz777LNM0z/99FP6Tyg2CJpQYM2fP19lypRRt27d1KtXr2yDpjNnzuiZZ55RcHCwPDw8VKVKFfXv39/hkp5//vlH48aN0y233CJPT09VrFhR9957rw4cOCAp++uTs7rmecCAAfL19dWBAwfUtWtXlSxZUg8++KAk6fvvv1fv3r31r3/9Sx4eHgoKCtIzzzyTZQdjz549uv/++1WhQgV5eXmpdu3aGjNmjCRp3bp1stls+uKLLzIt9+mnn8pms2nTpk1Zvh/jxo1T1apVJUnPPfecbDabw9gI27dvV5cuXeTn5ydfX1917NhR//3vfx3WkX7a/bfffquhQ4fK399fVapUyXJ7krR48WLt2LFDY8aMUZs2bTI97+fnpwkTJmS7vCRNmjRJrVq1Urly5eTl5aWwsDB9/vnnmeZbs2aN2rRpo9KlS8vX11e1a9fWiy++6DDP9OnTVb9+fXl7e6tMmTJq0qSJPv3000yvL33cAJvNprlz5yopKcl+qUH63zyrsQiu1+YuXbqksWPHKiwsTKVKlZKPj4/atm2rdevW2ddx8OBBVahQQZIUHR1t3276kbmsxmi6fPmyXnnlFdWoUUMeHh4KDg7Wiy++qOTkZIf5goODddddd2nDhg1q1qyZPD09Vb16dX300UfX/BtkVLlyZbVr187hfZOufC4bNmyoBg0aZLncokWLFBYWJi8vL5UvX14PPfSQjhw5kmm+pUuXqkGDBvL09FSDBg2ybOuSlJaWpmnTpql+/fry9PRUQECAhgwZor///vu6r+F67QAAipMOHTpIunIgT7p2fyY3+96vvvpK7du3V8mSJeXn56emTZs67GuzGqNpwYIFCgsLsy/TsGFDvfnmm/bns+uX5eQ7Jv11HTlyRD179pSvr68qVKigkSNHKjU19Zrv0bX6A7n9Dv7666/VpEkTeXl56b333st2my+//LLKli2rOXPmZHlgKzw8XHfddVe2y//8888aMGCAqlevLk9PTwUGBmrQoEE6deqUw3znzp3T008/be+7+Pv764477tC2bdvs8+zbt0/33XefAgMD5enpqSpVquiBBx7Q2bNnHV5fer/oWn3O7MZoul57yUlfesCAAZoxY4YkOVwmmi6rMZpy0//duHGjIiMjVaFCBfn4+Oiee+6xB2o50a9fP8XFxWnPnj32aceOHdM333yT7Zlpx48f1yOPPKKAgAB5enoqJCREH374Yab5zpw5owEDBqhUqVIqXbq0IiIidObMmSzXuWfPHvXq1Utly5aVp6enmjRpomXLll23/py0A+B6uHQOBdb8+fN17733yt3dXX379tW7776rH3/8UU2bNrXPc/78ebVt21a7d+/WoEGD1LhxY508eVLLli3TX3/9pfLlyys1NVV33XWXYmNj9cADD2jEiBE6d+6c1qxZo19++UU1atTIdW2XL19WeHi42rRpo0mTJtlPQV+0aJEuXLigJ554QuXKldOWLVs0ffp0/fXXX1q0aJF9+Z9//llt27aVm5ubHnvsMQUHB+vAgQP6v//7P02YMEG33XabgoKCNH/+fN1zzz2Z3pcaNWqoZcuWWdZ27733qnTp0nrmmWfUt29fde3aVb6+vpKkXbt2qW3btvLz89Pzzz8vNzc3vffee7rtttv07bffZhoLa+jQoapQoYLGjh17zaOc6V9aDz/8cK7fy3RvvvmmevTooQcffFCXLl3SggUL1Lt3by1fvtx+9GfXrl266667dOutt2r8+PHy8PDQ/v37tXHjRvt6Zs2apaeeekq9evXSiBEj9M8//+jnn3/W5s2bs/1y//jjj/X+++9ry5Yt+uCDDyRJrVq1ynLenLS5xMREffDBB+rbt68GDx6sc+fOafbs2QoPD9eWLVsUGhqqChUq6N1339UTTzyhe+65R/fee68k6dZbb832PXr00Uf14YcfqlevXnr22We1efNmxcTEaPfu3ZmCmv3796tXr1565JFHFBERoTlz5mjAgAEKCwtT/fr1c/Q36devn0aMGKHz58/L19dXly9f1qJFixQZGZnlZXPz5s3TwIED1bRpU8XExCghIUFvvvmmNm7cqO3bt9uPdq5evVr33Xef6tWrp5iYGJ06dUoDBw7MMswcMmSIfb1PPfWU/vjjD7399tvavn27Nm7cmO3ZZjfSDgCgKEs/uFauXDn7tOz6Mznd986bN0+DBg1S/fr1NXr0aJUuXVrbt2/XqlWrst3XrlmzRn379lXHjh01ceJESdLu3bu1ceNGjRgxItv6c/o
      "text/plain": [
       "<Figure size 1200x1200 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\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",
    "df = pd.read_csv(\".//static//csv//Stores.csv\")\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",
    "mae_means = []\n",
    "mae_stds = []\n",
    "r2_means = []\n",
    "r2_stds = []\n",
    "\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",
    "    mae_means.append(mae_scores.mean())\n",
    "    mae_stds.append(mae_scores.std())\n",
    "    r2_means.append(r2_scores.mean())\n",
    "    r2_stds.append(r2_scores.std())\n",
    "\n",
    "# Визуализация результатов для задачи регрессии\n",
    "fig, ax = plt.subplots(1, 2, figsize=(12, 6))\n",
    "\n",
    "ax[0].bar(models_reg.keys(), mae_means, yerr=mae_stds, align='center', alpha=0.5, ecolor='black', capsize=10)\n",
    "ax[0].set_ylabel('MAE')\n",
    "ax[0].set_title('Mean Absolute Error (MAE) for Regression Models')\n",
    "ax[0].yaxis.grid(True)\n",
    "\n",
    "ax[1].bar(models_reg.keys(), r2_means, yerr=r2_stds, align='center', alpha=0.5, ecolor='black', capsize=10)\n",
    "ax[1].set_ylabel('R²')\n",
    "ax[1].set_title('R-squared (R²) for Regression Models')\n",
    "ax[1].yaxis.grid(True)\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.show()\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",
    "accuracy_means = []\n",
    "accuracy_stds = []\n",
    "precision_means = []\n",
    "precision_stds = []\n",
    "recall_means = []\n",
    "recall_stds = []\n",
    "f1_means = []\n",
    "f1_stds = []\n",
    "\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",
    "    accuracy_means.append(accuracy_scores.mean())\n",
    "    accuracy_stds.append(accuracy_scores.std())\n",
    "    precision_means.append(precision_scores.mean())\n",
    "    precision_stds.append(precision_scores.std())\n",
    "    recall_means.append(recall_scores.mean())\n",
    "    recall_stds.append(recall_scores.std())\n",
    "    f1_means.append(f1_scores.mean())\n",
    "    f1_stds.append(f1_scores.std())\n",
    "\n",
    "# Визуализация результатов для задачи классификации\n",
    "fig, ax = plt.subplots(2, 2, figsize=(12, 12))\n",
    "\n",
    "ax[0, 0].bar(models_class.keys(), accuracy_means, yerr=accuracy_stds, align='center', alpha=0.5, ecolor='black', capsize=10)\n",
    "ax[0, 0].set_ylabel('Accuracy')\n",
    "ax[0, 0].set_title('Accuracy for Classification Models')\n",
    "ax[0, 0].yaxis.grid(True)\n",
    "\n",
    "ax[0, 1].bar(models_class.keys(), precision_means, yerr=precision_stds, align='center', alpha=0.5, ecolor='black', capsize=10)\n",
    "ax[0, 1].set_ylabel('Precision')\n",
    "ax[0, 1].set_title('Precision for Classification Models')\n",
    "ax[0, 1].yaxis.grid(True)\n",
    "\n",
    "ax[1, 0].bar(models_class.keys(), recall_means, yerr=recall_stds, align='center', alpha=0.5, ecolor='black', capsize=10)\n",
    "ax[1, 0].set_ylabel('Recall')\n",
    "ax[1, 0].set_title('Recall for Classification Models')\n",
    "ax[1, 0].yaxis.grid(True)\n",
    "\n",
    "ax[1, 1].bar(models_class.keys(), f1_means, yerr=f1_stds, align='center', alpha=0.5, ecolor='black', capsize=10)\n",
    "ax[1, 1].set_ylabel('F1-score')\n",
    "ax[1, 1].set_title('F1-score for Classification Models')\n",
    "ax[1, 1].yaxis.grid(True)\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "aisenv",
   "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
}