{ "cells": [ { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "RangeIndex: 162313 entries, 0 to 162312\n", "Data columns (total 5 columns):\n", " # Column Non-Null Count Dtype \n", "--- ------ -------------- ----- \n", " 0 category 162313 non-null object \n", " 1 sub_category 162313 non-null object \n", " 2 href 162313 non-null object \n", " 3 items 162280 non-null object \n", " 4 price 162282 non-null float64\n", "dtypes: float64(1), object(4)\n", "memory usage: 6.2+ MB\n" ] } ], "source": [ "import pandas as pd\n", "import seaborn as sns\n", "import matplotlib.pyplot as plt\n", "from sklearn.preprocessing import LabelEncoder\n", "from sklearn import metrics\n", "from imblearn.over_sampling import RandomOverSampler\n", "from imblearn.under_sampling import RandomUnderSampler\n", "from sklearn.preprocessing import StandardScaler, OneHotEncoder\n", "from sklearn.metrics import ConfusionMatrixDisplay\n", "from sklearn.compose import ColumnTransformer\n", "from sklearn.pipeline import Pipeline\n", "from sklearn.impute import SimpleImputer\n", "from sklearn.linear_model import LinearRegression, LogisticRegression\n", "from sklearn.ensemble import RandomForestRegressor, GradientBoostingRegressor, RandomForestClassifier, GradientBoostingClassifier\n", "from sklearn.model_selection import train_test_split, GridSearchCV\n", "from sklearn.metrics import (\n", " precision_score, recall_score, accuracy_score, roc_auc_score, f1_score,\n", " matthews_corrcoef, cohen_kappa_score, confusion_matrix\n", ")\n", "from sklearn.metrics import mean_squared_error, r2_score, mean_absolute_error\n", "import numpy as np\n", "import featuretools as ft\n", "from sklearn.metrics import accuracy_score, classification_report\n", "\n", "# Функция для применения oversampling\n", "def apply_oversampling(X, y):\n", " oversampler = RandomOverSampler(random_state=42)\n", " X_resampled, y_resampled = oversampler.fit_resample(X, y)\n", " return X_resampled, y_resampled\n", "\n", "# Функция для применения undersampling\n", "def apply_undersampling(X, y):\n", " undersampler = RandomUnderSampler(random_state=42)\n", " X_resampled, y_resampled = undersampler.fit_resample(X, y)\n", " return X_resampled, y_resampled\n", "\n", "def split_stratified_into_train_val_test(\n", " df_input,\n", " stratify_colname=\"y\",\n", " frac_train=0.6,\n", " frac_val=0.15,\n", " frac_test=0.25,\n", " random_state=None,\n", "):\n", " \"\"\"\n", " Splits a Pandas dataframe into three subsets (train, val, and test)\n", " following fractional ratios provided by the user, where each subset is\n", " stratified by the values in a specific column (that is, each subset has\n", " the same relative frequency of the values in the column). It performs this\n", " splitting by running train_test_split() twice.\n", "\n", " Parameters\n", " ----------\n", " df_input : Pandas dataframe\n", " Input dataframe to be split.\n", " stratify_colname : str\n", " The name of the column that will be used for stratification. Usually\n", " this column would be for the label.\n", " frac_train : float\n", " frac_val : float\n", " frac_test : float\n", " The ratios with which the dataframe will be split into train, val, and\n", " test data. The values should be expressed as float fractions and should\n", " sum to 1.0.\n", " random_state : int, None, or RandomStateInstance\n", " Value to be passed to train_test_split().\n", "\n", " Returns\n", " -------\n", " df_train, df_val, df_test :\n", " Dataframes containing the three splits.\n", " \"\"\"\n", "\n", " if frac_train + frac_val + frac_test != 1.0:\n", " raise ValueError(\n", " \"fractions %f, %f, %f do not add up to 1.0\"\n", " % (frac_train, frac_val, frac_test)\n", " )\n", "\n", " if stratify_colname not in df_input.columns:\n", " raise ValueError(\"%s is not a column in the dataframe\" % (stratify_colname))\n", "\n", " X = df_input # Contains all columns.\n", " y = df_input[\n", " [stratify_colname]\n", " ] # Dataframe of just the column on which to stratify.\n", "\n", " # Split original dataframe into train and temp dataframes.\n", " df_train, df_temp, y_train, y_temp = train_test_split(\n", " X, y, stratify=y, test_size=(1.0 - frac_train), random_state=random_state\n", " )\n", "\n", " # Split the temp dataframe into val and test dataframes.\n", " relative_frac_test = frac_test / (frac_val + frac_test)\n", " df_val, df_test, y_val, y_test = train_test_split(\n", " df_temp,\n", " y_temp,\n", " stratify=y_temp,\n", " test_size=relative_frac_test,\n", " random_state=random_state,\n", " )\n", "\n", " assert len(df_input) == len(df_train) + len(df_val) + len(df_test)\n", "\n", " return df_train, df_val, df_test\n", "\n", "\n", "df = pd.read_csv('../data/jio_mart_items.csv')\n", "df.info()\n", "df = df.sample(n=10000 , random_state=42)" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "['Dining' 'Toys, Games & Fitness' 'Fragrances' 'Bags & Travel Luggage'\n", " 'Girls' 'Home Decor' 'Boys' 'Stationery' 'Beverages' 'Staples' 'Men'\n", " 'Mobiles & Tablets' 'Personal Care' 'Dairy & Bakery' 'Mom & Baby Care'\n", " 'Snacks & Branded Foods' 'Women' 'Books' 'Auto Care' 'Electrical'\n", " 'Furnishing' 'Accessories' 'Pets' 'Home Care' 'Mops, Brushes & Scrubs'\n", " 'Furniture' 'Computers' 'Kitchen Appliances' 'Home Appliances' 'Cameras'\n", " 'Make-Up' 'Garden & Outdoor' 'Disposables' 'Carpentry & work accessories'\n", " 'Mom & Baby' 'Kitchenware' 'Power & Hand Tools' 'Pooja Needs'\n", " 'Bathroom & Laundry Accessories' 'Office Products' 'TV & Speaker'\n", " 'Personal Care & Grooming' 'Hair' 'Skin Care'\n", " 'Paint, Wall Treatments & Supplies' 'Industrial & Scientific Supplies'\n", " 'Infants' 'Kitchen & Bath Fixtures' 'Home Safety & Automation'\n", " 'Fine Jewellery' 'Fruits & Vegetables' 'Apparel' 'Premium Fruits'\n", " 'Phones' 'Bathroom & Laundry' 'Junior Boys' 'Tools & Appliances'\n", " 'Smart Devices' \"Men's Grooming\" 'Gaming' 'Health Care Devices'\n", " 'Handloom & Handicraft' 'Hardware & Plumbing' 'Wellness' 'Treatments']\n" ] } ], "source": [ "print(df['sub_category'].unique())" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Как бизнес-цели выделим следующие 2 варианта:\n", " 1) Регрессия - предсказание цены по категории (для аналитических систем или улучшения алгоритмов ценообразования)\n", " 2) Классификация - определение категории продукта по его подкатегории (для логистических или аналитических систем)\n", " \n", "Однако данный датасет весьма плоо подходит для подобных задач." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Выполним подготовку данных" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "# df.fillna({\"category\": \"NaN\", \"sub_category\": \"NaN\", \"href\" : \"NaN\", \"items\" : \"NaN\", \"price\" : \"NaN\" }, inplace=True)\n", "df = df.dropna()\n", "data = df.copy()\n", "\n", "value_counts = data[\"category\"].value_counts()\n", "rare = value_counts[value_counts < 100].index\n", "data = data[~data[\"category\"].isin(rare)]\n", "\n", "data1 = pd.get_dummies(data, columns=['category', 'sub_category'], drop_first=True)\n", "\n", "# label_encoder = LabelEncoder()\n", "# data1['sub_category'] = label_encoder.fit_transform(data['sub_category'])\n", "# data1['category'] = label_encoder.fit_transform(data['category'])\n", "# data1['items'] = label_encoder.fit_transform(data['items'])\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Определить достижимый уровень качества модели для каждой задачи. На основе имеющихся данных уровень качества моделей регрессии будет низким, поскольку цена слабо коррелирует с категорией (кроме некоторых исключений)." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Построим конвейер." ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Index(['href', 'items', 'price', 'category_Electronics', 'category_Fashion',\n", " 'category_Groceries', 'category_Home & Kitchen', 'sub_category_Apparel',\n", " 'sub_category_Auto Care', 'sub_category_Bags & Travel Luggage',\n", " 'sub_category_Bathroom & Laundry',\n", " 'sub_category_Bathroom & Laundry Accessories', 'sub_category_Beverages',\n", " 'sub_category_Books', 'sub_category_Boys', 'sub_category_Cameras',\n", " 'sub_category_Carpentry & work accessories', 'sub_category_Computers',\n", " 'sub_category_Dairy & Bakery', 'sub_category_Dining',\n", " 'sub_category_Disposables', 'sub_category_Electrical',\n", " 'sub_category_Fragrances', 'sub_category_Fruits & Vegetables',\n", " 'sub_category_Furnishing', 'sub_category_Furniture',\n", " 'sub_category_Gaming', 'sub_category_Garden & Outdoor',\n", " 'sub_category_Girls', 'sub_category_Hair',\n", " 'sub_category_Handloom & Handicraft',\n", " 'sub_category_Hardware & Plumbing', 'sub_category_Health Care Devices',\n", " 'sub_category_Home Appliances', 'sub_category_Home Care',\n", " 'sub_category_Home Decor', 'sub_category_Home Safety & Automation',\n", " 'sub_category_Industrial & Scientific Supplies', 'sub_category_Infants',\n", " 'sub_category_Junior Boys', 'sub_category_Kitchen & Bath Fixtures',\n", " 'sub_category_Kitchen Appliances', 'sub_category_Kitchenware',\n", " 'sub_category_Make-Up', 'sub_category_Men',\n", " 'sub_category_Men's Grooming', 'sub_category_Mobiles & Tablets',\n", " 'sub_category_Mom & Baby', 'sub_category_Mom & Baby Care',\n", " 'sub_category_Mops, Brushes & Scrubs', 'sub_category_Office Products',\n", " 'sub_category_Paint, Wall Treatments & Supplies',\n", " 'sub_category_Personal Care', 'sub_category_Personal Care & Grooming',\n", " 'sub_category_Pets', 'sub_category_Phones', 'sub_category_Pooja Needs',\n", " 'sub_category_Power & Hand Tools', 'sub_category_Premium Fruits',\n", " 'sub_category_Skin Care', 'sub_category_Smart Devices',\n", " 'sub_category_Snacks & Branded Foods', 'sub_category_Staples',\n", " 'sub_category_Stationery', 'sub_category_TV & Speaker',\n", " 'sub_category_Tools & Appliances', 'sub_category_Toys, Games & Fitness',\n", " 'sub_category_Wellness', 'sub_category_Women'],\n", " dtype='object')\n", "\n", "Index: 9995 entries, 52893 to 146053\n", "Data columns (total 69 columns):\n", " # Column Non-Null Count Dtype \n", "--- ------ -------------- ----- \n", " 0 href 9995 non-null object \n", " 1 items 9995 non-null object \n", " 2 price 9995 non-null float64\n", " 3 category_Electronics 9995 non-null bool \n", " 4 category_Fashion 9995 non-null bool \n", " 5 category_Groceries 9995 non-null bool \n", " 6 category_Home & Kitchen 9995 non-null bool \n", " 7 sub_category_Apparel 9995 non-null bool \n", " 8 sub_category_Auto Care 9995 non-null bool \n", " 9 sub_category_Bags & Travel Luggage 9995 non-null bool \n", " 10 sub_category_Bathroom & Laundry 9995 non-null bool \n", " 11 sub_category_Bathroom & Laundry Accessories 9995 non-null bool \n", " 12 sub_category_Beverages 9995 non-null bool \n", " 13 sub_category_Books 9995 non-null bool \n", " 14 sub_category_Boys 9995 non-null bool \n", " 15 sub_category_Cameras 9995 non-null bool \n", " 16 sub_category_Carpentry & work accessories 9995 non-null bool \n", " 17 sub_category_Computers 9995 non-null bool \n", " 18 sub_category_Dairy & Bakery 9995 non-null bool \n", " 19 sub_category_Dining 9995 non-null bool \n", " 20 sub_category_Disposables 9995 non-null bool \n", " 21 sub_category_Electrical 9995 non-null bool \n", " 22 sub_category_Fragrances 9995 non-null bool \n", " 23 sub_category_Fruits & Vegetables 9995 non-null bool \n", " 24 sub_category_Furnishing 9995 non-null bool \n", " 25 sub_category_Furniture 9995 non-null bool \n", " 26 sub_category_Gaming 9995 non-null bool \n", " 27 sub_category_Garden & Outdoor 9995 non-null bool \n", " 28 sub_category_Girls 9995 non-null bool \n", " 29 sub_category_Hair 9995 non-null bool \n", " 30 sub_category_Handloom & Handicraft 9995 non-null bool \n", " 31 sub_category_Hardware & Plumbing 9995 non-null bool \n", " 32 sub_category_Health Care Devices 9995 non-null bool \n", " 33 sub_category_Home Appliances 9995 non-null bool \n", " 34 sub_category_Home Care 9995 non-null bool \n", " 35 sub_category_Home Decor 9995 non-null bool \n", " 36 sub_category_Home Safety & Automation 9995 non-null bool \n", " 37 sub_category_Industrial & Scientific Supplies 9995 non-null bool \n", " 38 sub_category_Infants 9995 non-null bool \n", " 39 sub_category_Junior Boys 9995 non-null bool \n", " 40 sub_category_Kitchen & Bath Fixtures 9995 non-null bool \n", " 41 sub_category_Kitchen Appliances 9995 non-null bool \n", " 42 sub_category_Kitchenware 9995 non-null bool \n", " 43 sub_category_Make-Up 9995 non-null bool \n", " 44 sub_category_Men 9995 non-null bool \n", " 45 sub_category_Men's Grooming 9995 non-null bool \n", " 46 sub_category_Mobiles & Tablets 9995 non-null bool \n", " 47 sub_category_Mom & Baby 9995 non-null bool \n", " 48 sub_category_Mom & Baby Care 9995 non-null bool \n", " 49 sub_category_Mops, Brushes & Scrubs 9995 non-null bool \n", " 50 sub_category_Office Products 9995 non-null bool \n", " 51 sub_category_Paint, Wall Treatments & Supplies 9995 non-null bool \n", " 52 sub_category_Personal Care 9995 non-null bool \n", " 53 sub_category_Personal Care & Grooming 9995 non-null bool \n", " 54 sub_category_Pets 9995 non-null bool \n", " 55 sub_category_Phones 9995 non-null bool \n", " 56 sub_category_Pooja Needs 9995 non-null bool \n", " 57 sub_category_Power & Hand Tools 9995 non-null bool \n", " 58 sub_category_Premium Fruits 9995 non-null bool \n", " 59 sub_category_Skin Care 9995 non-null bool \n", " 60 sub_category_Smart Devices 9995 non-null bool \n", " 61 sub_category_Snacks & Branded Foods 9995 non-null bool \n", " 62 sub_category_Staples 9995 non-null bool \n", " 63 sub_category_Stationery 9995 non-null bool \n", " 64 sub_category_TV & Speaker 9995 non-null bool \n", " 65 sub_category_Tools & Appliances 9995 non-null bool \n", " 66 sub_category_Toys, Games & Fitness 9995 non-null bool \n", " 67 sub_category_Wellness 9995 non-null bool \n", " 68 sub_category_Women 9995 non-null bool \n", "dtypes: bool(66), float64(1), object(2)\n", "memory usage: 956.6+ KB\n" ] } ], "source": [ "print(data1.columns)\n", "data1.info()" ] }, { "cell_type": "code", "execution_count": 83, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Best parameters for Linear Regression: {}\n", "Best parameters for Random Forest Regressor: {'model__max_depth': None, 'model__n_estimators': 300}\n", "Best parameters for Gradient Boosting Regressor: {'model__learning_rate': 0.01, 'model__max_depth': 7, 'model__n_estimators': 300}\n", "Model: Linear Regression\n", "Model: Random Forest Regressor\n", "Model: Gradient Boosting Regressor\n" ] } ], "source": [ "X_reg = data1.drop(['href', 'items', 'price'], axis=1)\n", "y_reg = data1['price']\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", "models_reg = {\n", " 'Linear Regression': LinearRegression(),\n", " 'Random Forest Regressor': RandomForestRegressor(random_state=42),\n", " 'Gradient Boosting Regressor': GradientBoostingRegressor(random_state=42)\n", "}\n", "\n", "# Создание конвейера для регрессии\n", "pipelines_reg = {}\n", "for name, model in models_reg.items():\n", " pipelines_reg[name] = Pipeline([\n", " ('scaler', StandardScaler()),\n", " ('model', model)\n", " ])\n", "\n", "# Определение сетки гиперпараметров для регрессии\n", "param_grids_reg = {\n", " 'Linear Regression': {},\n", " 'Random Forest Regressor': {\n", " 'model__n_estimators': [100, 200, 300],\n", " 'model__max_depth': [None, 10, 20, 30]\n", " },\n", " 'Gradient Boosting Regressor': {\n", " 'model__n_estimators': [100, 200, 300],\n", " 'model__learning_rate': [0.01, 0.1, 0.2],\n", " 'model__max_depth': [3, 5, 7]\n", " }\n", "}\n", "\n", "# Настройка гиперпараметров для регрессии\n", "best_models_reg = {}\n", "for name, pipeline in pipelines_reg.items():\n", " grid_search = GridSearchCV(pipeline, param_grids_reg[name], cv=5, scoring='neg_mean_squared_error')\n", " grid_search.fit(X_train_reg, y_train_reg)\n", " best_models_reg[name] = {\n", " 'pipeline': grid_search.best_estimator_,\n", " 'best_params': grid_search.best_params_\n", " }\n", " print(f'Best parameters for {name}: {grid_search.best_params_}')\n", "\n", "# Обучение моделей и оценка качества\n", "for model_name in best_models_reg.keys():\n", " print(f\"Model: {model_name}\")\n", " model_pipeline = best_models_reg[model_name]['pipeline']\n", " model_pipeline.fit(X_train_reg, y_train_reg)\n", "\n", " y_train_predict = model_pipeline.predict(X_train_reg)\n", " y_test_predict = model_pipeline.predict(X_test_reg)\n", "\n", " best_models_reg[model_name][\"preds_train\"] = y_train_predict\n", " best_models_reg[model_name][\"preds_test\"] = y_test_predict\n", "\n", " best_models_reg[model_name][\"MSE_train\"] = mean_squared_error(y_train_reg, y_train_predict)\n", " best_models_reg[model_name][\"MSE_test\"] = mean_squared_error(y_test_reg, y_test_predict)\n", " best_models_reg[model_name][\"R2_train\"] = r2_score(y_train_reg, y_train_predict)\n", " best_models_reg[model_name][\"R2_test\"] = r2_score(y_test_reg, y_test_predict)\n", " best_models_reg[model_name][\"MAE_train\"] = mean_absolute_error(y_train_reg, y_train_predict)\n", " best_models_reg[model_name][\"MAE_test\"] = mean_absolute_error(y_test_reg, y_test_predict)" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Accuracy: 0.991495747873937\n", "Classification Report:\n", " precision recall f1-score support\n", "\n", " Beauty 0.99 0.90 0.94 131\n", " Electronics 0.99 1.00 0.99 241\n", " Fashion 1.00 1.00 1.00 307\n", " Groceries 0.98 1.00 0.99 573\n", "Home & Kitchen 1.00 1.00 1.00 747\n", "\n", " accuracy 0.99 1999\n", " macro avg 0.99 0.98 0.98 1999\n", " weighted avg 0.99 0.99 0.99 1999\n", "\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Кодирование категориальных данных через LabelEncoder\n", "label_encoder = LabelEncoder()\n", "data['sub_category_encoded'] = label_encoder.fit_transform(data['sub_category'])\n", "\n", "# Определение признаков (X) и целевой переменной (y)\n", "X = data[['sub_category_encoded']] # Используем закодированный sub_category\n", "y = label_encoder.fit_transform(data['category']) # Кодируем category\n", "\n", "# Разделение данных на тренировочную и тестовую выборки\n", "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42, stratify=y)\n", "\n", "# Создание конвейера для классификатора\n", "pipeline = Pipeline([\n", " ('scaler', StandardScaler()), # Масштабирование данных (хотя для категориальных признаков это не всегда нужно)\n", " ('classifier', RandomForestClassifier(random_state=42, n_estimators=100, max_depth=10))\n", "])\n", "\n", "# Обучение модели\n", "pipeline.fit(X_train, y_train)\n", "\n", "# Предсказание на тестовых данных\n", "y_pred = pipeline.predict(X_test)\n", "\n", "print(\"Accuracy:\", accuracy_score(y_test, y_pred))\n", "print(\"Classification Report:\\n\", classification_report(y_test, y_pred, target_names=label_encoder.inverse_transform(np.unique(y_test))))\n", "\n", "# Матрица ошибок\n", "cm = confusion_matrix(y_test, y_pred)\n", "plt.figure(figsize=(10, 8))\n", "sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', xticklabels=label_encoder.classes_, yticklabels=label_encoder.classes_)\n", "plt.xlabel('Predicted')\n", "plt.ylabel('Actual')\n", "plt.title('Confusion Matrix')\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Модель классификации показывает неплохие результаты, что логично, учитывая структуру датасета." ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "Index: 9995 entries, 52893 to 146053\n", "Data columns (total 5 columns):\n", " # Column Non-Null Count Dtype \n", "--- ------ -------------- ----- \n", " 0 category 9995 non-null object \n", " 1 sub_category 9995 non-null object \n", " 2 href 9995 non-null object \n", " 3 items 9995 non-null object \n", " 4 price 9995 non-null float64\n", "dtypes: float64(1), object(4)\n", "memory usage: 468.5+ KB\n" ] } ], "source": [ "data.info()" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "ename": "NameError", "evalue": "name 'best_models_reg' is not defined", "output_type": "error", "traceback": [ "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[1;31mNameError\u001b[0m Traceback (most recent call last)", "Cell \u001b[1;32mIn[9], line 4\u001b[0m\n\u001b[0;32m 1\u001b[0m _, ax \u001b[38;5;241m=\u001b[39m plt\u001b[38;5;241m.\u001b[39msubplots(\u001b[38;5;241m3\u001b[39m, \u001b[38;5;241m2\u001b[39m, figsize\u001b[38;5;241m=\u001b[39m(\u001b[38;5;241m12\u001b[39m, \u001b[38;5;241m10\u001b[39m), sharex\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mFalse\u001b[39;00m, sharey\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mFalse\u001b[39;00m)\n\u001b[0;32m 2\u001b[0m ax \u001b[38;5;241m=\u001b[39m ax\u001b[38;5;241m.\u001b[39mflatten()\n\u001b[1;32m----> 4\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m index, (name, model) \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28menumerate\u001b[39m(\u001b[43mbest_models_reg\u001b[49m\u001b[38;5;241m.\u001b[39mitems()):\n\u001b[0;32m 5\u001b[0m model_pipeline \u001b[38;5;241m=\u001b[39m model[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mpipeline\u001b[39m\u001b[38;5;124m'\u001b[39m]\n\u001b[0;32m 6\u001b[0m y_pred_reg \u001b[38;5;241m=\u001b[39m model_pipeline\u001b[38;5;241m.\u001b[39mpredict(X_test_reg)\n", "\u001b[1;31mNameError\u001b[0m: name 'best_models_reg' is not defined" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "_, ax = plt.subplots(3, 2, figsize=(12, 10), sharex=False, sharey=False)\n", "ax = ax.flatten()\n", "\n", "for index, (name, model) in enumerate(best_models_reg.items()):\n", " model_pipeline = model['pipeline']\n", " y_pred_reg = model_pipeline.predict(X_test_reg)\n", "\n", " # График фактических значений против предсказанных значений\n", " ax[index * 2].scatter(y_test_reg, y_pred_reg, alpha=0.5)\n", " ax[index * 2].plot([min(y_test_reg), max(y_test_reg)], [min(y_test_reg), max(y_test_reg)], color='red', linestyle='--')\n", " ax[index * 2].set_xlabel('Actual Values')\n", " ax[index * 2].set_ylabel('Predicted Values')\n", " ax[index * 2].set_title(f'{name}: Actual vs Predicted')\n", "\n", " # График остатков\n", " residuals = y_test_reg - y_pred_reg\n", " ax[index * 2 + 1].scatter(y_pred_reg, residuals, alpha=0.5)\n", " ax[index * 2 + 1].axhline(y=0, color='red', linestyle='--')\n", " ax[index * 2 + 1].set_xlabel('Predicted Values')\n", " ax[index * 2 + 1].set_ylabel('Residuals')\n", " ax[index * 2 + 1].set_title(f'{name}: Residuals vs Predicted')\n", "\n", "\n", "plt.subplots_adjust(top=1, bottom=0, hspace=0.4, wspace=0.1)\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Модель регресии демонстрирует ужасные результаты ввиду недостаточной корреляции между целеовй характеристикой и строковыми значениями." ] } ], "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.10.8" } }, "nbformat": 4, "nbformat_minor": 2 }