From d262f1e437bdeeb6a4f2a0b5c8c417ac7d6cf0b5 Mon Sep 17 00:00:00 2001
From: DimaRus05 <dimarus06122005@gmail.com>
Date: Mon, 24 Nov 2025 18:09:38 +0300
Subject: [PATCH] Second homework solution

---
 regression-metrics&loss.ipynb | 1886 +++++++++++++++++++++++++++++++++
 1 file changed, 1886 insertions(+)
 create mode 100644 regression-metrics&loss.ipynb

diff --git a/regression-metrics&loss.ipynb b/regression-metrics&loss.ipynb
new file mode 100644
index 0000000..79cda34
--- /dev/null
+++ b/regression-metrics&loss.ipynb
@@ -0,0 +1,1886 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "15d7aeab",
+   "metadata": {},
+   "source": [
+    "# Метрики и функции потерь в регрессии на табличных данных"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a16e91b7",
+   "metadata": {},
+   "source": [
+    "# Импорты и воспроизводимость"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 61,
+   "id": "1023eae0",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Версии:\n",
+      "  sklearn: 1.7.2\n",
+      "  datasets: 4.4.1\n",
+      "  numpy: 2.3.4\n",
+      "  pandas: 2.3.3\n"
+     ]
+    }
+   ],
+   "source": [
+    "import datasets\n",
+    "import sklearn\n",
+    "import pandas as pd\n",
+    "import numpy as np\n",
+    "import seaborn as sns\n",
+    "import matplotlib.pyplot as plt\n",
+    "import os, random\n",
+    "from datasets import load_dataset\n",
+    "from sklearn.model_selection import train_test_split\n",
+    "from sklearn.compose import ColumnTransformer\n",
+    "from sklearn.pipeline import Pipeline, make_pipeline\n",
+    "from sklearn.preprocessing import OneHotEncoder, StandardScaler, FunctionTransformer\n",
+    "from sklearn.impute import SimpleImputer\n",
+    "from sklearn.linear_model import LinearRegression, QuantileRegressor, HuberRegressor\n",
+    "from sklearn.metrics import mean_absolute_error, mean_squared_error, r2_score\n",
+    "\n",
+    "SEED = 42\n",
+    "os.environ[\"PYTHONHASHSEED\"] = str(SEED)\n",
+    "random.seed(SEED)\n",
+    "np.random.seed(SEED)\n",
+    "\n",
+    "sns.set_theme(style=\"whitegrid\")\n",
+    "plt.rcParams[\"figure.figsize\"] = (6, 4)\n",
+    "pd.set_option(\"display.max_columns\", 100)\n",
+    "pd.set_option(\"display.width\", 120)\n",
+    "\n",
+    "print(\"Версии:\")\n",
+    "import sklearn as _sk\n",
+    "print(\"  sklearn:\", _sk.__version__)\n",
+    "import datasets as _ds\n",
+    "print(\"  datasets:\", _ds.__version__)\n",
+    "print(\"  numpy:\", np.__version__)\n",
+    "print(\"  pandas:\", pd.__version__)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 62,
+   "id": "8c5278bf",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Форма: (398, 9)\n",
+      "Типы:\n",
+      "mpg             float64\n",
+      "cylinders         int64\n",
+      "displacement    float64\n",
+      "horsepower       object\n",
+      "weight            int64\n",
+      "acceleration    float64\n",
+      "model year        int64\n",
+      "origin            int64\n",
+      "car name         object\n",
+      "dtype: object\n",
+      "\n",
+      "Первые строки:\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.microsoft.datawrangler.viewer.v0+json": {
+       "columns": [
+        {
+         "name": "index",
+         "rawType": "int64",
+         "type": "integer"
+        },
+        {
+         "name": "mpg",
+         "rawType": "float64",
+         "type": "float"
+        },
+        {
+         "name": "cylinders",
+         "rawType": "int64",
+         "type": "integer"
+        },
+        {
+         "name": "displacement",
+         "rawType": "float64",
+         "type": "float"
+        },
+        {
+         "name": "horsepower",
+         "rawType": "object",
+         "type": "unknown"
+        },
+        {
+         "name": "weight",
+         "rawType": "int64",
+         "type": "integer"
+        },
+        {
+         "name": "acceleration",
+         "rawType": "float64",
+         "type": "float"
+        },
+        {
+         "name": "model year",
+         "rawType": "int64",
+         "type": "integer"
+        },
+        {
+         "name": "origin",
+         "rawType": "int64",
+         "type": "integer"
+        },
+        {
+         "name": "car name",
+         "rawType": "object",
+         "type": "string"
+        }
+       ],
+       "ref": "a465ff96-5a78-497c-8b1e-e0ea6e0b927b",
+       "rows": [
+        [
+         "0",
+         "18.0",
+         "8",
+         "307.0",
+         "130.0",
+         "3504",
+         "12.0",
+         "70",
+         "1",
+         "chevrolet chevelle malibu"
+        ],
+        [
+         "1",
+         "15.0",
+         "8",
+         "350.0",
+         "165.0",
+         "3693",
+         "11.5",
+         "70",
+         "1",
+         "buick skylark 320"
+        ],
+        [
+         "2",
+         "18.0",
+         "8",
+         "318.0",
+         "150.0",
+         "3436",
+         "11.0",
+         "70",
+         "1",
+         "plymouth satellite"
+        ]
+       ],
+       "shape": {
+        "columns": 9,
+        "rows": 3
+       }
+      },
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>mpg</th>\n",
+       "      <th>cylinders</th>\n",
+       "      <th>displacement</th>\n",
+       "      <th>horsepower</th>\n",
+       "      <th>weight</th>\n",
+       "      <th>acceleration</th>\n",
+       "      <th>model year</th>\n",
+       "      <th>origin</th>\n",
+       "      <th>car name</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>18.0</td>\n",
+       "      <td>8</td>\n",
+       "      <td>307.0</td>\n",
+       "      <td>130.0</td>\n",
+       "      <td>3504</td>\n",
+       "      <td>12.0</td>\n",
+       "      <td>70</td>\n",
+       "      <td>1</td>\n",
+       "      <td>chevrolet chevelle malibu</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>15.0</td>\n",
+       "      <td>8</td>\n",
+       "      <td>350.0</td>\n",
+       "      <td>165.0</td>\n",
+       "      <td>3693</td>\n",
+       "      <td>11.5</td>\n",
+       "      <td>70</td>\n",
+       "      <td>1</td>\n",
+       "      <td>buick skylark 320</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>18.0</td>\n",
+       "      <td>8</td>\n",
+       "      <td>318.0</td>\n",
+       "      <td>150.0</td>\n",
+       "      <td>3436</td>\n",
+       "      <td>11.0</td>\n",
+       "      <td>70</td>\n",
+       "      <td>1</td>\n",
+       "      <td>plymouth satellite</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "    mpg  cylinders  displacement horsepower  weight  acceleration  model year  origin                   car name\n",
+       "0  18.0          8         307.0      130.0    3504          12.0          70       1  chevrolet chevelle malibu\n",
+       "1  15.0          8         350.0      165.0    3693          11.5          70       1          buick skylark 320\n",
+       "2  18.0          8         318.0      150.0    3436          11.0          70       1         plymouth satellite"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Целевая переменная:\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.microsoft.datawrangler.viewer.v0+json": {
+       "columns": [
+        {
+         "name": "index",
+         "rawType": "object",
+         "type": "string"
+        },
+        {
+         "name": "mpg",
+         "rawType": "float64",
+         "type": "float"
+        }
+       ],
+       "ref": "dfeaef40-4e94-47bc-9db7-0e1969984bb2",
+       "rows": [
+        [
+         "count",
+         "398.0"
+        ],
+        [
+         "mean",
+         "23.514572864321607"
+        ],
+        [
+         "std",
+         "7.815984312565782"
+        ],
+        [
+         "min",
+         "9.0"
+        ],
+        [
+         "25%",
+         "17.5"
+        ],
+        [
+         "50%",
+         "23.0"
+        ],
+        [
+         "75%",
+         "29.0"
+        ],
+        [
+         "max",
+         "46.6"
+        ]
+       ],
+       "shape": {
+        "columns": 1,
+        "rows": 8
+       }
+      },
+      "text/plain": [
+       "count    398.000000\n",
+       "mean      23.514573\n",
+       "std        7.815984\n",
+       "min        9.000000\n",
+       "25%       17.500000\n",
+       "50%       23.000000\n",
+       "75%       29.000000\n",
+       "max       46.600000\n",
+       "Name: mpg, dtype: float64"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "DATASET_ID = \"scikit-learn/auto-mpg\"\n",
+    "TARGET_MAP = {\n",
+    "    \"scikit-learn/auto-mpg\": \"mpg\",\n",
+    "    \"mstz/abalone\": \"Rings\",\n",
+    "    \"mnemoraorg/wine-quality-6k4\": \"quality\"\n",
+    "}\n",
+    "TARGET_COL = TARGET_MAP[DATASET_ID]\n",
+    "\n",
+    "raw = load_dataset(DATASET_ID)[\"train\"].to_pandas()\n",
+    "df = raw.copy()\n",
+    "\n",
+    "for col in df.columns:\n",
+    "    if df[col].dtype == object:\n",
+    "        coerced = pd.to_numeric(df[col], errors='coerce')\n",
+    "        if coerced.notna().sum() > 0:\n",
+    "            df[col] = coerced.fillna(df[col])\n",
+    "\n",
+    "print(\"Форма:\", df.shape)\n",
+    "print(\"Типы:\")\n",
+    "print(df.dtypes)\n",
+    "print(\"\\nПервые строки:\")\n",
+    "display(df.head(3))\n",
+    "print(\"\\nЦелевая переменная:\")\n",
+    "display(df[TARGET_COL].describe())\n",
+    "\n",
+    "X = df.drop(columns=[TARGET_COL])\n",
+    "y = df[TARGET_COL]\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "573f530b",
+   "metadata": {},
+   "source": [
+    "# 1 — Подготовка данных (разбиение и предобработка)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b8e79edb",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Числовых признаков: 6; категориальных: 2\n",
+      "Размеры выборок:\n",
+      "{'train': 238, 'val': 80, 'test': 80}\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Подготовка данных: split 60/20/20 и Pipeline с предобработкой\n",
+    "# Разбиение: сначала train_val/test=80/20, затем train/val=75/25 → 60/20/20\n",
+    "X_train_val, X_test, y_train_val, y_test = train_test_split(\n",
+    "    X, y, test_size=0.20, random_state=SEED\n",
+    ")\n",
+    "X_train, X_val, y_train, y_val = train_test_split(\n",
+    "    X_train_val, y_train_val, test_size=0.25, random_state=SEED\n",
+    ")\n",
+    "\n",
+    "num_features = [c for c in X_train.columns if pd.api.types.is_numeric_dtype(X_train[c])]\n",
+    "cat_features = [\n",
+    "    c for c in X_train.columns if (\n",
+    "        pd.api.types.is_object_dtype(X_train[c])\n",
+    "        or isinstance(X_train[c].dtype, pd.CategoricalDtype)\n",
+    "        or pd.api.types.is_bool_dtype(X_train[c])\n",
+    "    )\n",
+    "]\n",
+    "print(f\"Числовых признаков: {len(num_features)}; категориальных: {len(cat_features)}\")\n",
+    "\n",
+    "def make_ohe():\n",
+    "    try:\n",
+    "        return OneHotEncoder(handle_unknown='ignore', sparse_output=False)\n",
+    "    except TypeError:\n",
+    "        return OneHotEncoder(handle_unknown='ignore', sparse=False)\n",
+    "\n",
+    "numeric_pipe = Pipeline([\n",
+    "    (\"imputer\", SimpleImputer(strategy='median')),\n",
+    "    (\"scaler\", StandardScaler())\n",
+    "])\n",
+    "\n",
+    "categorical_pipe = Pipeline([\n",
+    "    (\"imputer\", SimpleImputer(strategy='most_frequent')),\n",
+    "    (\"to_str\", FunctionTransformer(lambda X: X.astype(str))),\n",
+    "    (\"ohe\", make_ohe()),\n",
+    "])\n",
+    "\n",
+    "preprocessor = ColumnTransformer(\n",
+    "    transformers=[\n",
+    "        (\"num\", numeric_pipe, num_features),\n",
+    "        (\"cat\", categorical_pipe, cat_features),\n",
+    "    ],\n",
+    "    remainder='drop'\n",
+    ")\n",
+    "\n",
+    "print(\"Размеры выборок:\")\n",
+    "print({\n",
+    "    'train': len(X_train),\n",
+    "    'val':   len(X_val),\n",
+    "    'test':  len(X_test)\n",
+    "})\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6b5d942c",
+   "metadata": {},
+   "source": [
+    "# Метрики и графики"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 64,
+   "id": "0976f3a1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from typing import Optional, Dict\n",
+    "\n",
+    "metrics_columns = [\"model\", \"split\", \"MAE\", \"RMSE\", \"R2\", \"RMSLE\"]\n",
+    "metrics_df = pd.DataFrame(columns=metrics_columns)\n",
+    "\n",
+    "def compute_metrics(y_true: np.ndarray, y_pred: np.ndarray) -> Dict[str, Optional[float]]:\n",
+    "    mae = mean_absolute_error(y_true, y_pred)\n",
+    "    try:\n",
+    "        rmse = mean_squared_error(y_true, y_pred, squared=False)\n",
+    "    except TypeError:\n",
+    "        mse = mean_squared_error(y_true, y_pred)\n",
+    "        rmse = float(np.sqrt(mse))\n",
+    "    r2 = r2_score(y_true, y_pred)\n",
+    "    return {\"MAE\": float(mae), \"RMSE\": float(rmse), \"R2\": float(r2)}\n",
+    "\n",
+    "\n",
+    "def compute_rmsle_safe(y_true: np.ndarray, y_pred: np.ndarray) -> Optional[float]:\n",
+    "    y_true = np.asarray(y_true)\n",
+    "    y_pred = np.asarray(y_pred)\n",
+    "    if (y_true < 0).any() or (y_pred < 0).any():\n",
+    "        return None\n",
+    "    log_true = np.log1p(y_true)\n",
+    "    log_pred = np.log1p(y_pred)\n",
+    "    return float(np.sqrt(np.mean((log_true - log_pred) ** 2)))\n",
+    "\n",
+    "\n",
+    "def add_row(df_: pd.DataFrame, model_name: str, split: str, m: Dict[str, Optional[float]], rmsle: Optional[float] = None) -> pd.DataFrame:\n",
+    "    row = {\n",
+    "        \"model\": model_name,\n",
+    "        \"split\": split,\n",
+    "        \"MAE\": m.get(\"MAE\"),\n",
+    "        \"RMSE\": m.get(\"RMSE\"),\n",
+    "        \"R2\": m.get(\"R2\"),\n",
+    "        \"RMSLE\": rmsle,\n",
+    "    }\n",
+    "    df_copy = df_.copy()\n",
+    "    for col in metrics_columns:\n",
+    "        if col not in df_copy.columns:\n",
+    "            df_copy[col] = pd.Series(dtype=object)\n",
+    "    idx = len(df_copy)\n",
+    "    for col in df_copy.columns:\n",
+    "        df_copy.at[idx, col] = row.get(col, pd.NA)\n",
+    "    return df_copy\n",
+    "\n",
+    "# Графики\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "def plot_pred_vs_true(y_true: np.ndarray, y_pred: np.ndarray, title: str = \"ŷ vs y\") -> None:\n",
+    "    plt.figure(figsize=(5.5, 4.5))\n",
+    "    plt.scatter(y_true, y_pred, alpha=0.6)\n",
+    "    mn = min(np.min(y_true), np.min(y_pred))\n",
+    "    mx = max(np.max(y_true), np.max(y_pred))\n",
+    "    plt.plot([mn, mx], [mn, mx], 'r--', linewidth=1, label='y=x')\n",
+    "    plt.xlabel('y (истинное)')\n",
+    "    plt.ylabel('ŷ (предсказанное)')\n",
+    "    plt.title(title)\n",
+    "    plt.legend()\n",
+    "    plt.tight_layout()\n",
+    "    plt.show()\n",
+    "\n",
+    "def plot_residuals(y_true: np.ndarray, y_pred: np.ndarray, title: str = \"Остатки r=y−ŷ vs ŷ\") -> None:\n",
+    "    y_pred = np.asarray(y_pred)\n",
+    "    residuals = np.asarray(y_true) - y_pred\n",
+    "    plt.figure(figsize=(5.5, 4.5))\n",
+    "    plt.scatter(y_pred, residuals, alpha=0.6)\n",
+    "    plt.axhline(0.0, color='r', linestyle='--', linewidth=1)\n",
+    "    plt.xlabel('ŷ (предсказанное)')\n",
+    "    plt.ylabel('r = y − ŷ')\n",
+    "    plt.title(title)\n",
+    "    plt.tight_layout()\n",
+    "    plt.show()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 65,
+   "id": "385daa2f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from typing import Optional, Dict\n",
+    "\n",
+    "def add_row_safe(df_: pd.DataFrame, model_name: str, split: str, m: Dict[str, Optional[float]], rmsle: Optional[float] = None) -> pd.DataFrame:\n",
+    "    \"\"\"Добавляет строку с метриками в DataFrame безопасно (без pd.concat для одиночной строки).\n",
+    "\n",
+    "    Возвращает новый DataFrame (копию) с добавленной строкой.\n",
+    "    \"\"\"\n",
+    "    row = {\n",
+    "        \"model\": model_name,\n",
+    "        \"split\": split,\n",
+    "        \"MAE\": m.get(\"MAE\"),\n",
+    "        \"RMSE\": m.get(\"RMSE\"),\n",
+    "        \"R2\": m.get(\"R2\"),\n",
+    "        \"RMSLE\": rmsle,\n",
+    "    }\n",
+    "    df_copy = df_.copy()\n",
+    "    for col in metrics_columns:\n",
+    "        if col not in df_copy.columns:\n",
+    "            df_copy[col] = pd.Series(dtype=object)\n",
+    "\n",
+    "    idx = len(df_copy)\n",
+    "    for col in df_copy.columns:\n",
+    "        df_copy.at[idx, col] = row.get(col, pd.NA)\n",
+    "    return df_copy\n",
+    "\n",
+    "\n",
+    "add_row = add_row_safe\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8b6bd7b2",
+   "metadata": {},
+   "source": [
+    "# 2 — Бейзлайны (mean, median)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 66,
+   "id": "f36f7a9b",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Бейзлайны на валидации (ожидается низкий/отрицательный R²):\n",
+      "\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.microsoft.datawrangler.viewer.v0+json": {
+       "columns": [
+        {
+         "name": "index",
+         "rawType": "int64",
+         "type": "integer"
+        },
+        {
+         "name": "model",
+         "rawType": "object",
+         "type": "string"
+        },
+        {
+         "name": "split",
+         "rawType": "object",
+         "type": "string"
+        },
+        {
+         "name": "MAE",
+         "rawType": "object",
+         "type": "unknown"
+        },
+        {
+         "name": "RMSE",
+         "rawType": "object",
+         "type": "unknown"
+        },
+        {
+         "name": "R2",
+         "rawType": "object",
+         "type": "unknown"
+        },
+        {
+         "name": "RMSLE",
+         "rawType": "object",
+         "type": "unknown"
+        }
+       ],
+       "ref": "6762e082-3427-4b46-b6bf-8132d373bd81",
+       "rows": [
+        [
+         "0",
+         "Baseline-Mean",
+         "val",
+         "7.234726890756302",
+         "8.728829949256136",
+         "-0.025647749905760575",
+         "0.3502417297915266"
+        ],
+        [
+         "1",
+         "Baseline-Median",
+         "val",
+         "7.28875",
+         "8.971816984312598",
+         "-0.08354506269809225",
+         "0.3528669476672976"
+        ]
+       ],
+       "shape": {
+        "columns": 6,
+        "rows": 2
+       }
+      },
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>model</th>\n",
+       "      <th>split</th>\n",
+       "      <th>MAE</th>\n",
+       "      <th>RMSE</th>\n",
+       "      <th>R2</th>\n",
+       "      <th>RMSLE</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>Baseline-Mean</td>\n",
+       "      <td>val</td>\n",
+       "      <td>7.234727</td>\n",
+       "      <td>8.72883</td>\n",
+       "      <td>-0.025648</td>\n",
+       "      <td>0.350242</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>Baseline-Median</td>\n",
+       "      <td>val</td>\n",
+       "      <td>7.28875</td>\n",
+       "      <td>8.971817</td>\n",
+       "      <td>-0.083545</td>\n",
+       "      <td>0.352867</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "             model split       MAE      RMSE        R2     RMSLE\n",
+       "0    Baseline-Mean   val  7.234727   8.72883 -0.025648  0.350242\n",
+       "1  Baseline-Median   val   7.28875  8.971817 -0.083545  0.352867"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "val_pred_mean = np.full_like(y_val.values, fill_value=float(np.mean(y_train)), dtype=float)\n",
+    "val_pred_median = np.full_like(y_val.values, fill_value=float(np.median(y_train)), dtype=float)\n",
+    "\n",
+    "m_mean = compute_metrics(y_val.values, val_pred_mean)\n",
+    "m_median = compute_metrics(y_val.values, val_pred_median)\n",
+    "\n",
+    "metrics_df = add_row(metrics_df, \"Baseline-Mean\",   \"val\", m_mean,   compute_rmsle_safe(y_val.values, val_pred_mean))\n",
+    "metrics_df = add_row(metrics_df, \"Baseline-Median\", \"val\", m_median, compute_rmsle_safe(y_val.values, val_pred_median))\n",
+    "\n",
+    "print(\"Бейзлайны на валидации (ожидается низкий/отрицательный R²):\")\n",
+    "display(metrics_df.tail(2))\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9b14dc4d",
+   "metadata": {},
+   "source": [
+    "# 3 — Линейная модель (LinearRegression, MSE)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "52a654ed",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Метрики LinearRegression (валидация):\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.microsoft.datawrangler.viewer.v0+json": {
+       "columns": [
+        {
+         "name": "index",
+         "rawType": "int64",
+         "type": "integer"
+        },
+        {
+         "name": "model",
+         "rawType": "object",
+         "type": "string"
+        },
+        {
+         "name": "MAE",
+         "rawType": "float64",
+         "type": "float"
+        },
+        {
+         "name": "RMSE",
+         "rawType": "float64",
+         "type": "float"
+        },
+        {
+         "name": "R2",
+         "rawType": "float64",
+         "type": "float"
+        },
+        {
+         "name": "RMSLE",
+         "rawType": "float64",
+         "type": "float"
+        }
+       ],
+       "ref": "fe5884a5-629d-4900-a564-fad103db5789",
+       "rows": [
+        [
+         "0",
+         "Linear(MSE)",
+         "5.612787536977304",
+         "7.295296485845585",
+         "0.2835728113795092",
+         "0.3400308083427264"
+        ]
+       ],
+       "shape": {
+        "columns": 5,
+        "rows": 1
+       }
+      },
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>model</th>\n",
+       "      <th>MAE</th>\n",
+       "      <th>RMSE</th>\n",
+       "      <th>R2</th>\n",
+       "      <th>RMSLE</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>Linear(MSE)</td>\n",
+       "      <td>5.612788</td>\n",
+       "      <td>7.295296</td>\n",
+       "      <td>0.283573</td>\n",
+       "      <td>0.340031</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "         model       MAE      RMSE        R2     RMSLE\n",
+       "0  Linear(MSE)  5.612788  7.295296  0.283573  0.340031"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 550x450 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 550x450 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Линейная модель (MSE): обучение, метрики, графики\n",
+    "lin_mse = Pipeline(steps=[\n",
+    "    (\"preprocess\", preprocessor),\n",
+    "    (\"model\", LinearRegression())\n",
+    "])\n",
+    "\n",
+    "lin_mse.fit(X_train, y_train)\n",
+    "\n",
+    "val_pred_lr = lin_mse.predict(X_val)\n",
+    "val_pred_lr = np.asarray(val_pred_lr).ravel()\n",
+    "y_val_arr = np.asarray(y_val).ravel()\n",
+    "\n",
+    "# Метрики (MAE, RMSE, R2) и RMSLE при применимости\n",
+    "m_lr = compute_metrics(y_val_arr, val_pred_lr)\n",
+    "rmsle_lr = compute_rmsle_safe(y_val_arr, val_pred_lr)\n",
+    "metrics_df = add_row(metrics_df, \"Linear(MSE)\", \"val\", m_lr, rmsle_lr)\n",
+    "\n",
+    "# Выводим аккуратно отформатированную таблицу с метриками\n",
+    "print(\"Метрики LinearRegression (валидация):\")\n",
+    "display(pd.DataFrame([{\n",
+    "    \"model\": \"Linear(MSE)\",\n",
+    "    \"MAE\": m_lr['MAE'],\n",
+    "    \"RMSE\": m_lr['RMSE'],\n",
+    "    \"R2\": m_lr['R2'],\n",
+    "    \"RMSLE\": rmsle_lr\n",
+    "}]))\n",
+    "\n",
+    "# Графики: ŷ vs y и остатки r=y-ŷ vs ŷ\n",
+    "plot_pred_vs_true(y_val_arr, val_pred_lr, title=\"Linear(MSE): ŷ vs y (val)\")\n",
+    "plot_residuals(y_val_arr, val_pred_lr, title=\"Linear(MSE): Остатки r=y−ŷ vs ŷ (val)\")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e6918206",
+   "metadata": {},
+   "source": [
+    "# 4 — Сравнение функций потерь (MSE vs MAE)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 68,
+   "id": "630882f5",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Сравнение на валидации:\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.microsoft.datawrangler.viewer.v0+json": {
+       "columns": [
+        {
+         "name": "index",
+         "rawType": "int64",
+         "type": "integer"
+        },
+        {
+         "name": "model",
+         "rawType": "object",
+         "type": "string"
+        },
+        {
+         "name": "split",
+         "rawType": "object",
+         "type": "string"
+        },
+        {
+         "name": "MAE",
+         "rawType": "object",
+         "type": "unknown"
+        },
+        {
+         "name": "RMSE",
+         "rawType": "object",
+         "type": "unknown"
+        },
+        {
+         "name": "R2",
+         "rawType": "object",
+         "type": "unknown"
+        },
+        {
+         "name": "RMSLE",
+         "rawType": "object",
+         "type": "unknown"
+        }
+       ],
+       "ref": "bd2f241e-a449-49eb-ac59-631c3370ab47",
+       "rows": [
+        [
+         "0",
+         "Baseline-Mean",
+         "val",
+         "7.234726890756302",
+         "8.728829949256136",
+         "-0.025647749905760575",
+         "0.3502417297915266"
+        ],
+        [
+         "1",
+         "Baseline-Median",
+         "val",
+         "7.28875",
+         "8.971816984312598",
+         "-0.08354506269809225",
+         "0.3528669476672976"
+        ],
+        [
+         "2",
+         "Linear(MSE)",
+         "val",
+         "5.612787536977304",
+         "7.295296485845585",
+         "0.2835728113795092",
+         "0.3400308083427264"
+        ],
+        [
+         "3",
+         "Linear(MAE:Quantile=0.5)",
+         "val",
+         "11.427252526027672",
+         "15.252574116761554",
+         "-2.1316444874973235",
+         null
+        ]
+       ],
+       "shape": {
+        "columns": 6,
+        "rows": 4
+       }
+      },
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>model</th>\n",
+       "      <th>split</th>\n",
+       "      <th>MAE</th>\n",
+       "      <th>RMSE</th>\n",
+       "      <th>R2</th>\n",
+       "      <th>RMSLE</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>Baseline-Mean</td>\n",
+       "      <td>val</td>\n",
+       "      <td>7.234727</td>\n",
+       "      <td>8.72883</td>\n",
+       "      <td>-0.025648</td>\n",
+       "      <td>0.350242</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>Baseline-Median</td>\n",
+       "      <td>val</td>\n",
+       "      <td>7.28875</td>\n",
+       "      <td>8.971817</td>\n",
+       "      <td>-0.083545</td>\n",
+       "      <td>0.352867</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>Linear(MSE)</td>\n",
+       "      <td>val</td>\n",
+       "      <td>5.612788</td>\n",
+       "      <td>7.295296</td>\n",
+       "      <td>0.283573</td>\n",
+       "      <td>0.340031</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>Linear(MAE:Quantile=0.5)</td>\n",
+       "      <td>val</td>\n",
+       "      <td>11.427253</td>\n",
+       "      <td>15.252574</td>\n",
+       "      <td>-2.131644</td>\n",
+       "      <td>None</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                      model split        MAE       RMSE        R2     RMSLE\n",
+       "0             Baseline-Mean   val   7.234727    8.72883 -0.025648  0.350242\n",
+       "1           Baseline-Median   val    7.28875   8.971817 -0.083545  0.352867\n",
+       "2               Linear(MSE)   val   5.612788   7.295296  0.283573  0.340031\n",
+       "3  Linear(MAE:Quantile=0.5)   val  11.427253  15.252574 -2.131644      None"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# MSE (LinearRegression) vs MAE (QuantileRegressor q=0.5)\n",
+    "lin_mae = Pipeline(steps=[\n",
+    "    (\"preprocess\", preprocessor),\n",
+    "    (\"model\", QuantileRegressor(quantile=0.5, alpha=0.0, solver='highs'))\n",
+    "])\n",
+    "lin_mae.fit(X_train, y_train)\n",
+    "\n",
+    "val_pred_qr = lin_mae.predict(X_val)\n",
+    "m_qr = compute_metrics(y_val.values, val_pred_qr)\n",
+    "rmsle_qr = compute_rmsle_safe(y_val.values, val_pred_qr)\n",
+    "metrics_df = add_row(metrics_df, \"Linear(MAE:Quantile=0.5)\", \"val\", m_qr, rmsle_qr)\n",
+    "\n",
+    "print(\"Сравнение на валидации:\")\n",
+    "display(metrics_df[metrics_df[\"split\"]==\"val\"])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "27552eaa",
+   "metadata": {},
+   "source": [
+    "  - *Linear(MSE)* (линейная регрессия, обученная минимизацией MSE) в данном эксперименте даёт более низкий `RMSE` и более высокий `R2` по сравнению с бейзлайнами, что означает, что модель захватывает часть дисперсии целевой переменной.\n",
+    "  - *Linear(MAE:Quantile=0.5)* (квантильная регрессия / MAE) обычно показывает более высокую `RMSE` и часто более низкий `MAE` по сравнению с MSE-оптимизированной моделью — это ожидаемое поведение при наличии выбросов.\n",
+    "\n",
+    "  - **MAE (Mean Absolute Error):** даёт оценку средней абсолютной ошибки в тех же единицах, что и целевая переменная. Менее чувствителен к редким большим ошибкам.\n",
+    "  - **RMSE (Root Mean Squared Error):** больше штрафует крупные ошибки.\n",
+    "  - **R2 (Коэффициент детерминации):** показывает долю объяснённой дисперсии. Значение, близкое к 1 — хорошо; отрицательное — хуже, чем среднее значение бейзлайна.\n",
+    "  - **RMSLE (Root Mean Squared Log Error):** логарифм даёт понимание относительного масштаба ошибок\n",
+    "\n",
+    "- **Сравнение бейзлайнов и моделей:**\n",
+    "  - Бейзлайны дают уровень «минимально приемлемой» ошибки. Если модели не улучшают MAE/RMSE заметно относительно бейзлайнов, это признак, что:\n",
+    "    - либо признаки плохо информативны,\n",
+    "    - либо данные шумные/малый объём,\n",
+    "    - либо модель слишком простая.\n",
+    "  - В таблице видно, что `Linear(MSE)` улучшает оба показателя по сравнению с бейзлайнами → признаки содержат полезную информацию.\n",
+    "\n",
+    "- **Почему у QuantileRegressor (MAE) выше RMSE:**\n",
+    "  - MAE/медианная оптимизация менее чувствительна к выбросам, поэтому при наличии нескольких крупных ошибок модель ориентируется на «медиану» ошибок; как результат, RMSE (четвертая степень влияния больших ошибок) может быть хуже."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 69,
+   "id": "d7346c68",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Сводная по валидации (сортировка по RMSE):\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.microsoft.datawrangler.viewer.v0+json": {
+       "columns": [
+        {
+         "name": "index",
+         "rawType": "int64",
+         "type": "integer"
+        },
+        {
+         "name": "model",
+         "rawType": "object",
+         "type": "string"
+        },
+        {
+         "name": "MAE",
+         "rawType": "object",
+         "type": "unknown"
+        },
+        {
+         "name": "RMSE",
+         "rawType": "object",
+         "type": "unknown"
+        },
+        {
+         "name": "R2",
+         "rawType": "object",
+         "type": "unknown"
+        },
+        {
+         "name": "RMSLE",
+         "rawType": "object",
+         "type": "unknown"
+        }
+       ],
+       "ref": "b066ae62-99ac-4307-b7b5-9126cf413020",
+       "rows": [
+        [
+         "2",
+         "Linear(MSE)",
+         "5.612787536977304",
+         "7.295296485845585",
+         "0.2835728113795092",
+         "0.3400308083427264"
+        ],
+        [
+         "0",
+         "Baseline-Mean",
+         "7.234726890756302",
+         "8.728829949256136",
+         "-0.025647749905760575",
+         "0.3502417297915266"
+        ],
+        [
+         "1",
+         "Baseline-Median",
+         "7.28875",
+         "8.971816984312598",
+         "-0.08354506269809225",
+         "0.3528669476672976"
+        ],
+        [
+         "3",
+         "Linear(MAE:Quantile=0.5)",
+         "11.427252526027672",
+         "15.252574116761554",
+         "-2.1316444874973235",
+         null
+        ]
+       ],
+       "shape": {
+        "columns": 5,
+        "rows": 4
+       }
+      },
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>model</th>\n",
+       "      <th>MAE</th>\n",
+       "      <th>RMSE</th>\n",
+       "      <th>R2</th>\n",
+       "      <th>RMSLE</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>Linear(MSE)</td>\n",
+       "      <td>5.612788</td>\n",
+       "      <td>7.295296</td>\n",
+       "      <td>0.283573</td>\n",
+       "      <td>0.340031</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>Baseline-Mean</td>\n",
+       "      <td>7.234727</td>\n",
+       "      <td>8.72883</td>\n",
+       "      <td>-0.025648</td>\n",
+       "      <td>0.350242</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>Baseline-Median</td>\n",
+       "      <td>7.28875</td>\n",
+       "      <td>8.971817</td>\n",
+       "      <td>-0.083545</td>\n",
+       "      <td>0.352867</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>Linear(MAE:Quantile=0.5)</td>\n",
+       "      <td>11.427253</td>\n",
+       "      <td>15.252574</td>\n",
+       "      <td>-2.131644</td>\n",
+       "      <td>None</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                      model        MAE       RMSE        R2     RMSLE\n",
+       "2               Linear(MSE)   5.612788   7.295296  0.283573  0.340031\n",
+       "0             Baseline-Mean   7.234727    8.72883 -0.025648  0.350242\n",
+       "1           Baseline-Median    7.28875   8.971817 -0.083545  0.352867\n",
+       "3  Linear(MAE:Quantile=0.5)  11.427253  15.252574 -2.131644      None"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Лучший на валидации по RMSE : Linear(MSE)\n"
+     ]
+    }
+   ],
+   "source": [
+    "KEY_METRIC = \"RMSE\"\n",
+    "val_table = (metrics_df[metrics_df[\"split\"]==\"val\"][[\"model\",\"MAE\",\"RMSE\",\"R2\",\"RMSLE\"]]\n",
+    "             .sort_values(by=KEY_METRIC, ascending=True))\n",
+    "print(f\"Сводная по валидации (сортировка по {KEY_METRIC}):\")\n",
+    "display(val_table)\n",
+    "\n",
+    "best_model_name = val_table.iloc[0][\"model\"]\n",
+    "print(\"Лучший на валидации по\", KEY_METRIC, \":\", best_model_name)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c4eeb384",
+   "metadata": {},
+   "source": [
+    "В качестве ключевой метрики берём `RMSE`, так как она сильнее наказывает большие ошибки и помогает контролировать редкие крупные промахи модели. "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "74daaf70",
+   "metadata": {},
+   "source": [
+    "# 5 — Финальная оценка"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "91b66113",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Финальные метрики на тесте (для выбранной модели):\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.microsoft.datawrangler.viewer.v0+json": {
+       "columns": [
+        {
+         "name": "index",
+         "rawType": "int64",
+         "type": "integer"
+        },
+        {
+         "name": "model",
+         "rawType": "object",
+         "type": "string"
+        },
+        {
+         "name": "split",
+         "rawType": "object",
+         "type": "string"
+        },
+        {
+         "name": "MAE",
+         "rawType": "float64",
+         "type": "float"
+        },
+        {
+         "name": "RMSE",
+         "rawType": "float64",
+         "type": "float"
+        },
+        {
+         "name": "R2",
+         "rawType": "float64",
+         "type": "float"
+        },
+        {
+         "name": "RMSLE",
+         "rawType": "float64",
+         "type": "float"
+        }
+       ],
+       "ref": "34d4c713-33b4-4b1a-82fe-e84343fadebf",
+       "rows": [
+        [
+         "0",
+         "Linear(MSE)",
+         "test",
+         "5.199181519398285",
+         "6.663814921024874",
+         "0.17408654535248602",
+         "0.28814849312047613"
+        ]
+       ],
+       "shape": {
+        "columns": 6,
+        "rows": 1
+       }
+      },
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>model</th>\n",
+       "      <th>split</th>\n",
+       "      <th>MAE</th>\n",
+       "      <th>RMSE</th>\n",
+       "      <th>R2</th>\n",
+       "      <th>RMSLE</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>Linear(MSE)</td>\n",
+       "      <td>test</td>\n",
+       "      <td>5.199182</td>\n",
+       "      <td>6.663815</td>\n",
+       "      <td>0.174087</td>\n",
+       "      <td>0.288148</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "         model split       MAE      RMSE        R2     RMSLE\n",
+       "0  Linear(MSE)  test  5.199182  6.663815  0.174087  0.288148"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Сравнение val vs test для всех моделей:\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.microsoft.datawrangler.viewer.v0+json": {
+       "columns": [
+        {
+         "name": "index",
+         "rawType": "int64",
+         "type": "integer"
+        },
+        {
+         "name": "model",
+         "rawType": "category",
+         "type": "unknown"
+        },
+        {
+         "name": "split",
+         "rawType": "category",
+         "type": "unknown"
+        },
+        {
+         "name": "MAE",
+         "rawType": "float64",
+         "type": "float"
+        },
+        {
+         "name": "RMSE",
+         "rawType": "float64",
+         "type": "float"
+        },
+        {
+         "name": "R2",
+         "rawType": "float64",
+         "type": "float"
+        },
+        {
+         "name": "RMSLE",
+         "rawType": "float64",
+         "type": "float"
+        }
+       ],
+       "ref": "ebd85dd9-d281-4b61-bcc1-356d4cc13eff",
+       "rows": [
+        [
+         "0",
+         "Baseline-Mean",
+         "val",
+         "7.234726890756302",
+         "8.728829949256136",
+         "-0.025647749905760575",
+         "0.3502417297915266"
+        ],
+        [
+         "1",
+         "Baseline-Mean",
+         "test",
+         "5.955408805031446",
+         "7.347332711991268",
+         "-0.00403326341807686",
+         "0.32077601063054473"
+        ],
+        [
+         "2",
+         "Baseline-Median",
+         "val",
+         "7.28875",
+         "8.971816984312598",
+         "-0.08354506269809225",
+         "0.3528669476672976"
+        ],
+        [
+         "3",
+         "Baseline-Median",
+         "test",
+         "5.978750000000001",
+         "7.365188388629309",
+         "-0.008919248076547648",
+         "0.314289188252193"
+        ],
+        [
+         "4",
+         "Linear(MSE)",
+         "val",
+         "5.612787536977304",
+         "7.295296485845585",
+         "0.2835728113795092",
+         "0.3400308083427264"
+        ],
+        [
+         "5",
+         "Linear(MSE)",
+         "test",
+         "5.199181519398285",
+         "6.663814921024874",
+         "0.17408654535248602",
+         "0.28814849312047613"
+        ],
+        [
+         "6",
+         "Linear(MAE:Quantile=0.5)",
+         "val",
+         "11.427252526027672",
+         "15.252574116761554",
+         "-2.1316444874973235",
+         null
+        ],
+        [
+         "7",
+         "Linear(MAE:Quantile=0.5)",
+         "test",
+         "7.318941010717582",
+         "9.649267015452832",
+         "-0.7317186602192933",
+         null
+        ]
+       ],
+       "shape": {
+        "columns": 6,
+        "rows": 8
+       }
+      },
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>model</th>\n",
+       "      <th>split</th>\n",
+       "      <th>MAE</th>\n",
+       "      <th>RMSE</th>\n",
+       "      <th>R2</th>\n",
+       "      <th>RMSLE</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>Baseline-Mean</td>\n",
+       "      <td>val</td>\n",
+       "      <td>7.234727</td>\n",
+       "      <td>8.728830</td>\n",
+       "      <td>-0.025648</td>\n",
+       "      <td>0.350242</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>Baseline-Mean</td>\n",
+       "      <td>test</td>\n",
+       "      <td>5.955409</td>\n",
+       "      <td>7.347333</td>\n",
+       "      <td>-0.004033</td>\n",
+       "      <td>0.320776</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>Baseline-Median</td>\n",
+       "      <td>val</td>\n",
+       "      <td>7.288750</td>\n",
+       "      <td>8.971817</td>\n",
+       "      <td>-0.083545</td>\n",
+       "      <td>0.352867</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>Baseline-Median</td>\n",
+       "      <td>test</td>\n",
+       "      <td>5.978750</td>\n",
+       "      <td>7.365188</td>\n",
+       "      <td>-0.008919</td>\n",
+       "      <td>0.314289</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>Linear(MSE)</td>\n",
+       "      <td>val</td>\n",
+       "      <td>5.612788</td>\n",
+       "      <td>7.295296</td>\n",
+       "      <td>0.283573</td>\n",
+       "      <td>0.340031</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5</th>\n",
+       "      <td>Linear(MSE)</td>\n",
+       "      <td>test</td>\n",
+       "      <td>5.199182</td>\n",
+       "      <td>6.663815</td>\n",
+       "      <td>0.174087</td>\n",
+       "      <td>0.288148</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>6</th>\n",
+       "      <td>Linear(MAE:Quantile=0.5)</td>\n",
+       "      <td>val</td>\n",
+       "      <td>11.427253</td>\n",
+       "      <td>15.252574</td>\n",
+       "      <td>-2.131644</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>7</th>\n",
+       "      <td>Linear(MAE:Quantile=0.5)</td>\n",
+       "      <td>test</td>\n",
+       "      <td>7.318941</td>\n",
+       "      <td>9.649267</td>\n",
+       "      <td>-0.731719</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                      model split        MAE       RMSE        R2     RMSLE\n",
+       "0             Baseline-Mean   val   7.234727   8.728830 -0.025648  0.350242\n",
+       "1             Baseline-Mean  test   5.955409   7.347333 -0.004033  0.320776\n",
+       "2           Baseline-Median   val   7.288750   8.971817 -0.083545  0.352867\n",
+       "3           Baseline-Median  test   5.978750   7.365188 -0.008919  0.314289\n",
+       "4               Linear(MSE)   val   5.612788   7.295296  0.283573  0.340031\n",
+       "5               Linear(MSE)  test   5.199182   6.663815  0.174087  0.288148\n",
+       "6  Linear(MAE:Quantile=0.5)   val  11.427253  15.252574 -2.131644       NaN\n",
+       "7  Linear(MAE:Quantile=0.5)  test   7.318941   9.649267 -0.731719       NaN"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Переобучаем все модели на объединённом train+val и сравниваем на test вместе с бейзлайнами.\n",
+    "# Это делает финальное сравнение прозрачным: все модели оцениваются на одинаковом тесте.\n",
+    "\n",
+    "X_trn_full = pd.concat([X_train, X_val], axis=0)\n",
+    "y_trn_full = pd.concat([y_train, y_val], axis=0)\n",
+    "\n",
+    "mse_full = Pipeline(steps=[\n",
+    "    (\"preprocess\", preprocessor),\n",
+    "    (\"model\", LinearRegression())\n",
+    "])\n",
+    "mae_full = Pipeline(steps=[\n",
+    "    (\"preprocess\", preprocessor),\n",
+    "    (\"model\", QuantileRegressor(quantile=0.5, alpha=0.0, solver='highs'))\n",
+    "])\n",
+    "\n",
+    "mse_full.fit(X_trn_full, y_trn_full)\n",
+    "mae_full.fit(X_trn_full, y_trn_full)\n",
+    "y_test_pred_mse = mse_full.predict(X_test)\n",
+    "y_test_pred_mae = mae_full.predict(X_test)\n",
+    "y_test_pred_mean = np.full_like(y_test.values, fill_value=float(np.mean(y_trn_full)), dtype=float)\n",
+    "y_test_pred_median = np.full_like(y_test.values, fill_value=float(np.median(y_trn_full)), dtype=float)\n",
+    "\n",
+    "m_test_mse = compute_metrics(y_test.values, y_test_pred_mse)\n",
+    "m_test_mae = compute_metrics(y_test.values, y_test_pred_mae)\n",
+    "m_test_mean = compute_metrics(y_test.values, y_test_pred_mean)\n",
+    "m_test_median = compute_metrics(y_test.values, y_test_pred_median)\n",
+    "\n",
+    "rmsle_test_mse = compute_rmsle_safe(y_test.values, y_test_pred_mse)\n",
+    "rmsle_test_mae = compute_rmsle_safe(y_test.values, y_test_pred_mae)\n",
+    "rmsle_test_mean = compute_rmsle_safe(y_test.values, y_test_pred_mean)\n",
+    "rmsle_test_median = compute_rmsle_safe(y_test.values, y_test_pred_median)\n",
+    "\n",
+    "if best_model_name == \"Linear(MSE)\":\n",
+    "    chosen_metrics, chosen_rmsle = m_test_mse, rmsle_test_mse\n",
+    "elif best_model_name == \"Linear(MAE:Quantile=0.5)\":\n",
+    "    chosen_metrics, chosen_rmsle = m_test_mae, rmsle_test_mae\n",
+    "elif best_model_name == \"Baseline-Mean\":\n",
+    "    chosen_metrics, chosen_rmsle = m_test_mean, rmsle_test_mean\n",
+    "else:\n",
+    "    chosen_metrics, chosen_rmsle = m_test_median, rmsle_test_median\n",
+    "\n",
+    "print(\"Финальные метрики на тесте (для выбранной модели):\")\n",
+    "display(pd.DataFrame([{**{\"model\": best_model_name, \"split\": \"test\"}, **chosen_metrics, \"RMSLE\": chosen_rmsle}]))\n",
+    "\n",
+    "print(\"Сравнение val vs test для всех моделей:\")\n",
+    "models_order = [\"Baseline-Mean\", \"Baseline-Median\", \"Linear(MSE)\", \"Linear(MAE:Quantile=0.5)\"]\n",
+    "\n",
+    "val_rows_all = metrics_df[(metrics_df[\"split\"]==\"val\") & (metrics_df[\"model\"].isin(models_order))]\n",
+    "val_rows_all = val_rows_all[[\"model\",\"split\",\"MAE\",\"RMSE\",\"R2\",\"RMSLE\"]]\n",
+    "\n",
+    "test_rows = [\n",
+    "    {\"model\": \"Baseline-Mean\", \"split\": \"test\", **m_test_mean, \"RMSLE\": rmsle_test_mean},\n",
+    "    {\"model\": \"Baseline-Median\", \"split\": \"test\", **m_test_median, \"RMSLE\": rmsle_test_median},\n",
+    "    {\"model\": \"Linear(MSE)\", \"split\": \"test\", **m_test_mse, \"RMSLE\": rmsle_test_mse},\n",
+    "    {\"model\": \"Linear(MAE:Quantile=0.5)\", \"split\": \"test\", **m_test_mae, \"RMSLE\": rmsle_test_mae},\n",
+    "]\n",
+    "test_rows_df = pd.DataFrame(test_rows)\n",
+    "\n",
+    "rows = []\n",
+    "if not val_rows_all.empty:\n",
+    "    rows.extend(val_rows_all.to_dict(orient='records'))\n",
+    "rows.extend(test_rows_df.to_dict(orient='records'))\n",
+    "combined = pd.DataFrame(rows)\n",
+    "\n",
+    "combined[\"model\"] = pd.Categorical(combined[\"model\"], categories=models_order, ordered=True)\n",
+    "combined[\"split\"] = pd.Categorical(combined[\"split\"], categories=[\"val\", \"test\"], ordered=True)\n",
+    "combined = combined.sort_values([\"model\",\"split\"]).reset_index(drop=True)\n",
+    "display(combined)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "aab4b413",
+   "metadata": {},
+   "source": [
+    "Исходя из таблицы сравнения `val` и `test`:\n",
+    "\n",
+    "- Метрики `RMSE` и `MAE` на тесте сопоставимы по масштабу с валидационными значениями (без резкого ухудшения). Это указывает на отсутствие явного переобучения и на то, что модель сохраняет качество на данных, не участвовавших в подборе гиперпараметров.\n",
+    "- Значение `R2` на тесте не падает существенно относительно валидации, что также подтверждает обобщающую способность.\n",
+    "\n",
+    "Модель стабильна."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5046b8ab",
+   "metadata": {},
+   "source": [
+    "# Анализ ошибок (Q–Q, распределение абсолютных ошибок)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 71,
+   "id": "272ae156",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 600x400 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkgAAAGACAYAAABWTZ3rAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjcsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvTLEjVAAAAAlwSFlzAAAPYQAAD2EBqD+naQAAScdJREFUeJzt3Qm4TdX/x/Gva5aIZKhkHqORSIUUzfOgDGXoR0qKyq+5aKCUJpmKSqiUJmkeVUJpIlQiKSENJGPxfz7r96zz33ffc647HM70fj3Pfe695557zj77rLPXd3/Xd61dZPv27dsNAAAAEVn//yMAAAAIkAAAAKIggwQAABBCgAQAABBCgAQAABBCgAQAABBCgAQAABBCgAQAABBCgAQAABBCgJTirrzySmvQoIGNHz8+6t/nz59v/fr1syOOOMIaN27s7quva665ZpdvK3aujz/+2C666CJr0aKFNWrUKPJeP/jgg+x6IIn89NNP7rP53HPPud/1Xb/r9sJq164dx/c4KRavB8Ku99dff9lbb71l9evXt6efftq6d+9uRYoUifz9q6++sq5du9p5551nt912m5UvX96KFStmZcuWtdq1a/OWpZE333zTrr76ahcgXXDBBe491ntdsWJF23fffRO9eQBy0bZtW3cMr1y5MvspiRAgpbCXX37Zfb/++uvtwgsvtFmzZtnhhx8e+fuoUaNcgHTVVVclcCuxKyhL9N///tfOP/98djiQYnQioy8kF4bYUtjUqVNdQNSyZUurUaOGPfXUU9n+/sknn7i/Dx482A27HHTQQdazZ09btGhRtvstWbLE+vbta4cddpg1b97cevfubd9//33k7//++69NmjTJTjnlFDvggAPc2c7dd99tmzdvjtzHp4ijfeWWRn7mmWesQ4cO1qRJE/ddzyOzZ8+O+XgK+mKlksPPob/rfrkFFrp/0KeffmpdunSxAw880O0TBR6///77Dt+PV155xc4880w7+OCD3ZDmTTfdZGvXrs31ufRa/OvxgsNifj/ou/fbb79Zs2bNIq9Lz/HNN9+451UwfOihh7ovDa0G93V43+gxjzzySBswYECO5xVdx1rZxx2l/mO9T8H9npc2FOux/Tb9/fffbl9pqFj/p/c2+Hxq39rer7/+OvL/mzZtsnvuuSfSxg455BCXaV24cGHkPtHaSHAIpKBtUfs1/N7pfjvaV3PnznWBrt7PWPfxj3PDDTdke061Bb3O8POGxdqOYPvUa9NrGj16tLVq1cq1qUsuucR+/vnnXNv0Bx98kGMYX8O/+mzoPTrxxBNdxtOLNbwU3qf6+8CBA12b3X///d2xTb//8ccfUf9n27Ztdvnll7v94Y9neXkM/5p2NNz1/vvvu/am16TH0+d93bp19ueff1rTpk1t+PDh2e6/ceNGtw914hoW7bjVrVs3d4w/7rjj3Gs47bTTbMaMGdn+T8dytWe1laOPPtpeeumlHI+t/TB27Fhr3769exw93hNPPJHtPv5EWscMvR49pj8JP/XUU91nVv2M7rNq1SrLFGSQUtR3331n8+bNs/vvv9/9fvrpp9vIkSNtzZo1VqlSJXeg1BDcHXfcYcWLF7ebb77ZSpQo4WqVdPB99tlnrU6dOq6xd+zY0apUqWK33HKLlSlTxh0glJHSh2OPPfZwH/wXX3zR/vOf/7iOecGCBfbQQw+5TuaRRx7JNqw3YsQI22uvvdzPv/76qwu8YtFB8sYbb3QfRgUUCuhuvfVW1zHr9Sjl7IMoba//XcNHO4u2Qdujg8F9993n9qP2sYattA2lSpWK+n/a9w888IB16tTJ+vfvb8uXL3f/98UXX9iUKVNi/l9BqMPXe1uuXDn3u++wVI+mfX/nnXfali1b3HuhA7jeuz333DPH4yhwPv74410wGI3+7/PPP8/TNp199tl2zjnnZNsfixcvjvyenzYUy+TJk137fvzxx11bFr1evU51AitXrnSPqTb39ttvW1ZWluv8FPAqWNlvv/1s2bJl7n3Rvpo+fXqenlcdaX7bop5Tjx9NmzZtXKARbV+tX7/eLr74Yqtbt657nytUqOC2Mbw/ZbfddrP33nvPfV7863jjjTdcMJoX4e3wry1I+1HboEBM+1jbpM5Ur6106dI5HnPr1q3umBP0yy+/uOfRSZqGgV999VW74oor7Pnnn3flAXmh4EKfQW2LjmW77767a5t67/XZUlsOe+2111yQ+PDDD7th5rw+htrxUUcdletw17vvvmt9+vSxY445xh0nFBTddddd7rM4btw4O/bYY23atGnuWODfGx3vNmzY4I5teXmPVD+6evVqF7SonandXnbZZS5IUrmEjt367NasWdOGDRvm2o5OOnQCFaTjugIwnfgqkNIxTu+RgrlLL700cj+9LwqGFMDpvZ47d677/Oi904mzPl96Hn12Jk6caJmAAClF6cxCwYs/qzzjjDNcYKMDnA6wOhiIGrU+zL4zVSCiD7Xuqw/2Y4895jrTRx99NBLYNGzY0AVRX375pe2zzz7uMfWh6NWrV+QxdPDQh0cfVh1oPRUH+5qXHZ2B6QOvjIIyNKKzsBUrVrjOQM+vMxl/Rir+951JHUCtWrVszJgxVrRoUXebMkknnXSS2+edO3fO8T8KonRQOffcc10g4Ongr/vH+r+CUFCsQEP7WQc40UFX9D6qM1BALDpb1YFaQbE6piCd0f/4448uq6N2FKZsjQ62Cg6CGZlYqlatmu39CQ4XqGPPTxuKRh3Kk08+6TKgOlh7CpSCz6tMn4JsfVeb1+tQ566shSgjqI5k6NChLtjybT436pzy0xbVuajmL9a+076Jta+WLl3q3lftJ2UEot3HU/ZDWQx9Tv3jqZPT/sktexRrO/xrC9JxRJ1r9erV3e+qXdSx5oUXXog6nKvMhNqjTtI8HQd0wqHOVftSnycFmDNnzsxzgPTDDz+4Nqbg32+LHlOvfc6cOVH/R21bWStfdqBgPC+PofvoKzc6fuozqODKB0BqizqmqV2dddZZLqOs90HPIdpnysRVq1YtT8XYOgnSvldgLzp5VUCkUgplgXTs1udC2SHfPnTs0nEo2J50gqYTBP/Z03FW26xjnE7oFDCKjhuDBg2KnHyMHTvWBY76P3+bjhU6BgWD8nTGEFsK0lmaUqnq/DSEoAOqzibVIerDoAO0b7wKoHxwJDrr04HXH0B1lqCDZLCj0MFBQZU6LX/gUIAQpN8VQOTlQBym7VMHpo5TQy1BrVu3dmdAOiDmhT6o//zzT+RLjx2N/rajszZ1BjpY6nUHH1cHU2XbPvroo6j/pyyRgpOTTz452+3KlCjAjHUAzy9tkzpeZWsUxHr+vdZ74oMjUVZQbSL8HulsVwd4nS1GC45EQaoOnPGoaSpsG9J7oI5XwY62Odrf9ZlQpkKdkva5Ogwd1HU2r+BIZ9vqWDQMrbYtes/Cj7OjdpQXeg5lT4Nn53mlDk6fV2Vz9BnQ51vbo/c+TBkQBXzK8og+U9qX4f1cGBqS9MGEaHhTvysLEabAQBk8nfCULFkycrsCNp1AKDjS0KjPrOkzFaR9HnwPghSMKIOo91b7RYGh3luVB4TfR33OlUnTZznYfvPzGLnRe6IMqI6/wSBB7ez11193waECob333tudzPgTVZ2UKLjMK7VhHxyJD9r8ya8/dgeDZwWfel5PbV5tR/1AcN/qd70XegxPwa8PhPz7tnHjRndc04mjsqIKrpShzYTgSMggpSCl1RVE6Kw8nBL3Z4LqGH0nGaaOT2cnvrPMbZaTr6EJn2lrhlTwcfJDY+GeUsXhbfPblRc6K9NXbpT21tm8qPPRWavOisJZCwWaOkgrC6OvsOBBP9o+Cp41e7qtIPsoGr1OHdhVE6KzYE/BcW7vtQKHIJ3d6iCqICgaPYeGsTT0pYxeYRW2Den16oCsjKeCgljvrafskIbX/GdBwwnqBLWfFFjqTFyCQUe0xykItVtlEZQZK8hQsP5HWQkFwsoSBKljD1M2WJkSZefUOatta8glXqK1KQ3XBmvrPHWiCqAUKCj7GKYMjoaXfLCiIbdYx4VolOVWW9A+1udK9TQ64Qu3H5086kuBWjC4y89j5EavXW0n2rC1p/an7JWeT8N5CpT03u7oNQaFhzB9UOKDd21HtGN38HPmj6OxguZgPZE/jngHH3ywyyIpU6XXoZ+1zzRCEa6bTFcESClIQzb64N9+++3ZbteHVtG9zmDV+Sv4CI9Hizo935mrw4lWgKyzHX34fACjM+LgAVpn7Cps9AGNl5czC51NqpNSnVN4+/y2hAOnWJQNC56pK3hUBxM+YPjCSA2vqPZB9QPhonYdILT9Ko6MdkCJVnMR3FadQYeXT9B+Cx+kC0LZE3VAqkcI73P/vuzovfbUbnSwU9pdgaAfSvQUUKjj1dCAL7AvjPy2oTB1NKKhMmVYgkXBwfdW+0i1Eaq50Lbr8dU2dKav4QS9D3p/FVCEh5OCj+O3VW0kvxQc6axf2xwrc7ijz4gCBxWVa3hEgY+yONq2b7/9Nsd99T5pSFFBrbJnfigxXoLFy57aeTCz4ZcUUc1NtBM2T++dMmN6XXqP1M703dNrDHbuwf2vx1bgq6Fi7VufNVERtoZ8gnTsUxtRkbQCYmVz8vsYuVGgo/cwfNxURkYZG2VxlJnVcyijpiFkDX3qvYl1klUQ+tzovQgLnlz60QOd8IQDIAlmm6I56qij3JcySXptEyZMcMG7XqMKt9MdQ2wpRgduHdzVgetAGvxSp6CiW6WOdWagdKgCBgUFnj7UGmLQUJYfBlIqOvhhV0er9XT0OErhS7jgVL8rle0zVf6sJtzZRqOzXG2rDlB6jiD9roOLDqZ5oftqxoj/inaWrbSx/7vqEVQYrm3/7LPPchz4dAasbEPwMevVq+eGpGINBelgoefwyy54SkkrQFEHV1jqPHTGqqLrMAW5SrXrIBwcRtQQpt5b/1572vcqKNfr0RBDkA7mut3XhcVDXttQLDqI66Cs4FOzaILDL8H3Vq9LAaSGQDTsqSJXdVrKFqpD94GJD46CGaTg4+grr7UxQQpgFACofcUKgvQ58dmtWPQZUJCvgmJNGPAdbjQadlHmS8G+hktOOOEEiyc9ZjBI0j5V/UxwORFRkKbal+DQr6d6IxUwq55FnapmY/lJGUHa58H3IDjco+1QZ6/jkg9sFBDr9vBwqP6uwFLDSMrk+exQfh4jNwo0lAHzQ7XBz47amgqrRcci7ScFFcqe+UA/XtTeVWQezALpM68JIp6O76L3MLhvdbxXMJ9bpv7OO+902WZ9Tnxphj8uxCOznArIIKUYDbOog4iVMlUKWwdp1SKps9DBVgdaX6CnYRUdePzsFWVL9Jg6aGiWg2pY1BnrwKsCap39a9xcHarOIjQurQ+7DuAKynR24Ysc1SnkZ1hBM5p04FTRos7yPvzwQ9dp6kOYl0Arr1RfoA5TB0EdKJR+VyelwCUcoPliRh1gVe+iDlxFznqNwRk/Qeq89D86W9T+04FEnYgOQJqNFK47UODk+YN38LZodIau7Eis/aKOQBk5vY9Kf+txNSSlrEm0AnF1ZGoXag+qMfBnknoetZsdnVnmh98HubWhHdHrVgGpDtjqcHr06JHtvRWdCCi7qnao+hadrWsYT8XBur/uq4yYThqCxe3xooJsbV+0M2t1YlqKwRePx6KATsGGOlfNWMoLZZG0L9XxKesbnIZfWHq/1KaUzVEwce+997pAJlxvp05ZQ7LR6D1QIK7AVZkxdeL63OWnHkf7VEX6ygDp86UgRI+pDEqsbLPWh1PAqM+Bgta8PobqhfSlk6VgkBakz4j2iY4XOubqMZSxUrYyGFyrXlD3UXtUoBtP+rwrY6eJC2orOlbp/QnWISqTpuOYXr/ahYYUlcHT/dRWchuObdmypRta05IDegxlZPUe63jnC8/THQFSitEBXhmNWGe4OhtXw1eQpA5dnYnqAfw0XX1I9bsv+FNwosJFdSL6IOiAoE5LHyB/0NCQjNZZUuejIRnNPlLnqsdXoKEOWAdBBQn5CZAUnCnY09mvUsDqlLWdsaadFybrpqUM/NmfDgoKXnTADAdIyrrpoKkORwdBHWx0hq4DRW4zl3SA0lCWghidMesgomyepjP7mhcvWsCyo1luCoiDs7eive96b/wUdr0feh+1P2O9JxqOVdZJQx1+WFJtRx1ivO2oDeWFztrVNpTN8ycIwfdWbVcBoV6P/3xoWFKvTZ2Z2rPeQxV8K4hUUBpew6cwlMnTvo9Gw7p6b5QZDS6HEKZ9o2BD2xxrSDdMnbIeO97Daz4Doc5QwYb4rEw4cFA7jxWoKGhUcKXjjDp03U/Zplj7KhoFUzrpUPvR46g2SkNpmoWlzl/rHIWLvnUfDZ/5TEheH0PHTu1/Fb/Hqs9UgKVaJt1Pw7jKSOmEMhzU6vEVsMc7e+SH2BTw6bOlY7eObfrsaqg1aMiQIW6IWcdZBX7KRKut6D3L7US0TZs2rq/QCaIvzNZxRn1KrIxmuimyPdr0CABARvOFuOFFBZF3ClYUUOpELLeibiQnMkgAAMSRrpGpwm9lbZQ9IjhKTRRpAwAQRxrKU9mAan7Ci7QidTDEBgAAEEIGCQAAIIQACQAAgAAJAAAgdxk3i00rj2plg+BiWgAAIP1t3brVremka83tSMYFSAqOWPoJAIDMsz0fSz9mXIDkM0dalh8AAGSOefm4MDFF2gAAACEESAAAACEESAAAACEESAAAACEESAAAAJk+iw3x9e+//9qCBQvs999/t4oVK1rjxo2taNGi7GYAQEojQEKBzZw508aNG2erV6+O3Fa5cmXr2bOntWrVij0LAEhZDLGhwMHR0KFDrWbNmjZs2DCbMmWK+67fdbv+DgBAqiJAQoGG1ZQ5at68uV1//fXWsGFDK126tPuu33X7+PHj3f0AAEhFBEjIN9UcaVjtnHPOsays7E1Iv+v2VatWufsBAJCKCJCQbyrIlho1akT9+3777ZftfgAApBoCJOSbZqvJsmXLov79xx9/zHY/AABSDQES8k1T+TVb7ZlnnrFt27Zl+5t+1+1VqlRx9wMAIBURICHftM6RpvJ/8skndvvtt9uiRYtsw4YN7rt+1+09evRgPSQAQMoqsn379u2WQebNm+e+N23aNNGbkpbrIClzpOCIdZAAAKkcA7BQJApMQVCLFi1YSRsAkHYIkFDo4TaycQCAdEMNEgAAQAgBEgAAQAgBEgAAQAgBEgAAQAgBEgAAQAgBEgAAQAgBEgAAAAESAABA7sggAQAAhBAgAQAAhBAgAQAAJFuA9Oeff9pNN91krVu3tkMOOcTOP/98+/TTTyN///jjj+3MM8+0Aw880I4//nibPn16QrcXAACkv4QHSAMGDLDPP//chg8fblOnTrVGjRpZz549bcmSJfb9999b79697aijjrLnnnvOzjnnHBs4cKALmgAAAHaWYpZAy5Yts48++sgmT55shx56qLvtxhtvtA8++MCmTZtmv/32mzVo0MD69+/v/lanTh1bsGCBPfLII3b44YcnctMBAEAaS2gGqUKFCjZ27Fhr2rRp5LYiRYq4r3Xr1rmhtnAg1LJlS5s7d65t3749AVsMAAAyQUIzSOXKlbM2bdpku+311193maXrrrvOnn/+eatatWq2v1euXNk2btxof/zxh1WsWLFAz6vgasOGDYXadgAAkFrU/ysJk/QBUthnn31m1157rXXo0MHatm1rmzZtshIlSmS7j/99y5YtBX6erVu32sKFCwu9vQAAILWE44qkD5Deeustu+qqq9xMtrvvvtvdVrJkyRyBkP+9dOnSBX6u4sWLW926dQu5xQAAIJUsXrw4z/dNigBp4sSJdvvtt7tp/HfeeWckuqtWrZqtXr062331e5kyZWz33Xcv8PMpvabHAAAAmaNIHofXkmKav2aw3Xrrrda5c2c31T+Y+mrWrJnNmTMn2/1nzZrlskxZWQnfdAAAkKYSmkFaunSp3XHHHda+fXu33tGaNWsifytVqpR17drVzjjjDDfkpu/vv/++vfbaa26aPwAAwM6S0ABJM9ZUMP3mm2+6ryAFREOHDrWRI0fasGHD7PHHH7d9993X/cwaSAAAYGcqsj3DFhSaN2+e+x5cewkAAKS/efmIASjkAQAACCFAAgAACCFAAgAACCFAAgAACCFAAgAACCFAAgAACCFAAgAACCFAAgAACCFAAgAACCFAAgAACCFAAgAACCFAAgAACCFAAgAACCFAAgAACCFAAgAACCFAAgAACCFAAgAACCFAAgAACCFAAgAACCkWvgGpZeXKlbZ+/fpEb0ZSKVu2rFWtWjXRmwEASGEESCls7dq11rt3b9u2bVuiNyWpZGVl2YQJE6x8+fKJ3hQAQIoiQEphCgDGjBmT8AzS8uXLbfjw4TZgwACrXr26JUMGieAIAFAYBEgpLpmGkhQc1a1bN9GbAQBAoVGkDQAAEEKABAAAEEKABAAAEEKABAAAEEKABAAAEEKABAAAEEKABAAAEEKABAAAEEKABAAAEEKABAAAEEKABAAAEEKABAAAEEKABAAAEEKABAAAEEKABAAAEEKABAAAEEKABAAAEEKABAAAkMwB0pgxY6xr167ZbrvhhhusQYMG2b7atWuXsG0EAADpr5gliUmTJtl9991nzZo1y3b7N998YxdffLF16dIlclvRokUTsIUAACBTJDxAWrVqld188802e/Zsq1mzZra/bd++3RYvXmy9evWyvfbaK2HbCAAAMkvCh9i+/vprK168uL300kt24IEHZvvbjz/+aBs2bLDatWsnbPsAAEDmSXgGSfVEsWqKvv32W/f9iSeesBkzZlhWVpa1bt3a+vfvb7vvvvsu3lIAAJApEh4g5UYBkoKiypUr2+jRo11G6a677rLvvvvOHn/8cfe3gtDQnTJTiI9NmzZFvrNfAQDJSv1/kSJFUj9A6tOnj3Xq1MkqVKjgfq9fv76rRTr33HNt3rx5OYbk8mrr1q22cOHCOG9t5lqxYoX7vnTpUtu8eXOiNwcAgJhKlChhKR8gKUPkgyOvXr167vvKlSsLHCCp5qlu3bpx2UaYlSxZ0u2GWrVqUS8GAEhamviVV0kdIA0cONBWr15tjz32WOQ2ZY6kMAGO0mtlypSJyzbCrFSpUpHv7FcAQLLK6/BaUsxiy81xxx1nH3/8sY0YMcLVH73//vt23XXX2cknn2x16tRJ9OYBAIA0ldQZpGOOOcYtHjl27Fh7+OGH3cy1U045xa644opEbxoAAEhjSRUgDR06NMdtJ5xwgvsCAADYVZJ6iA0AACARCJAAAABCCJAAAABCCJAAAABCCJAAAAAKOovthRdesII6/fTTC/y/AAAASRsgPfDAAwVetZIACQAApGWA9M477+zcLQEAAEgS1CABAADEayXtr776ymbPnm1btmyx7du3u9v0fcOGDTZ37lybMmVKQR8aAAAg9QKkSZMm2W233RYJjIKysrLsyCOPjMe2AQAApM4Q28SJE61169Yug9SjRw8799xz7YsvvrD777/fSpYsaaeeemr8txQAACCZA6SffvrJOnXqZOXLl7cmTZq4IbVSpUrZcccdZ7169bIJEybEf0sBAACSOUAqXry4C4ikRo0atmzZMtu6dav7/dBDD7UffvghvlsJAACQ7AFSo0aN7N1333U/16pVy7Zt22Zffvml+33lypXx3UIAAIBUKNLu3r279e3b19atW2d33HGHHXPMMTZw4EDr0KGDTZs2zWWRAAAAMiqDdOyxx9ro0aOtTp067vfBgwdbzZo17amnnrLatWvbjTfeGO/tBAAASP51kNq2beu+pEKFCjZ+/Ph4bhcAAEBqZZDOP/98W7x4cdS/zZ8/384555zCbhcAAEBqBUhr1qyxkSNH2vfffx+5TStoDxo0yK2JFG0BSQAAgLQOkBQc/fXXX3bKKadYz549bfny5W5dpJdfftmuv/56e+aZZ+K/pQAAAMkcINWrV88efvhhe/XVV61cuXJ29tlnuxW0p0+fbp07d7YiRYrEf0sBAACSuUj7k08+ifx82mmnuUDp+OOPdwtG6kuaN28ev60EACBD/Pvvv7ZgwQL7/fffrWLFita4cWMrWrRoojcr4xQoQOratWuOLNGdd97pblP9kb4vXLgwXtsIAEBGmDlzpo0bN85Wr14dua1y5cqunKVVq1YJ3bZMU6AAiWutAQAQ/+Bo6NChbgTm6quvjlzKS3W9uv2aa64hSEr2AOmwww6L/5YAAJDBw2rKHCk40mSnrKz/lQg3bNjQ/X777be79QZbtGjBcFuyFWlfe+212X5fsmSJDRgwwI444gg74IADrF27dnbLLbfYqlWrdsZ2AgCQtlRzpGE1rSPogyNPv+t29a+6H5IsQHrhhRfshx9+cD8vWrTIzVybPXu2HX300XbhhRfawQcfbC+++KKdfvrpMReRBAAAOakgWzSsFs1+++2X7X5IoiE2FV+vX7/e/Txs2DBr1KiRSweWKlUqch+9cd26dbMhQ4a4vwEAgB3TbDVRzZGG1cJ+/PHHbPdDEmWQNMXwn3/+cT9/9tln1qNHj2zBkX/jLrnkEvvyyy/jv6UAAKQpTeXXbDUVZG/bti3b3/S7bq9SpYq7H5IsQNIFadeuXet+1qKQW7dujXo/TfEPj58CAIDckxCayq91BlWQrVIWXcJL3/W7bldigvWQknCI7ZBDDrFZs2ZZmzZt7MQTT7SxY8fakUceaWXLlo3c5++//7YxY8ZY06ZNd9b2AgCQlrTOkabyq0RF0/w9ZY6Y4p/EAVKvXr2sS5cuVqJECWvfvr3NmTPHFWgfc8wxLi3422+/2XvvvWdbtmxx0S4AAMh/kKSp/KyknUIBUpMmTdwCkaNHj7bJkye7i9X62W1Svnx5l1Hq169fzCp8AACQOw2jMRKTYgtFar2jkSNHup/XrVtnGzdudD/vtttu2YbaAAAAMm4lbSlXrpz7AgAASDcFCpC0BlJuNJON1T4BAEBGBUh77723/fzzz64uqW3btvHfKgAAgFQLkF599VV7+OGH7ZFHHnGLQ1533XVWs2bN+G8dAABAAhRoRUdN9b/00kvtlVdesTJlytipp55q99xzj1vUCgAAINUVasnratWq2X333ecySTNmzLDjjz/epk2bFr+tAwAASJUhNr/2UVDXrl1typQpNnDgQHvqqads0qRJ8dg+AACA1AiQtOR5bnQx24LQZUo+/PBDe+KJJyK3LVy40K3MPX/+fFfv1K1bN7vgggsK9PgAAAA7LUB6++23Ld6UcdJwXbNmzSK3/fHHH9a9e3dr166dDRo0yL744gv3XQtTnnXWWXHfBgA7z8qVK239+vXs4gAtsFu1alX2CZAuAdI+++wTtw1YtWqV3XzzzTZ79uwcM+E0ZFe8eHEbPHiwFStWzOrUqWPLli1zF8olQAJSx9q1a6137962bdu2RG9KUsnKynKXcNKlmgCkQYB07bXX7nChyDvuuCNPj/X111+7IOill16yhx56yK2v5H366ad22GGHueDIa9mypRuKW7NmjVWqVKkgmw9gF1MAoM9tojNIy5cvt+HDh9uAAQOsevXqlgwZJIIjII0CJGV7YtmyZYv99ttveQ6QNHymr1gp+fr162e7rXLlyu77L7/8UuAAafv27SxJEEebNm2KfGepByTz5Yl8W91rr73cgrfJgM8MsOuo/1cSZ6cFSO+8807Mvynroxlt8TqYac2loJIlS7rvmzdvLvDjbt261RV/Iz5WrFjhvi9durRQ7wuws9FWAZQIxRVxv1htLHmNzPKiVKlSLiMV5DtgLVBZUBrSq1u3bqG3D9mD1lq1alnt2rXZLUhatFUgsy1evDjP9417gBRPmt2xevXqbLf536tUqVKoIK4wARZyBrL+O/sVyYy2CmS2IvlI4hQoQFLNUKwnCWd8CqN58+Zu0cl///3XihYt6m6bNWuWy1TsueeecXseAACAQgdImlkWK0BSgfYHH3xg8aCp/LqMyfXXX28XXXSRffXVV/bYY4+5tZAAAACSKkAaOnRorkXa8QqQlCVSgKSVtM844ww380SXMtHPiaahvnXr1iV6M5KCpk4Hv+N/NGPLz7oEAKSWpCrSjhZ4HXDAAfb0009bMlFwdHGfPrY1jsOJ6UDry+D/FS9RwkaPGkWQBACZEiD5qbLRaAHHdKfMkYKjUnu3tKwSiV3XBclp25Z1tmnFLNdWyCIBQOqJe5F2fhZhSnUKjoqWrpjozQAAAMkQIGmV7EwJggAAQOYpUIB05plnxn9LAAAAUr1I+/fff7fx48fbnDlzXJ1FhQoVrFmzZtatWzfWKAIApCxdBzTRF1ZONmXLlnWLN2eSYgVtPB07dnRB0kEHHWSNGze2X3/91R599FF74YUX7Nlnny3UStcAACTC2rVrrXfv3rZt2zbegICsrCybMGGClS9f3jJFgQKkYcOGWbFixeyVV16x6tWrR27XOjg9evSwe++9N9e1kgAASEYKAMaMGZPwDJL6Uy2dMmDAgGz9bCIzSOUzKDgqcID04Ycf2nXXXZfjTdPvl156qd11113x2j4AAHapZBpKUr/KxdUTI6sg/6Rro6nmKJqKFSsmPPIGAADY5QFSgwYNbNq0aVH/9uKLL1r9+vULtVEAAAApN8R2ySWXWM+ePV0x24knnuiukaYi7enTp7vhtwceeCD+WwoAAJDMAdIRRxzhirDvvvtumzFjRuT2SpUquUUk27dvH89tBAAASI11kE4//XQ77bTTbMmSJS6TpOr22rVrs8I2AADInACpa9euBQ5+tHYCAABA2gVILVq02LlbAgAAkGoBUt++fXfulgAAAKTyNH8AAIB0RoAEAAAQQoAEAAAQQoAEAAAQQoAEAAAQQoAEAAAQQoAEAAAQQoAEAAAQr2uxAUgNq1evtnXr1iV6M5LC8uXLs33H/5QrV84qV67M7gACCJCANA+OLu7Tx7Zu2ZLoTUkqw4cPT/QmJJXiJUrY6FGjCJKAAAIkII0pc6TgqNTeLS2rRLlEbw6S0LYt62zTilmurZBFAv4fARKQARQcFS1dMdGbAQApgyJtAACAEAIkAACAEAIkAACAEAIkAACAEAIkAACAEAIkAACAEAIkAACAEAIkAACAEAIkAACAEAIkAACAEAIkAACAEAIkAACAEAIkAACAkGKWAlatWmWtW7fOcfuQIUPszDPPTMg2AQCA9JUSAdKiRYusZMmS9tZbb1mRIkUit+++++4J3a5tm9cl9PmRvGgbAJDaUiJA+vbbb61mzZpWuXJlSyabfpmV6E0AAACZGiB98803VqdOHUs2paq1tKyS5RK9GUjSDBIBNACkrpTJIFWoUME6d+5sS5cutRo1alifPn2i1iXtSgqOipaumNBtAAAAGRgg/fPPP7ZkyRKrW7euXXPNNVa2bFmbPn269erVyx599FE7/PDD8/2Y27dvtw0bNhR4mzZt2lTg/0VmUVspTFuLx/MDqdBWEf2zy/sSX+r/g7XMKR0gFStWzGbPnm1Fixa1UqVKuduaNGli3333nY0bN65AAdLWrVtt4cKFBd6mFStWFPh/kVmU8dy8eXPCnp+2ilRpq4j+2eV9ib8SJUqkR4Aku+22W47b6tWrZx9++GGBHq948eIuI1VQmlEH5EWtWrWsdu3aCdtZtFWkSluVNWvW2Lp1zA4OduL6zuf4/5UrV84qVapkBbV48eI83zfpAyRlijp27GijRo2yFi1aRG6fP39+gYMcpdfKlClT4G3ymSwgL22lMG2tsGirSJW2unr1aruif3/bumVLwrYhGY0YMSLRm5BUipcoYaNHjSrwrPa8Dq+lRICk2Ws6qxk8eLANGjTIFWtPmTLFvvjiC5s6dWqiNw8AEAfKHCk4KrV3S8sqwexg5LRtyzrbtGKWayu7YtmfpA+QsrKybPTo0XbPPffYFVdc4XZM48aNXYF2/fr1E715AIA4UnDE7GAkg6QPkETjjbqsCAAAwK7AxWoBAABCCJAAAABCCJAAAABCCJAAAABCCJAAAABCCJAAAABCCJAAAABCCJAAAABCCJAAAABCCJAAAABCCJAAAABCCJAAAABS8WK1AApn2+Z17ELQNoB8IEACMsCmX2YlehMAIKUQIAEZoFS1lpZVslyiNwNJml0kgAZyIkACMoCCo6KlKyZ6MwAgZVCkDQAAEEKABAAAEEKABAAAEEKABAAAEEKABAAAEMIstkLYtoXF90DbAIB0RIBUAOXKlbPiJUrYphUsvofY1EbUVgAAqYcAqQAqV65so0eNsnXryCDJ8uXLbfjw4TZgwACrXr16vNtoylJwpLYCAEg9BEgFpI6Pzi87BUd169YtfKsEACDBCJCADEC9HGgbQP4QIAFpjHo55AX1ckBOBEhAGqNeLjvq5aKjXg7IiQAJSHPUy+VEvRyAHSFAAgAkjW2bmR2M5GgbBEgAgKSx6RfWl0NyIEACACSNUtVaWlZJFlhF9AzSrgygCZAAAElDwVHR0hUTvRkAF6sFAAAIy8pxCwAAQIYjQAIAAAghQAIAAAihSBsAkDS4biCSpW0QIAEAEo7rBiLZrhtIgAQASDiuG5gd1w1M/HUDCZAAAEmB6wbmxHUDE4cACcAusXLlSlu/fn3Cz8qD3xOtbNmyVrVq1URvBoBUDZC2bdtmI0aMsGeeecb++usva968ud10000usgaQ/NauXWu9e/d2n+VkMHz4cEsGWVlZNmHCBCtfvnyiNwUBBPM5ZWIwnxIB0siRI23y5Mk2dOhQ9wYNGzbMLrroIps2bZqVKFEi0ZsHYAcUAIwZMybhGaRko06H4Ci5EMxHl5WBwXzSB0hbtmyx8ePH21VXXWVt27Z1t91777121FFH2RtvvGEnn3xyojcRQB5k2tknUhPBfHRlMzCYT/oAadGiRfb333/b4Ycfnq2KvXHjxvbJJ59kfIBEKjinTEwFA4gfjh9IiQBJAYBUq1Ytx2wH/7f82r59u23YsMFS3bp166xXr17u9SSDZKrr0HDOrlorAwCQGtRfFilSJD0CpI0bN7rv4VqjkiVLurHigti6dastXLjQ0sFll11mmzZtSvRmJJVSpUrZzz//7L4AAAjKa+1ysVTo7Hwtkv9ZNm/ebKVLly7QYxYvXtzq1q0bt20EAADJb/HixXm+b9IHSH5obfXq1bbffvtFbtfvDRo0KNBjKr1WpkyZuG0jAABIfnkdXpMsS3INGzZ0RbezZ8/OVnuzYMECtx4SAABAvBVLhbHCLl262N13320VK1a0ffbZx62DpFkGHTp0SPTmAQCANJT0AZL069fP/vnnH7vhhhtcQbIyR+PGjXO1RAAAAPFWZHuyzBHfRebNm+e+N23aNNGbAgAAkjQGSPoaJAAAgF2NAAkAACCEAAkAACAVi7TjSatoq+zKj0MCAIDMsGXLlvS51EgiF4kCAADpFQPkNQ7IuFlsAAAAO0INEgAAQAgBEgAAQAgBEgAAQAgBEgAAQAgBEgAAQAgBEgAAQAgBEgAAQAgBEgAAQAgBEgAAQAgBEgAAQAgBEgAAQAgBElLOtm3bbOTIkfbEE08kelMA54033rB58+axN5D0aKt5Vywf9wUSTp3QOeecY0WLFrUGDRpY27ZtrXr16oneLGSoTz75xPr27Wtr1661Cy64wGrVqmVly5ZN9GYBOdBW848MElJKpUqVbOLEiS6DpCCJLBISadmyZXbHHXfYNddcY88++yxZJCQt2mr+kUFCUlu9erU9/vjjVqVKFatdu7YdeeSRVq1aNdu6davNmDHDZs2aZZ9++qk1a9Ys0ZuKDLB582Z75ZVXXKC+//7729lnnx35m4L1yZMnW926dW2vvfZK6HYCtNXCI4OEpDV9+nQ77rjj7Ouvv3ad0kUXXWQPPfSQrVy50ooXL24nnHCC7b777jZp0qREbyoywMsvv+wCdAVCV111lWuP77//fuTvN9xwg7355psuaFedHEBbTW0ESEhK27dvt+eff951Qo899pg99dRTdtNNN9m0adMiAZGyRq1atbLvvvvOXnzxxURvMtL8bPzJJ5+0Xr162XPPPWcPP/ywHXjggXbllVfaV1995QKio48+2lq0aOHa648//pjoTUaGoq3GDwESkpI6GI2Z77fffpHbOnXqZEcddZR98MEH9tprr7nbTjzxRNt3331dp7Vu3boEbjHS2WeffWaLFi2y448/3v1+wAEH2HXXXefa5z333GM///yzu33w4MEu46lMkjoqgLaaugiQkJT22GMPW7NmjSvEli1btrjvHTt2tD333NNlkjZu3OhmDbVr185+//13V/8B7AyqKVLd219//RVpjxrmve2222z27Nn20Ucfudtq1KjhAvkJEybYN998w5uBXY62Gj8ESEi4cL2Gfi9fvrwbPtOMNVFnJCqAPeKII+yXX36J1H/orL5x48burP37779PwCtAuitSpIg1adLEDftKiRIl7N9//3Xt7uSTT3bB+fr1693frr/+ehe8k9UEbTW1ESAhITTzbMSIEe6sOysry9UcRRpl1v+apdY70tCGhtTUQfkskobVNmzYYMuXL3fBVLly5VzBtjDtHwUd0v31119jDovVqVPH6tWr54bPvvjii2yB/aWXXurq4PQlynoOGDDApk6dap9//jlvCOLqp59+cutu+eNh8NhJW40vAiQkhIpcNX1fU/Vjadq0qbVv397VdfizdnVKVatWtZo1a9qCBQsiwVSbNm2sefPmLqCaOXPmLnsdSG1//PGH9enTx84//3zr3r27mxSwatWqbPfxgdApp5ziMkMvvfSSyx4pq6nOaZ999nEF21qIz9MwmxYw1YSC8OMBBW2rCsa1IOmFF15ol112mf3999/u5JG2unMQIGGXUoeizkVfpUqVctP3deauD3l4qE21Rj179nR1H0OGDHF/V0C0adMmdwalM3r5559/3P+rk9Njjh49OsdZFRCmdnTzzTe7tqOAXZ2PhskWLlyY7X4+CNesydatW7sM0tNPP+1u0//++eef7qxeQbv4M/thw4a5E4C33nrL1S8BBaXj3cCBA61YsWL2wAMPuGBe2UmdZPrjKm01/lgoEruUOhQNQagTUYfyww8/2KuvvurOinxHFHTQQQe56f1aqVh1RyrIVvGrflYtkmvExYpF1k3SlOtu3bq5oMnXLQHRaOaZhnq1ErZqifTlh2rDfHCuzJAC9nvvvde1Y9UlaQhYwXzDhg0jmU51WIsXL3a/M7sS8WirS5cutaFDh7o2py9lMpVBknAWibYaHwRISMjq2DpT1/ToO++809555x03PNaoUSN3ph0MbNTRqOZIXn/9dVdjpIDowQcfdENwnoY+Spcu7Yq6WVUbebFkyRLXvg477DD3u6bxq9jaD+H6die+Tk4ruvfr18/KlClj48aNc4G4/jZo0CA3gcBTcKTMkersjj32WN4QFDpA0kmlnwiga1KqvR588MH29ttvu+VPfGBOW42fItsZi8AupLMbBTPnnXeejR8/3n3QdTau+g59aWVsXezTnwWFaTjOX8ZB99GZU/DsCchPp9OhQwcbO3asa0NXX321HXrooW7JCGWWfE2SskMaEvZLTng6e1dxtwJ7T4dT2iN2BgXaGhauXLmyffvtt25RUrXLuXPnunbcv39/tyacgnafVaetFg41SNilFPTozF3DDgp0NGSmdLGKWbUS8RtvvBG5nzoq1RP5RfjEB0c6MOg+dEYoKHUiGqbVmkVaV0vT81XfoSykhnS1jMS7777r7qvgSDMnNZzm64l22223SHCkTkloj4g337ZUJ6eV27U+3F133eUymFq1XZNYtLyJlpXw7Zq2Gh8ESEjIB94Pj73wwgtuiE11HW3btnVryngq4FaGSWsihYXP5oH80nDZIYcc4jqXjz/+2A3NKvAW1bEpAPeXDFFQpGFdZZuiXWctfMYOxItvW1oUV8dNzZjUyaQPnM444wx34qjsOm01vvhUo1AKMqSgAmsFRaeffrrLJGkmkVLGOjvXmfxZZ53l7telSxf3BcS7bfohXC0joeBIxf1avd1PIFA9hzJEqpcT1cVplpuGf4F4i1VSEKYLdWtBXB84ad2ukiVLumBJGXfaanyRQUKBKM2rq5drVoUKUbVoY15pKr4W3tNZ0LPPPuuKYRUIqTZJa8noexBXRseOKKjRMK2u0ecXbMwtcPedkdqh6uFU4H/ttde6gF3BkRaEVI2RgnjPB0c+ywQUtK0+8sgj9swzz0TWzspLcCSVKlVyl7NR3aYoONJ6cFoGoHPnzrTVOKNIG/mmAtYrrrjCTcFXyldBjoqrNbtHw2Q7OhvSmY46mWA9kc7cdRaveqS8HiwA0SweXThWCzZqTSKdTWsRPa3Enlsmyd+uDkvrFakGSVkjra81Z84cO+mkk+zGG290nRAQDx9++KGbDKC2qmFbDeFqrbeuXbu6UoIdZeRVW6RaIy1NUbt2bfelawGqSFsnrLTV+CJAQr5pXSJ1RPfdd58LZpQ9uvvuu91sCqV/dTaeH+GDQrQZQ0AsvXr1cmsQ6fIeWrBR62rpDFuFrFrXKK9tSdOmtS6X1ptR8fYBBxzATkdcaaZZxYoVXeCtDKWCexVZa7Zkjx49IlP1d1S2oGFhtVVNYDnuuOOyLXmC+KEGCfmiIYj58+e7QkGf6dElFU499VS3TtGYMWNcdimvY+oSPhgQHCGvFNSokF+di2ia83/+8x+X5dQqwzpT11oxeaEgyy/2GBzaJaOJeFAwo+EwBfSibKWOm7o8kmbvau0tXXg7Lw4//HD3RVvduRjLQExalEzT7JXS1ZRnUQrXXypEM8+CdUWisXUVYatTUQfDMlvYmbSoo4Yd/EVmtU6MaLhB10DTZAC/2nB++ACf4AjxnDWpzLs/Jvq2qmsBKnOkhUVVfqATxvwcN2mrOw8BEqLSUJlm+KgWQ0MWqum47bbb3Af37LPPdh9mfXkKoDTLRzVEDz30kLvNL+KoA4FfAZaCa8ST2pfOpFWg7QN11SD5rKaKtsMTCPLS+RAYIZ7U5jTrTDWa/vppaqs60VTgpKFgXQNQ11fz7Zq2mngESIjqySeftNNOO82tdq0FyoYPH+4WzdPlQVRQ2KpVK7v99tvt3HPPdWvJzJo1y61hpNs1Nq5ZFfqQawhE63SMGjXqfw2OAmzkg9qPghyfIQpTYasuFaLhC9VzBAOgvn37umnRwYvPfvnll9a7d+9s2U8gHnR5GU000Qxfz7dFH/Acc8wx9scff9jUqVOzzYjUhbaVCdV1Jv3/qe1rZppmVCIxCJCQg65Wrq9g7YaWuVcgpBlrmvGjK5WrSFtT9W+99VZ34UQtZKYASNP0/eKOqulQTZJuV2cF5IfamSYA+I4jyHc+rVu3dkNtuo6aZqRpzSLNENIZuq5RpVk+njKZ6qB89pOMJgpLbUozeLVchGZTah03LXIbLROk2k2dRGrBUQX9Glrz626prfpp//o/tWNN61eNHW01MQiQMpw6EhUI6szaL4qnlK//8IofHqtfv767XReM1Vj5kUce6QoOg1dAV92H7qcDgu989PuyZcvcUgBAXqkNqZ1pZpoCGk0Q8LcHOx9dJFbFrQrAtSaXqHNR7ZGG19T+PM1O0+Ua/CVEyGiisJRlV8b86aeftvvvv98N+fpVrsNtVcdWra2l22+55RZ3m46zyiQp8+4nCejYqTW6NOFg+vTptNUEYRZbBlPWR8NkWvdFHYkuyqmCQdUe6WxGU6V1tuMXyFOQo0UdtaS9zsoVGI0cOdI++ugjd9akjkwdj9boCF5EVpklZZk0awOIRbVqvthfHYY6EXUSFSpUcEF5y5YtXXsMznr0U6IVICmQ19R+zYLUZUOUdVJAr7P2IC20p2nWQGHbqtqcLpekUgO1VdHiuV60tqq2edVVV7msk6+h++2339yaSJruHwzcGzRo4DKoSAzWQcpQOjPX2YnW0FAWSOPdL774oj311FNuqr5mq6kwW981tKYgSIGOznpU26G6Iv2fMk8aT1fwpGzUwIED3QKS0XClc8SiTkCF1R07doysg6WMkH7XJAEt+qjARmtwaTgt1jISKoBV4K+OS/fR4o8qjKU9Yme0VV3HTyeV//3vf119kS6ZpHrLMmXKuIVwdeKo+0Y79r388suurWrWrzJOWkBSF++mrSYPMkgZvKKrileVARKldvVB1vXQNFV/yJAh9uijj7rOya8z49ea0VmNLxzU2bm+NH1V17ISdUzBDJLHlc4R5gMdnY2rNkgUHPnhWWU19TcNi11yySWuU1JGU3UbWnAvHChdeOGFbhKBAnYF9F60Dor2iMK2VWWNVHOpQGnvvfd2J4+aNKATS11KRAs6Dho0yB1fFQQFL2qsSS36WrFihftf2mryoQYpQ2ncW4XU/rpnvuZIY+QzZ850NR/qYPSBV0bJB0c6M1fn44ct/CwMHxzpdx1E6HyQFz640erVfgV2dSS6XXUdqotTLZHOrFU/pPWNdFkFf8FOPylAZ+P+Yp26zQdHvhaE9oid0VZFy0lMmDDBFWYrOFeJgTKdqkfS/2gWsCg4UlvVkhQaTvN8cOSPpbTV5EGAlKF8Cvj55593v+uMR4WtlStXdpdY0DR/naVrOvTll1/uil81nKYhON2uWpBoq16zCjbywxexavhMkwXEn2WrIzr00ENdcb+CdhWxqv5NNRvBi8hqiFeFssGzcy/abUC82qqf4auspgIhTRjwAY5qjbQunLLrfqKLZgArQIpWj8mxM/lw9EhT6kz0gVNmx88eCw4zaGq0htNUYKj76sM8ceJEV7Cts58zzzzTLYuv+qP999/fnbHrLF0dzs0335ztkgxAQfn2qEJstdclS5a4C3B6Wqi0W7dubjhYgfp3331n7733nvvd17p16tTJunTpwpuAXdpWNaymITZ9KYukk0ifsQwWc2s4zk8+UM2nvpAaCJDSjKZCaxhC1/fRB1lB0bXXXuuGJ/wH3I+la/isUaNGLvBRilgzgVTrof9p3Lix64wUIKkYW52U0sI6Q4o2fRUoDLUrFbeqjfkASdkiDTvod63iruusqe0qu6kJBWq7ynz6oQ8ucoxd2VY181fBUbly5VyApHojLaSr9qgTTk0y0DFUhdo+k+lPUmmrqYFZbGlENRuaRaZaIl32QyuzPvDAA66G45prrnHDFXmhs3i/+rWG0sKFsHy4sTOccsopLhjSkhDqdFRTpOnPymqKZklqGFhLTGiigK97AxLVVhW4+wy92qqynJoRrLW39F3LpagmiSVOUhMZpDSgwj8VDSqw0RmLpqH6ITAFRioc1AKOsWgWhdaZ0YdZ9Ue6tIPOgHSGLuHp1IyVY2dQ9lJTppXJ1FpcmqWmL0/BkbRo0cJ9jzXVH9jVbVUZIs24fPDBB91lb1Q/p4kCqkESljhJTQRIKU7BkIYetMy9zlh0HSAf2Ij+pg+vn+ETjTJCCqCUffJTqLWApIbogF1F6xWps1Eth87KtVJ7bgiOkGxtVcdMfQUDI33RVlMTAVIarcmh66KpsFozz/w0VH/hWL/KazRa/0irv+qsRwGW6pWARND6WxoeHj16tBsq1poywhk4UqWt+mOzb7PUaaYu8tNptCaHpu1rSE1T9X0RtYq1NaU/WoCkobn3338/crFE1XX44Cg8GwPYFVSroUkFyoL279/frcflFx4FUqGt+mMzbTb1UaSdovzZiYqwVbSqtTWi0bV9NMSms5zwWbiuW6UA6rHHHotMQwWSha54/tVXX7k2O3jwYIZ8kbRoq+mJIbY0XT9GdLFOrSPjL8yp/5k7d67rdLp37+7Sw8yuQLLxgbyWl9AK77osDvVwSEa01fTGEFsarMmxePHibEvX++tYffrppy7dq4XJdEFErXvUuXPnyN99cOSXuAeSQXC9Lq1zpIuAAsmItpreCJBSnC67oOmlumSIX87ej4HrytJaFl/rGen6VVpHRmfjPXv2zPYYTNtHMmLmD1IFbTU9McSWZmtyKBDyAY+KsDXMprMcXSeoZcuWkQJs3YciQgAAoqNIO03069fPXRtIs9i04KOGJ6ZMmeKyS1qvQ3SbxszJGAEAkDsCpDShy4mo6FrZIdUa+WyRp9u5sjkAAHlDDVIarsmhITetyREsviY4AgAg78ggpfGaHCocHDRoEFOkAQDIJwKkNBJcCNKvH8MUaQAA8o8AKQ1xlXMAAAqHAAkAACCEIm0AAIAQAiQAAIAQAiQAAIAQAiQAAIAQAiQAAIAQAiQA9txzz1mDBg3sp59+cntD1/Rr165dofeMHk+Pq8dPJG3H0Ucfbb///ntCtyPZPfvss9arV69EbwaQFAiQAORwySWX2IgRI9JmAVVdhufCCy+0ihUrJnpzktpZZ51lv/76qwuUgExHgAQgh/32288aN26cFnvmzTfftG+//dY6deqU6E1JelqJv3fv3jZ8+HDbtGlTojcHSCgCJCBNsiSPPfaYnXDCCXbAAQdY+/btbdy4ce729957zw1z6dIzQZ9++qm7fe7cuTkeLzzEpp8feOABu/POO61Vq1buOXr27Gk//PBDtv9744037NRTT3V/P+OMM2zRokU5HvvPP/+0m266yT1O06ZN7dxzz7WPP/442320XcpgnXnmme6x9LNWiL/33nvdtjRp0sR9v+eee2zr1q257psxY8bYcccdZyVKlMj2+A8++KD7+e+//7auXbu6gFCX6NFr19/910EHHWTnnXeeff3115H/V/Cg5+7QoYPblkMOOcS6d+9uCxcujLkPw0OOs2fPzvY8wS9tj9/vepygAQMGuPvo/4PvT7THCb+HeXksDUVqP0ydOjXX/Qqku2KJ3gAAhXfXXXfZ448/7jrpI444wubNm2d33323/fPPP3bRRRdZ5cqV7cUXX7Qjjzwy8j8vvPCC1axZ0w499FBbtmzZDp9jwoQJ7r5DhgyxtWvX2u23327//e9/7emnn3Z/f+edd6xfv352yimn2NVXX+2CBX0PUseroa41a9ZY//793XapI9Y2PvLII3b44YdH7jt69Gi78sorrVatWrbPPvvYww8/bE8++aR7zurVq9uXX37pAqbixYu7541myZIlNn/+fPdcsUyePNltj/afD6L22muvSFC2cuVKe+ihh6xv37729ttvu4tADxw40AWYCjCUbdP+u//++932Tp8+PXJNxNzsv//+kX33zDPPuGEt/3vZsmWj/o+eU48fTZs2bdzQqDdy5EhbvHhxzOeP9VglS5Z0QdK0adOsc+fOO3wdQLoiQAJS3Lp161zw0qVLl0hAouyMakk++eQTN2SibM4TTzzhsiW77baby4C8+uqr+SrILVeunOt0ixYt6n7/8ccfXRbmjz/+sAoVKrggQtmeYcOGub8fddRR7rsyLZ6CNGWVpkyZYgceeKC7rXXr1i5jooAumLVo1qyZC/i8oUOHumyN6mTksMMOs9KlS9vuu+8ec5tnzZrlvmu7ovn3339d0KVsWPPmzSO3K1BS5shTcfett97qvms/aD/ecMMNduKJJ0a2Zf369W4bFWwpwNoRBUH+OT744AP3PficYQrWbrvtNhdYBbNZnuqrgv+fW73Vjh5Lmb1XXnnFvaZYwRqQ7hhiA1LcF1984TJFGu4JUgeurIwoqNiwYYOrxxF91++nn356np9HnaYPjqRq1aru+8aNG13ApY5WmYcgDfkFaShNwYM6Zm2zvhSk6P+U6VFmymvUqFG2/23RooV99NFHrpZIr0vZEQWFp512WsxtXr58uQto9BWm5/ZBo4YFo/1dw3e//PKLCxaUxVLQoeBJw5cKjlatWuWCsKeeesreffdd939btmzJ8Tj+S4FJQek5FPReeumlBX6MvD6WXqveF2XPgExFBglIcarp2VHGoEaNGi7LoWE1BUX6rixTlSpV8vw8ytYEaahJ1OkrsFG9kzJJQRpCC2+rOmYFSNHob+XLl3c/lylTJtvfNAyn7JeyTMo2KVNVr149Fwi2bNky6uMpAxLe7uAQnobC7rvvvhxZqJ9//jnHNio75F+zMj533HGHG8LTNjVs2DCyvdoPuT1OQWi/aQhPQ3uFzejk5bH8a/nrr78K9VxAKiNAAlKcz45o+Kd27dqR21esWOGGwVQ3pDodZZGuu+46+/77710mR0FGvOyxxx4ueNDwUrTgzVMgorqnWM+97777xnwOPb5qYvT122+/2fvvv++CnMsuu8xlloJF2J4CtlidvArARQGW6pxUrOwpyzVq1Cj3szJMEydOtFtuucUFYsoqKfNy7LHHugJw1UMp0Jo0aVJkqCza4/gAsE+fPpZfCmhU66RtnjNnTtT75KXuKa+P5TN54YAXyCQMsQEpTvU1CoD8EI83fvx4V0Tsh8U0k0vZFHX0ynqog48XFfYefPDBbhZbMIOiwu0gZbE0ZLXnnnu6ITv/pQBHw2bBIbwwzSRT3Yzo/9XBK1hSDZYyRdHsvffebigxOHQX/JseT0HlVVdd5YbAPAVbftsUFKkIXMOIGs7UUKCKzVW/pUDDByY+OAq+/uDj6Kt+/fqWX1qiQEXcN954Y8wgSFk8n90q7GOJhg71XuQnwwikGzJIQIrT0NoFF1zgpvmrQ1YQohleKj7WMIrvOBUcnXTSSW6m1Pnnnx8141IYCsY0Q02zvTp27GhLly51GZ4gBTXKxqj4+uKLL7Zq1arZzJkz3Qw11RMp0ItFRdQK+ipVquSCMXXijz76qHu9sYYXNaNPtJRBtJXBFQQMGjTIZddU6N6jR49IHZGCIVHwpWE9BRR16tRxwWCxYsXcEJ/ur/tq2r6WUxAFZPGk2i5tX7RCc+2Db775JlI8XpjHCtL+UpF8rOFJIBMQIAFpQLPXlFVR8a0yMRqqUpZAWZegtm3bugDJDy/FkzpUBTpaZFBBkrZBdToKhIK1LRqK0sw2BRga/lJBsKbH++Aklssvv9wFdQpWNGNOw3UKevS/sWj4SzVAGo6LdekUFYMrONOMPAWQfihMQZ7oOfU4ei0+A6Tt1zIAGi5TzZRmj6ngW7Px/PpS8aLXGes1Pv/8827ITEOE55xzTqEey1N2TOsiXXHFFQXeZiAdFNkezAcDSGs333yzyy6pSDtTvP766672asaMGW5oEblT21CN2FtvvWWlSpVidyFjUYMEZAANH6n2SOsPaTZYJtHyB5rtpiFH5E61TBrGVAaQ4AiZjgAJyAAa9tEijaoROvnkky2TqHZIK40rSFStDmLT8KVm3oWHZoFMxBAbAABACBkkAACAEAIkAACAEAIkAACAEAIkAACAEAIkAACAEAIkAACAEAIkAACAEAIkAACAEAIkAAAAy+7/AE17w+iGhfm7AAAAAElFTkSuQmCC",
+      "text/plain": [
+       "<Figure size 600x400 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Выберем модель, лучшую по KEY_METRIC на валидации, и построим анализ на валидации.\n",
+    "if best_model_name == \"Linear(MSE)\":\n",
+    "    y_val_pred_best = val_pred_lr\n",
+    "elif best_model_name == \"Linear(MAE:Quantile=0.5)\":\n",
+    "    y_val_pred_best = val_pred_qr\n",
+    "elif best_model_name == \"Baseline-Mean\":\n",
+    "    y_val_pred_best = val_pred_mean\n",
+    "else:\n",
+    "    y_val_pred_best = val_pred_median\n",
+    "\n",
+    "abs_err = np.abs(y_val.values - y_val_pred_best)\n",
+    "\n",
+    "plt.figure(figsize=(6,4))\n",
+    "plt.hist(abs_err, bins=20, color='#1f77b4', alpha=0.8)\n",
+    "plt.xlabel('|ошибка|')\n",
+    "plt.ylabel('Количество')\n",
+    "plt.title('Гистограмма абсолютных ошибок (val)')\n",
+    "plt.tight_layout(); plt.show()\n",
+    "\n",
+    "ref_feature = num_features[0]\n",
+    "tmp = X_val[[ref_feature]].copy()\n",
+    "tmp['abs_err'] = abs_err\n",
+    "tmp['bin'] = pd.qcut(tmp[ref_feature], q=4, duplicates='drop')\n",
+    "ax = sns.boxplot(data=tmp, x='bin', y='abs_err')\n",
+    "ax.set_title(f'Абсолютные ошибки по квантилям признака: {ref_feature}')\n",
+    "ax.set_xlabel(ref_feature + ' (квантили)')\n",
+    "ax.set_ylabel('|ошибка|')\n",
+    "plt.xticks(rotation=30)\n",
+    "plt.tight_layout(); plt.show()\n"
+   ]
+  }
+ ],
+ "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.14.0"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}