{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Polynomial and Spline Interpolation (balance-scale)\n",
    "\n",
    "**Цель задачи:**  \n",
    "Продемонстрировать применение **PolynomialFeatures** и **SplineTransformer** для аппроксимации нелинейной зависимости в реальных данных c openml.\n",
    "\n",
    "1. **Использовать** `PolynomialFeatures` и `SplineTransformer` из scikit-learn.\n",
    "2. **Протестировать** на реальном датасете **balance-scale** из openml.org.\n",
    "3. **Сравнить** результаты и визуализировать аппроксимирующие кривые."
   ],
   "id": "title"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.1. Импорт библиотек"
   ],
   "id": "imports_title"
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2026-05-05T15:30:30.145447700Z",
     "start_time": "2026-05-05T15:30:30.071046600Z"
    }
   },
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import openml\n",
    "\n",
    "from sklearn.linear_model import Ridge\n",
    "from sklearn.pipeline import make_pipeline\n",
    "from sklearn.preprocessing import PolynomialFeatures, SplineTransformer, StandardScaler"
   ],
   "id": "imports",
   "outputs": [],
   "execution_count": 29
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.2. Получение данных\n",
    "\n",
    "Получение данных из openml.org: **balance-scale**"
   ],
   "id": "load_title"
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2026-05-05T15:30:30.206477600Z",
     "start_time": "2026-05-05T15:30:30.156450200Z"
    }
   },
   "source": [
    "dataset = openml.datasets.get_dataset(11)  # balance-scale\n",
    "X, y, _, _ = dataset.get_data(target=dataset.default_target_attribute)\n",
    "X = X.select_dtypes(include=['float64', 'int64'])  # Только числовые признаки"
   ],
   "id": "load_data",
   "outputs": [],
   "execution_count": 30
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.3. Подготовка данных"
   ],
   "id": "prep_title"
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2026-05-05T15:30:30.248375900Z",
     "start_time": "2026-05-05T15:30:30.221465Z"
    }
   },
   "source": [
    "# Вычисляем разность торков — физический признак, определяющий класс весов\n",
    "X['torque_diff'] = (X['left-weight']  * X['left-distance'] - X['right-weight'] * X['right-distance'])\n",
    "\n",
    "# Кодируем целевой класс числом: L -> +1, B -> 0, R -> -1\n",
    "y_encoded = y.map({'L': 1, 'B': 0, 'R': -1}).astype(float)\n",
    "\n",
    "X_feat = X[['torque_diff']].values # признак для интерполяции\n",
    "y_feat = y_encoded.values"
   ],
   "id": "prep",
   "outputs": [],
   "execution_count": 31
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.4. Визуализация данных"
   ],
   "id": "eda_title"
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2026-05-05T15:30:30.424640800Z",
     "start_time": "2026-05-05T15:30:30.253376800Z"
    }
   },
   "source": [
    "plt.figure(figsize=(10, 6))\n",
    "plt.scatter(X_feat, y_feat, c='steelblue', alpha=0.3, label='Данные')\n",
    "plt.xlabel('Разность торков (left - right)')\n",
    "plt.ylabel('Класс (L=+1, B=0, R=-1)')\n",
    "plt.title('balance-scale: разность торков vs класс')\n",
    "plt.yticks([-1, 0, 1], ['R (-1)', 'B (0)', 'L (+1)'])\n",
    "plt.legend()\n",
    "plt.show()"
   ],
   "id": "eda",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data",
     "jetTransient": {
      "display_id": null
     }
    }
   ],
   "execution_count": 32
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Обучение модели"
   ],
   "id": "train_title"
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2026-05-05T15:30:30.516547Z",
     "start_time": "2026-05-05T15:30:30.441644700Z"
    }
   },
   "source": [
    "# PolynomialFeatures с оптимальным значением degree=7\n",
    "poly_model = make_pipeline(StandardScaler(), PolynomialFeatures(degree=7), Ridge(alpha=1e-3))\n",
    "# SplineTransformer с оптимальным значением n_knots=10\n",
    "spline_model = make_pipeline(SplineTransformer(n_knots=10, degree=3), Ridge(alpha=1e-3))\n",
    "\n",
    "poly_model.fit(X_feat, y_feat)\n",
    "spline_model.fit(X_feat, y_feat)"
   ],
   "id": "train",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Pipeline(steps=[('splinetransformer', SplineTransformer(n_knots=10)),\n",
       "                ('ridge', Ridge(alpha=0.001))])"
      ],
      "text/html": [
       "<style>#sk-container-id-7 {\n",
       "  /* Definition of color scheme common for light and dark mode */\n",
       "  --sklearn-color-text: #000;\n",
       "  --sklearn-color-text-muted: #666;\n",
       "  --sklearn-color-line: gray;\n",
       "  /* Definition of color scheme for unfitted estimators */\n",
       "  --sklearn-color-unfitted-level-0: #fff5e6;\n",
       "  --sklearn-color-unfitted-level-1: #f6e4d2;\n",
       "  --sklearn-color-unfitted-level-2: #ffe0b3;\n",
       "  --sklearn-color-unfitted-level-3: chocolate;\n",
       "  /* Definition of color scheme for fitted estimators */\n",
       "  --sklearn-color-fitted-level-0: #f0f8ff;\n",
       "  --sklearn-color-fitted-level-1: #d4ebff;\n",
       "  --sklearn-color-fitted-level-2: #b3dbfd;\n",
       "  --sklearn-color-fitted-level-3: cornflowerblue;\n",
       "}\n",
       "\n",
       "#sk-container-id-7.light {\n",
       "  /* Specific color for light theme */\n",
       "  --sklearn-color-text-on-default-background: black;\n",
       "  --sklearn-color-background: white;\n",
       "  --sklearn-color-border-box: black;\n",
       "  --sklearn-color-icon: #696969;\n",
       "}\n",
       "\n",
       "#sk-container-id-7.dark {\n",
       "  --sklearn-color-text-on-default-background: white;\n",
       "  --sklearn-color-background: #111;\n",
       "  --sklearn-color-border-box: white;\n",
       "  --sklearn-color-icon: #878787;\n",
       "}\n",
       "\n",
       "#sk-container-id-7 {\n",
       "  color: var(--sklearn-color-text);\n",
       "}\n",
       "\n",
       "#sk-container-id-7 pre {\n",
       "  padding: 0;\n",
       "}\n",
       "\n",
       "#sk-container-id-7 input.sk-hidden--visually {\n",
       "  border: 0;\n",
       "  clip: rect(1px 1px 1px 1px);\n",
       "  clip: rect(1px, 1px, 1px, 1px);\n",
       "  height: 1px;\n",
       "  margin: -1px;\n",
       "  overflow: hidden;\n",
       "  padding: 0;\n",
       "  position: absolute;\n",
       "  width: 1px;\n",
       "}\n",
       "\n",
       "#sk-container-id-7 div.sk-dashed-wrapped {\n",
       "  border: 1px dashed var(--sklearn-color-line);\n",
       "  margin: 0 0.4em 0.5em 0.4em;\n",
       "  box-sizing: border-box;\n",
       "  padding-bottom: 0.4em;\n",
       "  background-color: var(--sklearn-color-background);\n",
       "}\n",
       "\n",
       "#sk-container-id-7 div.sk-container {\n",
       "  /* jupyter's `normalize.less` sets `[hidden] { display: none; }`\n",
       "     but bootstrap.min.css set `[hidden] { display: none !important; }`\n",
       "     so we also need the `!important` here to be able to override the\n",
       "     default hidden behavior on the sphinx rendered scikit-learn.org.\n",
       "     See: https://github.com/scikit-learn/scikit-learn/issues/21755 */\n",
       "  display: inline-block !important;\n",
       "  position: relative;\n",
       "}\n",
       "\n",
       "#sk-container-id-7 div.sk-text-repr-fallback {\n",
       "  display: none;\n",
       "}\n",
       "\n",
       "div.sk-parallel-item,\n",
       "div.sk-serial,\n",
       "div.sk-item {\n",
       "  /* draw centered vertical line to link estimators */\n",
       "  background-image: linear-gradient(var(--sklearn-color-text-on-default-background), var(--sklearn-color-text-on-default-background));\n",
       "  background-size: 2px 100%;\n",
       "  background-repeat: no-repeat;\n",
       "  background-position: center center;\n",
       "}\n",
       "\n",
       "/* Parallel-specific style estimator block */\n",
       "\n",
       "#sk-container-id-7 div.sk-parallel-item::after {\n",
       "  content: \"\";\n",
       "  width: 100%;\n",
       "  border-bottom: 2px solid var(--sklearn-color-text-on-default-background);\n",
       "  flex-grow: 1;\n",
       "}\n",
       "\n",
       "#sk-container-id-7 div.sk-parallel {\n",
       "  display: flex;\n",
       "  align-items: stretch;\n",
       "  justify-content: center;\n",
       "  background-color: var(--sklearn-color-background);\n",
       "  position: relative;\n",
       "}\n",
       "\n",
       "#sk-container-id-7 div.sk-parallel-item {\n",
       "  display: flex;\n",
       "  flex-direction: column;\n",
       "}\n",
       "\n",
       "#sk-container-id-7 div.sk-parallel-item:first-child::after {\n",
       "  align-self: flex-end;\n",
       "  width: 50%;\n",
       "}\n",
       "\n",
       "#sk-container-id-7 div.sk-parallel-item:last-child::after {\n",
       "  align-self: flex-start;\n",
       "  width: 50%;\n",
       "}\n",
       "\n",
       "#sk-container-id-7 div.sk-parallel-item:only-child::after {\n",
       "  width: 0;\n",
       "}\n",
       "\n",
       "/* Serial-specific style estimator block */\n",
       "\n",
       "#sk-container-id-7 div.sk-serial {\n",
       "  display: flex;\n",
       "  flex-direction: column;\n",
       "  align-items: center;\n",
       "  background-color: var(--sklearn-color-background);\n",
       "  padding-right: 1em;\n",
       "  padding-left: 1em;\n",
       "}\n",
       "\n",
       "\n",
       "/* Toggleable style: style used for estimator/Pipeline/ColumnTransformer box that is\n",
       "clickable and can be expanded/collapsed.\n",
       "- Pipeline and ColumnTransformer use this feature and define the default style\n",
       "- Estimators will overwrite some part of the style using the `sk-estimator` class\n",
       "*/\n",
       "\n",
       "/* Pipeline and ColumnTransformer style (default) */\n",
       "\n",
       "#sk-container-id-7 div.sk-toggleable {\n",
       "  /* Default theme specific background. It is overwritten whether we have a\n",
       "  specific estimator or a Pipeline/ColumnTransformer */\n",
       "  background-color: var(--sklearn-color-background);\n",
       "}\n",
       "\n",
       "/* Toggleable label */\n",
       "#sk-container-id-7 label.sk-toggleable__label {\n",
       "  cursor: pointer;\n",
       "  display: flex;\n",
       "  width: 100%;\n",
       "  margin-bottom: 0;\n",
       "  padding: 0.5em;\n",
       "  box-sizing: border-box;\n",
       "  text-align: center;\n",
       "  align-items: center;\n",
       "  justify-content: center;\n",
       "  gap: 0.5em;\n",
       "}\n",
       "\n",
       "#sk-container-id-7 label.sk-toggleable__label .caption {\n",
       "  font-size: 0.6rem;\n",
       "  font-weight: lighter;\n",
       "  color: var(--sklearn-color-text-muted);\n",
       "}\n",
       "\n",
       "#sk-container-id-7 label.sk-toggleable__label-arrow:before {\n",
       "  /* Arrow on the left of the label */\n",
       "  content: \"▸\";\n",
       "  float: left;\n",
       "  margin-right: 0.25em;\n",
       "  color: var(--sklearn-color-icon);\n",
       "}\n",
       "\n",
       "#sk-container-id-7 label.sk-toggleable__label-arrow:hover:before {\n",
       "  color: var(--sklearn-color-text);\n",
       "}\n",
       "\n",
       "/* Toggleable content - dropdown */\n",
       "\n",
       "#sk-container-id-7 div.sk-toggleable__content {\n",
       "  display: none;\n",
       "  text-align: left;\n",
       "  /* unfitted */\n",
       "  background-color: var(--sklearn-color-unfitted-level-0);\n",
       "}\n",
       "\n",
       "#sk-container-id-7 div.sk-toggleable__content.fitted {\n",
       "  /* fitted */\n",
       "  background-color: var(--sklearn-color-fitted-level-0);\n",
       "}\n",
       "\n",
       "#sk-container-id-7 div.sk-toggleable__content pre {\n",
       "  margin: 0.2em;\n",
       "  border-radius: 0.25em;\n",
       "  color: var(--sklearn-color-text);\n",
       "  /* unfitted */\n",
       "  background-color: var(--sklearn-color-unfitted-level-0);\n",
       "}\n",
       "\n",
       "#sk-container-id-7 div.sk-toggleable__content.fitted pre {\n",
       "  /* unfitted */\n",
       "  background-color: var(--sklearn-color-fitted-level-0);\n",
       "}\n",
       "\n",
       "#sk-container-id-7 input.sk-toggleable__control:checked~div.sk-toggleable__content {\n",
       "  /* Expand drop-down */\n",
       "  display: block;\n",
       "  width: 100%;\n",
       "  overflow: visible;\n",
       "}\n",
       "\n",
       "#sk-container-id-7 input.sk-toggleable__control:checked~label.sk-toggleable__label-arrow:before {\n",
       "  content: \"▾\";\n",
       "}\n",
       "\n",
       "/* Pipeline/ColumnTransformer-specific style */\n",
       "\n",
       "#sk-container-id-7 div.sk-label input.sk-toggleable__control:checked~label.sk-toggleable__label {\n",
       "  color: var(--sklearn-color-text);\n",
       "  background-color: var(--sklearn-color-unfitted-level-2);\n",
       "}\n",
       "\n",
       "#sk-container-id-7 div.sk-label.fitted input.sk-toggleable__control:checked~label.sk-toggleable__label {\n",
       "  background-color: var(--sklearn-color-fitted-level-2);\n",
       "}\n",
       "\n",
       "/* Estimator-specific style */\n",
       "\n",
       "/* Colorize estimator box */\n",
       "#sk-container-id-7 div.sk-estimator input.sk-toggleable__control:checked~label.sk-toggleable__label {\n",
       "  /* unfitted */\n",
       "  background-color: var(--sklearn-color-unfitted-level-2);\n",
       "}\n",
       "\n",
       "#sk-container-id-7 div.sk-estimator.fitted input.sk-toggleable__control:checked~label.sk-toggleable__label {\n",
       "  /* fitted */\n",
       "  background-color: var(--sklearn-color-fitted-level-2);\n",
       "}\n",
       "\n",
       "#sk-container-id-7 div.sk-label label.sk-toggleable__label,\n",
       "#sk-container-id-7 div.sk-label label {\n",
       "  /* The background is the default theme color */\n",
       "  color: var(--sklearn-color-text-on-default-background);\n",
       "}\n",
       "\n",
       "/* On hover, darken the color of the background */\n",
       "#sk-container-id-7 div.sk-label:hover label.sk-toggleable__label {\n",
       "  color: var(--sklearn-color-text);\n",
       "  background-color: var(--sklearn-color-unfitted-level-2);\n",
       "}\n",
       "\n",
       "/* Label box, darken color on hover, fitted */\n",
       "#sk-container-id-7 div.sk-label.fitted:hover label.sk-toggleable__label.fitted {\n",
       "  color: var(--sklearn-color-text);\n",
       "  background-color: var(--sklearn-color-fitted-level-2);\n",
       "}\n",
       "\n",
       "/* Estimator label */\n",
       "\n",
       "#sk-container-id-7 div.sk-label label {\n",
       "  font-family: monospace;\n",
       "  font-weight: bold;\n",
       "  line-height: 1.2em;\n",
       "}\n",
       "\n",
       "#sk-container-id-7 div.sk-label-container {\n",
       "  text-align: center;\n",
       "}\n",
       "\n",
       "/* Estimator-specific */\n",
       "#sk-container-id-7 div.sk-estimator {\n",
       "  font-family: monospace;\n",
       "  border: 1px dotted var(--sklearn-color-border-box);\n",
       "  border-radius: 0.25em;\n",
       "  box-sizing: border-box;\n",
       "  margin-bottom: 0.5em;\n",
       "  /* unfitted */\n",
       "  background-color: var(--sklearn-color-unfitted-level-0);\n",
       "}\n",
       "\n",
       "#sk-container-id-7 div.sk-estimator.fitted {\n",
       "  /* fitted */\n",
       "  background-color: var(--sklearn-color-fitted-level-0);\n",
       "}\n",
       "\n",
       "/* on hover */\n",
       "#sk-container-id-7 div.sk-estimator:hover {\n",
       "  /* unfitted */\n",
       "  background-color: var(--sklearn-color-unfitted-level-2);\n",
       "}\n",
       "\n",
       "#sk-container-id-7 div.sk-estimator.fitted:hover {\n",
       "  /* fitted */\n",
       "  background-color: var(--sklearn-color-fitted-level-2);\n",
       "}\n",
       "\n",
       "/* Specification for estimator info (e.g. \"i\" and \"?\") */\n",
       "\n",
       "/* Common style for \"i\" and \"?\" */\n",
       "\n",
       ".sk-estimator-doc-link,\n",
       "a:link.sk-estimator-doc-link,\n",
       "a:visited.sk-estimator-doc-link {\n",
       "  float: right;\n",
       "  font-size: smaller;\n",
       "  line-height: 1em;\n",
       "  font-family: monospace;\n",
       "  background-color: var(--sklearn-color-unfitted-level-0);\n",
       "  border-radius: 1em;\n",
       "  height: 1em;\n",
       "  width: 1em;\n",
       "  text-decoration: none !important;\n",
       "  margin-left: 0.5em;\n",
       "  text-align: center;\n",
       "  /* unfitted */\n",
       "  border: var(--sklearn-color-unfitted-level-3) 1pt solid;\n",
       "  color: var(--sklearn-color-unfitted-level-3);\n",
       "}\n",
       "\n",
       ".sk-estimator-doc-link.fitted,\n",
       "a:link.sk-estimator-doc-link.fitted,\n",
       "a:visited.sk-estimator-doc-link.fitted {\n",
       "  /* fitted */\n",
       "  background-color: var(--sklearn-color-fitted-level-0);\n",
       "  border: var(--sklearn-color-fitted-level-3) 1pt solid;\n",
       "  color: var(--sklearn-color-fitted-level-3);\n",
       "}\n",
       "\n",
       "/* On hover */\n",
       "div.sk-estimator:hover .sk-estimator-doc-link:hover,\n",
       ".sk-estimator-doc-link:hover,\n",
       "div.sk-label-container:hover .sk-estimator-doc-link:hover,\n",
       ".sk-estimator-doc-link:hover {\n",
       "  /* unfitted */\n",
       "  background-color: var(--sklearn-color-unfitted-level-3);\n",
       "  border: var(--sklearn-color-fitted-level-0) 1pt solid;\n",
       "  color: var(--sklearn-color-unfitted-level-0);\n",
       "  text-decoration: none;\n",
       "}\n",
       "\n",
       "div.sk-estimator.fitted:hover .sk-estimator-doc-link.fitted:hover,\n",
       ".sk-estimator-doc-link.fitted:hover,\n",
       "div.sk-label-container:hover .sk-estimator-doc-link.fitted:hover,\n",
       ".sk-estimator-doc-link.fitted:hover {\n",
       "  /* fitted */\n",
       "  background-color: var(--sklearn-color-fitted-level-3);\n",
       "  border: var(--sklearn-color-fitted-level-0) 1pt solid;\n",
       "  color: var(--sklearn-color-fitted-level-0);\n",
       "  text-decoration: none;\n",
       "}\n",
       "\n",
       "/* Span, style for the box shown on hovering the info icon */\n",
       ".sk-estimator-doc-link span {\n",
       "  display: none;\n",
       "  z-index: 9999;\n",
       "  position: relative;\n",
       "  font-weight: normal;\n",
       "  right: .2ex;\n",
       "  padding: .5ex;\n",
       "  margin: .5ex;\n",
       "  width: min-content;\n",
       "  min-width: 20ex;\n",
       "  max-width: 50ex;\n",
       "  color: var(--sklearn-color-text);\n",
       "  box-shadow: 2pt 2pt 4pt #999;\n",
       "  /* unfitted */\n",
       "  background: var(--sklearn-color-unfitted-level-0);\n",
       "  border: .5pt solid var(--sklearn-color-unfitted-level-3);\n",
       "}\n",
       "\n",
       ".sk-estimator-doc-link.fitted span {\n",
       "  /* fitted */\n",
       "  background: var(--sklearn-color-fitted-level-0);\n",
       "  border: var(--sklearn-color-fitted-level-3);\n",
       "}\n",
       "\n",
       ".sk-estimator-doc-link:hover span {\n",
       "  display: block;\n",
       "}\n",
       "\n",
       "/* \"?\"-specific style due to the `<a>` HTML tag */\n",
       "\n",
       "#sk-container-id-7 a.estimator_doc_link {\n",
       "  float: right;\n",
       "  font-size: 1rem;\n",
       "  line-height: 1em;\n",
       "  font-family: monospace;\n",
       "  background-color: var(--sklearn-color-unfitted-level-0);\n",
       "  border-radius: 1rem;\n",
       "  height: 1rem;\n",
       "  width: 1rem;\n",
       "  text-decoration: none;\n",
       "  /* unfitted */\n",
       "  color: var(--sklearn-color-unfitted-level-1);\n",
       "  border: var(--sklearn-color-unfitted-level-1) 1pt solid;\n",
       "}\n",
       "\n",
       "#sk-container-id-7 a.estimator_doc_link.fitted {\n",
       "  /* fitted */\n",
       "  background-color: var(--sklearn-color-fitted-level-0);\n",
       "  border: var(--sklearn-color-fitted-level-1) 1pt solid;\n",
       "  color: var(--sklearn-color-fitted-level-1);\n",
       "}\n",
       "\n",
       "/* On hover */\n",
       "#sk-container-id-7 a.estimator_doc_link:hover {\n",
       "  /* unfitted */\n",
       "  background-color: var(--sklearn-color-unfitted-level-3);\n",
       "  color: var(--sklearn-color-background);\n",
       "  text-decoration: none;\n",
       "}\n",
       "\n",
       "#sk-container-id-7 a.estimator_doc_link.fitted:hover {\n",
       "  /* fitted */\n",
       "  background-color: var(--sklearn-color-fitted-level-3);\n",
       "}\n",
       "\n",
       ".estimator-table {\n",
       "    font-family: monospace;\n",
       "}\n",
       "\n",
       ".estimator-table summary {\n",
       "    padding: .5rem;\n",
       "    cursor: pointer;\n",
       "}\n",
       "\n",
       ".estimator-table summary::marker {\n",
       "    font-size: 0.7rem;\n",
       "}\n",
       "\n",
       ".estimator-table details[open] {\n",
       "    padding-left: 0.1rem;\n",
       "    padding-right: 0.1rem;\n",
       "    padding-bottom: 0.3rem;\n",
       "}\n",
       "\n",
       ".estimator-table .parameters-table {\n",
       "    margin-left: auto !important;\n",
       "    margin-right: auto !important;\n",
       "    margin-top: 0;\n",
       "}\n",
       "\n",
       ".estimator-table .parameters-table tr:nth-child(odd) {\n",
       "    background-color: #fff;\n",
       "}\n",
       "\n",
       ".estimator-table .parameters-table tr:nth-child(even) {\n",
       "    background-color: #f6f6f6;\n",
       "}\n",
       "\n",
       ".estimator-table .parameters-table tr:hover {\n",
       "    background-color: #e0e0e0;\n",
       "}\n",
       "\n",
       ".estimator-table table td {\n",
       "    border: 1px solid rgba(106, 105, 104, 0.232);\n",
       "}\n",
       "\n",
       "/*\n",
       "    `table td`is set in notebook with right text-align.\n",
       "    We need to overwrite it.\n",
       "*/\n",
       ".estimator-table table td.param {\n",
       "    text-align: left;\n",
       "    position: relative;\n",
       "    padding: 0;\n",
       "}\n",
       "\n",
       ".user-set td {\n",
       "    color:rgb(255, 94, 0);\n",
       "    text-align: left !important;\n",
       "}\n",
       "\n",
       ".user-set td.value {\n",
       "    color:rgb(255, 94, 0);\n",
       "    background-color: transparent;\n",
       "}\n",
       "\n",
       ".default td {\n",
       "    color: black;\n",
       "    text-align: left !important;\n",
       "}\n",
       "\n",
       ".user-set td i,\n",
       ".default td i {\n",
       "    color: black;\n",
       "}\n",
       "\n",
       "/*\n",
       "    Styles for parameter documentation links\n",
       "    We need styling for visited so jupyter doesn't overwrite it\n",
       "*/\n",
       "a.param-doc-link,\n",
       "a.param-doc-link:link,\n",
       "a.param-doc-link:visited {\n",
       "    text-decoration: underline dashed;\n",
       "    text-underline-offset: .3em;\n",
       "    color: inherit;\n",
       "    display: block;\n",
       "    padding: .5em;\n",
       "}\n",
       "\n",
       "/* \"hack\" to make the entire area of the cell containing the link clickable */\n",
       "a.param-doc-link::before {\n",
       "    position: absolute;\n",
       "    content: \"\";\n",
       "    inset: 0;\n",
       "}\n",
       "\n",
       ".param-doc-description {\n",
       "    display: none;\n",
       "    position: absolute;\n",
       "    z-index: 9999;\n",
       "    left: 0;\n",
       "    padding: .5ex;\n",
       "    margin-left: 1.5em;\n",
       "    color: var(--sklearn-color-text);\n",
       "    box-shadow: .3em .3em .4em #999;\n",
       "    width: max-content;\n",
       "    text-align: left;\n",
       "    max-height: 10em;\n",
       "    overflow-y: auto;\n",
       "\n",
       "    /* unfitted */\n",
       "    background: var(--sklearn-color-unfitted-level-0);\n",
       "    border: thin solid var(--sklearn-color-unfitted-level-3);\n",
       "}\n",
       "\n",
       "/* Fitted state for parameter tooltips */\n",
       ".fitted .param-doc-description {\n",
       "    /* fitted */\n",
       "    background: var(--sklearn-color-fitted-level-0);\n",
       "    border: thin solid var(--sklearn-color-fitted-level-3);\n",
       "}\n",
       "\n",
       ".param-doc-link:hover .param-doc-description {\n",
       "    display: block;\n",
       "}\n",
       "\n",
       ".copy-paste-icon {\n",
       "    background-image: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCA0NDggNTEyIj48IS0tIUZvbnQgQXdlc29tZSBGcmVlIDYuNy4yIGJ5IEBmb250YXdlc29tZSAtIGh0dHBzOi8vZm9udGF3ZXNvbWUuY29tIExpY2Vuc2UgLSBodHRwczovL2ZvbnRhd2Vzb21lLmNvbS9saWNlbnNlL2ZyZWUgQ29weXJpZ2h0IDIwMjUgRm9udGljb25zLCBJbmMuLS0+PHBhdGggZD0iTTIwOCAwTDMzMi4xIDBjMTIuNyAwIDI0LjkgNS4xIDMzLjkgMTQuMWw2Ny45IDY3LjljOSA5IDE0LjEgMjEuMiAxNC4xIDMzLjlMNDQ4IDMzNmMwIDI2LjUtMjEuNSA0OC00OCA0OGwtMTkyIDBjLTI2LjUgMC00OC0yMS41LTQ4LTQ4bDAtMjg4YzAtMjYuNSAyMS41LTQ4IDQ4LTQ4ek00OCAxMjhsODAgMCAwIDY0LTY0IDAgMCAyNTYgMTkyIDAgMC0zMiA2NCAwIDAgNDhjMCAyNi41LTIxLjUgNDgtNDggNDhMNDggNTEyYy0yNi41IDAtNDgtMjEuNS00OC00OEwwIDE3NmMwLTI2LjUgMjEuNS00OCA0OC00OHoiLz48L3N2Zz4=);\n",
       "    background-repeat: no-repeat;\n",
       "    background-size: 14px 14px;\n",
       "    background-position: 0;\n",
       "    display: inline-block;\n",
       "    width: 14px;\n",
       "    height: 14px;\n",
       "    cursor: pointer;\n",
       "}\n",
       "</style><body><div id=\"sk-container-id-7\" class=\"sk-top-container\"><div class=\"sk-text-repr-fallback\"><pre>Pipeline(steps=[(&#x27;splinetransformer&#x27;, SplineTransformer(n_knots=10)),\n",
       "                (&#x27;ridge&#x27;, Ridge(alpha=0.001))])</pre><b>In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook. <br />On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.</b></div><div class=\"sk-container\" hidden><div class=\"sk-item sk-dashed-wrapped\"><div class=\"sk-label-container\"><div class=\"sk-label fitted sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-19\" type=\"checkbox\" ><label for=\"sk-estimator-id-19\" class=\"sk-toggleable__label fitted sk-toggleable__label-arrow\"><div><div>Pipeline</div></div><div><a class=\"sk-estimator-doc-link fitted\" rel=\"noreferrer\" target=\"_blank\" href=\"https://scikit-learn.org/1.8/modules/generated/sklearn.pipeline.Pipeline.html\">?<span>Documentation for Pipeline</span></a><span class=\"sk-estimator-doc-link fitted\">i<span>Fitted</span></span></div></label><div class=\"sk-toggleable__content fitted\" data-param-prefix=\"\">\n",
       "        <div class=\"estimator-table\">\n",
       "            <details>\n",
       "                <summary>Parameters</summary>\n",
       "                <table class=\"parameters-table\">\n",
       "                  <tbody>\n",
       "                    \n",
       "        <tr class=\"user-set\">\n",
       "            <td><i class=\"copy-paste-icon\"\n",
       "                 onclick=\"copyToClipboard('steps',\n",
       "                          this.parentElement.nextElementSibling)\"\n",
       "            ></i></td>\n",
       "            <td class=\"param\">\n",
       "        <a class=\"param-doc-link\"\n",
       "            rel=\"noreferrer\" target=\"_blank\" href=\"https://scikit-learn.org/1.8/modules/generated/sklearn.pipeline.Pipeline.html#:~:text=steps,-list%20of%20tuples\">\n",
       "            steps\n",
       "            <span class=\"param-doc-description\">steps: list of tuples<br><br>List of (name of step, estimator) tuples that are to be chained in<br>sequential order. To be compatible with the scikit-learn API, all steps<br>must define `fit`. All non-last steps must also define `transform`. See<br>:ref:`Combining Estimators <combining_estimators>` for more details.</span>\n",
       "        </a>\n",
       "    </td>\n",
       "            <td class=\"value\">[(&#x27;splinetransformer&#x27;, ...), (&#x27;ridge&#x27;, ...)]</td>\n",
       "        </tr>\n",
       "    \n",
       "\n",
       "        <tr class=\"default\">\n",
       "            <td><i class=\"copy-paste-icon\"\n",
       "                 onclick=\"copyToClipboard('transform_input',\n",
       "                          this.parentElement.nextElementSibling)\"\n",
       "            ></i></td>\n",
       "            <td class=\"param\">\n",
       "        <a class=\"param-doc-link\"\n",
       "            rel=\"noreferrer\" target=\"_blank\" href=\"https://scikit-learn.org/1.8/modules/generated/sklearn.pipeline.Pipeline.html#:~:text=transform_input,-list%20of%20str%2C%20default%3DNone\">\n",
       "            transform_input\n",
       "            <span class=\"param-doc-description\">transform_input: list of str, default=None<br><br>The names of the :term:`metadata` parameters that should be transformed by the<br>pipeline before passing it to the step consuming it.<br><br>This enables transforming some input arguments to ``fit`` (other than ``X``)<br>to be transformed by the steps of the pipeline up to the step which requires<br>them. Requirement is defined via :ref:`metadata routing <metadata_routing>`.<br>For instance, this can be used to pass a validation set through the pipeline.<br><br>You can only set this if metadata routing is enabled, which you<br>can enable using ``sklearn.set_config(enable_metadata_routing=True)``.<br><br>.. versionadded:: 1.6</span>\n",
       "        </a>\n",
       "    </td>\n",
       "            <td class=\"value\">None</td>\n",
       "        </tr>\n",
       "    \n",
       "\n",
       "        <tr class=\"default\">\n",
       "            <td><i class=\"copy-paste-icon\"\n",
       "                 onclick=\"copyToClipboard('memory',\n",
       "                          this.parentElement.nextElementSibling)\"\n",
       "            ></i></td>\n",
       "            <td class=\"param\">\n",
       "        <a class=\"param-doc-link\"\n",
       "            rel=\"noreferrer\" target=\"_blank\" href=\"https://scikit-learn.org/1.8/modules/generated/sklearn.pipeline.Pipeline.html#:~:text=memory,-str%20or%20object%20with%20the%20joblib.Memory%20interface%2C%20default%3DNone\">\n",
       "            memory\n",
       "            <span class=\"param-doc-description\">memory: str or object with the joblib.Memory interface, default=None<br><br>Used to cache the fitted transformers of the pipeline. The last step<br>will never be cached, even if it is a transformer. By default, no<br>caching is performed. If a string is given, it is the path to the<br>caching directory. Enabling caching triggers a clone of the transformers<br>before fitting. Therefore, the transformer instance given to the<br>pipeline cannot be inspected directly. Use the attribute ``named_steps``<br>or ``steps`` to inspect estimators within the pipeline. Caching the<br>transformers is advantageous when fitting is time consuming. See<br>:ref:`sphx_glr_auto_examples_neighbors_plot_caching_nearest_neighbors.py`<br>for an example on how to enable caching.</span>\n",
       "        </a>\n",
       "    </td>\n",
       "            <td class=\"value\">None</td>\n",
       "        </tr>\n",
       "    \n",
       "\n",
       "        <tr class=\"default\">\n",
       "            <td><i class=\"copy-paste-icon\"\n",
       "                 onclick=\"copyToClipboard('verbose',\n",
       "                          this.parentElement.nextElementSibling)\"\n",
       "            ></i></td>\n",
       "            <td class=\"param\">\n",
       "        <a class=\"param-doc-link\"\n",
       "            rel=\"noreferrer\" target=\"_blank\" href=\"https://scikit-learn.org/1.8/modules/generated/sklearn.pipeline.Pipeline.html#:~:text=verbose,-bool%2C%20default%3DFalse\">\n",
       "            verbose\n",
       "            <span class=\"param-doc-description\">verbose: bool, default=False<br><br>If True, the time elapsed while fitting each step will be printed as it<br>is completed.</span>\n",
       "        </a>\n",
       "    </td>\n",
       "            <td class=\"value\">False</td>\n",
       "        </tr>\n",
       "    \n",
       "                  </tbody>\n",
       "                </table>\n",
       "            </details>\n",
       "        </div>\n",
       "    </div></div></div><div class=\"sk-serial\"><div class=\"sk-item\"><div class=\"sk-estimator fitted sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-20\" type=\"checkbox\" ><label for=\"sk-estimator-id-20\" class=\"sk-toggleable__label fitted sk-toggleable__label-arrow\"><div><div>SplineTransformer</div></div><div><a class=\"sk-estimator-doc-link fitted\" rel=\"noreferrer\" target=\"_blank\" href=\"https://scikit-learn.org/1.8/modules/generated/sklearn.preprocessing.SplineTransformer.html\">?<span>Documentation for SplineTransformer</span></a></div></label><div class=\"sk-toggleable__content fitted\" data-param-prefix=\"splinetransformer__\">\n",
       "        <div class=\"estimator-table\">\n",
       "            <details>\n",
       "                <summary>Parameters</summary>\n",
       "                <table class=\"parameters-table\">\n",
       "                  <tbody>\n",
       "                    \n",
       "        <tr class=\"user-set\">\n",
       "            <td><i class=\"copy-paste-icon\"\n",
       "                 onclick=\"copyToClipboard('n_knots',\n",
       "                          this.parentElement.nextElementSibling)\"\n",
       "            ></i></td>\n",
       "            <td class=\"param\">\n",
       "        <a class=\"param-doc-link\"\n",
       "            rel=\"noreferrer\" target=\"_blank\" href=\"https://scikit-learn.org/1.8/modules/generated/sklearn.preprocessing.SplineTransformer.html#:~:text=n_knots,-int%2C%20default%3D5\">\n",
       "            n_knots\n",
       "            <span class=\"param-doc-description\">n_knots: int, default=5<br><br>Number of knots of the splines if `knots` equals one of<br>{'uniform', 'quantile'}. Must be larger or equal 2. Ignored if `knots`<br>is array-like.</span>\n",
       "        </a>\n",
       "    </td>\n",
       "            <td class=\"value\">10</td>\n",
       "        </tr>\n",
       "    \n",
       "\n",
       "        <tr class=\"default\">\n",
       "            <td><i class=\"copy-paste-icon\"\n",
       "                 onclick=\"copyToClipboard('degree',\n",
       "                          this.parentElement.nextElementSibling)\"\n",
       "            ></i></td>\n",
       "            <td class=\"param\">\n",
       "        <a class=\"param-doc-link\"\n",
       "            rel=\"noreferrer\" target=\"_blank\" href=\"https://scikit-learn.org/1.8/modules/generated/sklearn.preprocessing.SplineTransformer.html#:~:text=degree,-int%2C%20default%3D3\">\n",
       "            degree\n",
       "            <span class=\"param-doc-description\">degree: int, default=3<br><br>The polynomial degree of the spline basis. Must be a non-negative<br>integer.</span>\n",
       "        </a>\n",
       "    </td>\n",
       "            <td class=\"value\">3</td>\n",
       "        </tr>\n",
       "    \n",
       "\n",
       "        <tr class=\"default\">\n",
       "            <td><i class=\"copy-paste-icon\"\n",
       "                 onclick=\"copyToClipboard('knots',\n",
       "                          this.parentElement.nextElementSibling)\"\n",
       "            ></i></td>\n",
       "            <td class=\"param\">\n",
       "        <a class=\"param-doc-link\"\n",
       "            rel=\"noreferrer\" target=\"_blank\" href=\"https://scikit-learn.org/1.8/modules/generated/sklearn.preprocessing.SplineTransformer.html#:~:text=knots,-int%2C%20default%3D5\">\n",
       "            knots\n",
       "            <span class=\"param-doc-description\">knots: {'uniform', 'quantile'} or array-like of shape         (n_knots, n_features), default='uniform'<br><br>Set knot positions such that first knot <= features <= last knot.<br><br>- If 'uniform', `n_knots` number of knots are distributed uniformly<br>  from min to max values of the features.<br>- If 'quantile', they are distributed uniformly along the quantiles of<br>  the features.<br>- If an array-like is given, it directly specifies the sorted knot<br>  positions including the boundary knots. Note that, internally,<br>  `degree` number of knots are added before the first knot, the same<br>  after the last knot.</span>\n",
       "        </a>\n",
       "    </td>\n",
       "            <td class=\"value\">&#x27;uniform&#x27;</td>\n",
       "        </tr>\n",
       "    \n",
       "\n",
       "        <tr class=\"default\">\n",
       "            <td><i class=\"copy-paste-icon\"\n",
       "                 onclick=\"copyToClipboard('extrapolation',\n",
       "                          this.parentElement.nextElementSibling)\"\n",
       "            ></i></td>\n",
       "            <td class=\"param\">\n",
       "        <a class=\"param-doc-link\"\n",
       "            rel=\"noreferrer\" target=\"_blank\" href=\"https://scikit-learn.org/1.8/modules/generated/sklearn.preprocessing.SplineTransformer.html#:~:text=extrapolation,-%7B%27error%27%2C%20%27constant%27%2C%20%27linear%27%2C%20%27continue%27%2C%20%27periodic%27%7D%2C%20%20%20%20%20%20%20%20%20default%3D%27constant%27\">\n",
       "            extrapolation\n",
       "            <span class=\"param-doc-description\">extrapolation: {'error', 'constant', 'linear', 'continue', 'periodic'},         default='constant'<br><br>If 'error', values outside the min and max values of the training<br>features raises a `ValueError`. If 'constant', the value of the<br>splines at minimum and maximum value of the features is used as<br>constant extrapolation. If 'linear', a linear extrapolation is used.<br>If 'continue', the splines are extrapolated as is, i.e. option<br>`extrapolate=True` in :class:`scipy.interpolate.BSpline`. If<br>'periodic', periodic splines with a periodicity equal to the distance<br>between the first and last knot are used. Periodic splines enforce<br>equal function values and derivatives at the first and last knot.<br>For example, this makes it possible to avoid introducing an arbitrary<br>jump between Dec 31st and Jan 1st in spline features derived from a<br>naturally periodic \"day-of-year\" input feature. In this case it is<br>recommended to manually set the knot values to control the period.</span>\n",
       "        </a>\n",
       "    </td>\n",
       "            <td class=\"value\">&#x27;constant&#x27;</td>\n",
       "        </tr>\n",
       "    \n",
       "\n",
       "        <tr class=\"default\">\n",
       "            <td><i class=\"copy-paste-icon\"\n",
       "                 onclick=\"copyToClipboard('include_bias',\n",
       "                          this.parentElement.nextElementSibling)\"\n",
       "            ></i></td>\n",
       "            <td class=\"param\">\n",
       "        <a class=\"param-doc-link\"\n",
       "            rel=\"noreferrer\" target=\"_blank\" href=\"https://scikit-learn.org/1.8/modules/generated/sklearn.preprocessing.SplineTransformer.html#:~:text=include_bias,-bool%2C%20default%3DTrue\">\n",
       "            include_bias\n",
       "            <span class=\"param-doc-description\">include_bias: bool, default=True<br><br>If False, then the last spline element inside the data range<br>of a feature is dropped. As B-splines sum to one over the spline basis<br>functions for each data point, they implicitly include a bias term,<br>i.e. a column of ones. It acts as an intercept term in a linear models.</span>\n",
       "        </a>\n",
       "    </td>\n",
       "            <td class=\"value\">True</td>\n",
       "        </tr>\n",
       "    \n",
       "\n",
       "        <tr class=\"default\">\n",
       "            <td><i class=\"copy-paste-icon\"\n",
       "                 onclick=\"copyToClipboard('order',\n",
       "                          this.parentElement.nextElementSibling)\"\n",
       "            ></i></td>\n",
       "            <td class=\"param\">\n",
       "        <a class=\"param-doc-link\"\n",
       "            rel=\"noreferrer\" target=\"_blank\" href=\"https://scikit-learn.org/1.8/modules/generated/sklearn.preprocessing.SplineTransformer.html#:~:text=order,-%7B%27C%27%2C%20%27F%27%7D%2C%20default%3D%27C%27\">\n",
       "            order\n",
       "            <span class=\"param-doc-description\">order: {'C', 'F'}, default='C'<br><br>Order of output array in the dense case. `'F'` order is faster to compute, but<br>may slow down subsequent estimators.</span>\n",
       "        </a>\n",
       "    </td>\n",
       "            <td class=\"value\">&#x27;C&#x27;</td>\n",
       "        </tr>\n",
       "    \n",
       "\n",
       "        <tr class=\"default\">\n",
       "            <td><i class=\"copy-paste-icon\"\n",
       "                 onclick=\"copyToClipboard('handle_missing',\n",
       "                          this.parentElement.nextElementSibling)\"\n",
       "            ></i></td>\n",
       "            <td class=\"param\">\n",
       "        <a class=\"param-doc-link\"\n",
       "            rel=\"noreferrer\" target=\"_blank\" href=\"https://scikit-learn.org/1.8/modules/generated/sklearn.preprocessing.SplineTransformer.html#:~:text=handle_missing,-%7B%27error%27%2C%20%27zeros%27%7D%2C%20default%3D%27error%27\">\n",
       "            handle_missing\n",
       "            <span class=\"param-doc-description\">handle_missing: {'error', 'zeros'}, default='error'<br><br>Specifies the way missing values are handled.<br><br>- 'error' : Raise an error if `np.nan` values are present during :meth:`fit`.<br>- 'zeros' : Encode splines of missing values with values `0`.<br><br>Note that `handle_missing='zeros'` differs from first imputing missing values<br>with zeros and then creating the spline basis. The latter creates spline basis<br>functions which have non-zero values at the missing values<br>whereas this option simply sets all spline basis function values to zero at the<br>missing values.<br><br>.. versionadded:: 1.8</span>\n",
       "        </a>\n",
       "    </td>\n",
       "            <td class=\"value\">&#x27;error&#x27;</td>\n",
       "        </tr>\n",
       "    \n",
       "\n",
       "        <tr class=\"default\">\n",
       "            <td><i class=\"copy-paste-icon\"\n",
       "                 onclick=\"copyToClipboard('sparse_output',\n",
       "                          this.parentElement.nextElementSibling)\"\n",
       "            ></i></td>\n",
       "            <td class=\"param\">\n",
       "        <a class=\"param-doc-link\"\n",
       "            rel=\"noreferrer\" target=\"_blank\" href=\"https://scikit-learn.org/1.8/modules/generated/sklearn.preprocessing.SplineTransformer.html#:~:text=sparse_output,-bool%2C%20default%3DFalse\">\n",
       "            sparse_output\n",
       "            <span class=\"param-doc-description\">sparse_output: bool, default=False<br><br>Will return sparse CSR matrix if set True else will return an array.<br><br>.. versionadded:: 1.2</span>\n",
       "        </a>\n",
       "    </td>\n",
       "            <td class=\"value\">False</td>\n",
       "        </tr>\n",
       "    \n",
       "                  </tbody>\n",
       "                </table>\n",
       "            </details>\n",
       "        </div>\n",
       "    </div></div></div><div class=\"sk-item\"><div class=\"sk-estimator fitted sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-21\" type=\"checkbox\" ><label for=\"sk-estimator-id-21\" class=\"sk-toggleable__label fitted sk-toggleable__label-arrow\"><div><div>Ridge</div></div><div><a class=\"sk-estimator-doc-link fitted\" rel=\"noreferrer\" target=\"_blank\" href=\"https://scikit-learn.org/1.8/modules/generated/sklearn.linear_model.Ridge.html\">?<span>Documentation for Ridge</span></a></div></label><div class=\"sk-toggleable__content fitted\" data-param-prefix=\"ridge__\">\n",
       "        <div class=\"estimator-table\">\n",
       "            <details>\n",
       "                <summary>Parameters</summary>\n",
       "                <table class=\"parameters-table\">\n",
       "                  <tbody>\n",
       "                    \n",
       "        <tr class=\"user-set\">\n",
       "            <td><i class=\"copy-paste-icon\"\n",
       "                 onclick=\"copyToClipboard('alpha',\n",
       "                          this.parentElement.nextElementSibling)\"\n",
       "            ></i></td>\n",
       "            <td class=\"param\">\n",
       "        <a class=\"param-doc-link\"\n",
       "            rel=\"noreferrer\" target=\"_blank\" href=\"https://scikit-learn.org/1.8/modules/generated/sklearn.linear_model.Ridge.html#:~:text=alpha,-%7Bfloat%2C%20ndarray%20of%20shape%20%28n_targets%2C%29%7D%2C%20default%3D1.0\">\n",
       "            alpha\n",
       "            <span class=\"param-doc-description\">alpha: {float, ndarray of shape (n_targets,)}, default=1.0<br><br>Constant that multiplies the L2 term, controlling regularization<br>strength. `alpha` must be a non-negative float i.e. in `[0, inf)`.<br><br>When `alpha = 0`, the objective is equivalent to ordinary least<br>squares, solved by the :class:`LinearRegression` object. For numerical<br>reasons, using `alpha = 0` with the `Ridge` object is not advised.<br>Instead, you should use the :class:`LinearRegression` object.<br><br>If an array is passed, penalties are assumed to be specific to the<br>targets. Hence they must correspond in number.</span>\n",
       "        </a>\n",
       "    </td>\n",
       "            <td class=\"value\">0.001</td>\n",
       "        </tr>\n",
       "    \n",
       "\n",
       "        <tr class=\"default\">\n",
       "            <td><i class=\"copy-paste-icon\"\n",
       "                 onclick=\"copyToClipboard('fit_intercept',\n",
       "                          this.parentElement.nextElementSibling)\"\n",
       "            ></i></td>\n",
       "            <td class=\"param\">\n",
       "        <a class=\"param-doc-link\"\n",
       "            rel=\"noreferrer\" target=\"_blank\" href=\"https://scikit-learn.org/1.8/modules/generated/sklearn.linear_model.Ridge.html#:~:text=fit_intercept,-bool%2C%20default%3DTrue\">\n",
       "            fit_intercept\n",
       "            <span class=\"param-doc-description\">fit_intercept: bool, default=True<br><br>Whether to fit the intercept for this model. If set<br>to false, no intercept will be used in calculations<br>(i.e. ``X`` and ``y`` are expected to be centered).</span>\n",
       "        </a>\n",
       "    </td>\n",
       "            <td class=\"value\">True</td>\n",
       "        </tr>\n",
       "    \n",
       "\n",
       "        <tr class=\"default\">\n",
       "            <td><i class=\"copy-paste-icon\"\n",
       "                 onclick=\"copyToClipboard('copy_X',\n",
       "                          this.parentElement.nextElementSibling)\"\n",
       "            ></i></td>\n",
       "            <td class=\"param\">\n",
       "        <a class=\"param-doc-link\"\n",
       "            rel=\"noreferrer\" target=\"_blank\" href=\"https://scikit-learn.org/1.8/modules/generated/sklearn.linear_model.Ridge.html#:~:text=copy_X,-bool%2C%20default%3DTrue\">\n",
       "            copy_X\n",
       "            <span class=\"param-doc-description\">copy_X: bool, default=True<br><br>If True, X will be copied; else, it may be overwritten.</span>\n",
       "        </a>\n",
       "    </td>\n",
       "            <td class=\"value\">True</td>\n",
       "        </tr>\n",
       "    \n",
       "\n",
       "        <tr class=\"default\">\n",
       "            <td><i class=\"copy-paste-icon\"\n",
       "                 onclick=\"copyToClipboard('max_iter',\n",
       "                          this.parentElement.nextElementSibling)\"\n",
       "            ></i></td>\n",
       "            <td class=\"param\">\n",
       "        <a class=\"param-doc-link\"\n",
       "            rel=\"noreferrer\" target=\"_blank\" href=\"https://scikit-learn.org/1.8/modules/generated/sklearn.linear_model.Ridge.html#:~:text=max_iter,-int%2C%20default%3DNone\">\n",
       "            max_iter\n",
       "            <span class=\"param-doc-description\">max_iter: int, default=None<br><br>Maximum number of iterations for conjugate gradient solver.<br>For 'sparse_cg' and 'lsqr' solvers, the default value is determined<br>by scipy.sparse.linalg. For 'sag' solver, the default value is 1000.<br>For 'lbfgs' solver, the default value is 15000.</span>\n",
       "        </a>\n",
       "    </td>\n",
       "            <td class=\"value\">None</td>\n",
       "        </tr>\n",
       "    \n",
       "\n",
       "        <tr class=\"default\">\n",
       "            <td><i class=\"copy-paste-icon\"\n",
       "                 onclick=\"copyToClipboard('tol',\n",
       "                          this.parentElement.nextElementSibling)\"\n",
       "            ></i></td>\n",
       "            <td class=\"param\">\n",
       "        <a class=\"param-doc-link\"\n",
       "            rel=\"noreferrer\" target=\"_blank\" href=\"https://scikit-learn.org/1.8/modules/generated/sklearn.linear_model.Ridge.html#:~:text=tol,-float%2C%20default%3D1e-4\">\n",
       "            tol\n",
       "            <span class=\"param-doc-description\">tol: float, default=1e-4<br><br>The precision of the solution (`coef_`) is determined by `tol` which<br>specifies a different convergence criterion for each solver:<br><br>- 'svd': `tol` has no impact.<br><br>- 'cholesky': `tol` has no impact.<br><br>- 'sparse_cg': norm of residuals smaller than `tol`.<br><br>- 'lsqr': `tol` is set as atol and btol of scipy.sparse.linalg.lsqr,<br>  which control the norm of the residual vector in terms of the norms of<br>  matrix and coefficients.<br><br>- 'sag' and 'saga': relative change of coef smaller than `tol`.<br><br>- 'lbfgs': maximum of the absolute (projected) gradient=max|residuals|<br>  smaller than `tol`.<br><br>.. versionchanged:: 1.2<br>   Default value changed from 1e-3 to 1e-4 for consistency with other linear<br>   models.</span>\n",
       "        </a>\n",
       "    </td>\n",
       "            <td class=\"value\">0.0001</td>\n",
       "        </tr>\n",
       "    \n",
       "\n",
       "        <tr class=\"default\">\n",
       "            <td><i class=\"copy-paste-icon\"\n",
       "                 onclick=\"copyToClipboard('solver',\n",
       "                          this.parentElement.nextElementSibling)\"\n",
       "            ></i></td>\n",
       "            <td class=\"param\">\n",
       "        <a class=\"param-doc-link\"\n",
       "            rel=\"noreferrer\" target=\"_blank\" href=\"https://scikit-learn.org/1.8/modules/generated/sklearn.linear_model.Ridge.html#:~:text=solver,-%7B%27auto%27%2C%20%27svd%27%2C%20%27cholesky%27%2C%20%27lsqr%27%2C%20%27sparse_cg%27%2C%20%20%20%20%20%20%20%20%20%20%20%20%20%27sag%27%2C%20%27saga%27%2C%20%27lbfgs%27%7D%2C%20default%3D%27auto%27\">\n",
       "            solver\n",
       "            <span class=\"param-doc-description\">solver: {'auto', 'svd', 'cholesky', 'lsqr', 'sparse_cg',             'sag', 'saga', 'lbfgs'}, default='auto'<br><br>Solver to use in the computational routines:<br><br>- 'auto' chooses the solver automatically based on the type of data.<br><br>- 'svd' uses a Singular Value Decomposition of X to compute the Ridge<br>  coefficients. It is the most stable solver, in particular more stable<br>  for singular matrices than 'cholesky' at the cost of being slower.<br><br>- 'cholesky' uses the standard :func:`scipy.linalg.solve` function to<br>  obtain a closed-form solution.<br><br>- 'sparse_cg' uses the conjugate gradient solver as found in<br>  :func:`scipy.sparse.linalg.cg`. As an iterative algorithm, this solver is<br>  more appropriate than 'cholesky' for large-scale data<br>  (possibility to set `tol` and `max_iter`).<br><br>- 'lsqr' uses the dedicated regularized least-squares routine<br>  :func:`scipy.sparse.linalg.lsqr`. It is the fastest and uses an iterative<br>  procedure.<br><br>- 'sag' uses a Stochastic Average Gradient descent, and 'saga' uses<br>  its improved, unbiased version named SAGA. Both methods also use an<br>  iterative procedure, and are often faster than other solvers when<br>  both n_samples and n_features are large. Note that 'sag' and<br>  'saga' fast convergence is only guaranteed on features with<br>  approximately the same scale. You can preprocess the data with a<br>  scaler from :mod:`sklearn.preprocessing`.<br><br>- 'lbfgs' uses L-BFGS-B algorithm implemented in<br>  :func:`scipy.optimize.minimize`. It can be used only when `positive`<br>  is True.<br><br>All solvers except 'svd' support both dense and sparse data. However, only<br>'lsqr', 'sag', 'sparse_cg', and 'lbfgs' support sparse input when<br>`fit_intercept` is True.<br><br>.. versionadded:: 0.17<br>   Stochastic Average Gradient descent solver.<br>.. versionadded:: 0.19<br>   SAGA solver.</span>\n",
       "        </a>\n",
       "    </td>\n",
       "            <td class=\"value\">&#x27;auto&#x27;</td>\n",
       "        </tr>\n",
       "    \n",
       "\n",
       "        <tr class=\"default\">\n",
       "            <td><i class=\"copy-paste-icon\"\n",
       "                 onclick=\"copyToClipboard('positive',\n",
       "                          this.parentElement.nextElementSibling)\"\n",
       "            ></i></td>\n",
       "            <td class=\"param\">\n",
       "        <a class=\"param-doc-link\"\n",
       "            rel=\"noreferrer\" target=\"_blank\" href=\"https://scikit-learn.org/1.8/modules/generated/sklearn.linear_model.Ridge.html#:~:text=positive,-bool%2C%20default%3DFalse\">\n",
       "            positive\n",
       "            <span class=\"param-doc-description\">positive: bool, default=False<br><br>When set to ``True``, forces the coefficients to be positive.<br>Only 'lbfgs' solver is supported in this case.</span>\n",
       "        </a>\n",
       "    </td>\n",
       "            <td class=\"value\">False</td>\n",
       "        </tr>\n",
       "    \n",
       "\n",
       "        <tr class=\"default\">\n",
       "            <td><i class=\"copy-paste-icon\"\n",
       "                 onclick=\"copyToClipboard('random_state',\n",
       "                          this.parentElement.nextElementSibling)\"\n",
       "            ></i></td>\n",
       "            <td class=\"param\">\n",
       "        <a class=\"param-doc-link\"\n",
       "            rel=\"noreferrer\" target=\"_blank\" href=\"https://scikit-learn.org/1.8/modules/generated/sklearn.linear_model.Ridge.html#:~:text=random_state,-int%2C%20RandomState%20instance%2C%20default%3DNone\">\n",
       "            random_state\n",
       "            <span class=\"param-doc-description\">random_state: int, RandomState instance, default=None<br><br>Used when ``solver`` == 'sag' or 'saga' to shuffle the data.<br>See :term:`Glossary <random_state>` for details.<br><br>.. versionadded:: 0.17<br>   `random_state` to support Stochastic Average Gradient.</span>\n",
       "        </a>\n",
       "    </td>\n",
       "            <td class=\"value\">None</td>\n",
       "        </tr>\n",
       "    \n",
       "                  </tbody>\n",
       "                </table>\n",
       "            </details>\n",
       "        </div>\n",
       "    </div></div></div></div></div></div></div><script>function copyToClipboard(text, element) {\n",
       "    // Get the parameter prefix from the closest toggleable content\n",
       "    const toggleableContent = element.closest('.sk-toggleable__content');\n",
       "    const paramPrefix = toggleableContent ? toggleableContent.dataset.paramPrefix : '';\n",
       "    const fullParamName = paramPrefix ? `${paramPrefix}${text}` : text;\n",
       "\n",
       "    const originalStyle = element.style;\n",
       "    const computedStyle = window.getComputedStyle(element);\n",
       "    const originalWidth = computedStyle.width;\n",
       "    const originalHTML = element.innerHTML.replace('Copied!', '');\n",
       "\n",
       "    navigator.clipboard.writeText(fullParamName)\n",
       "        .then(() => {\n",
       "            element.style.width = originalWidth;\n",
       "            element.style.color = 'green';\n",
       "            element.innerHTML = \"Copied!\";\n",
       "\n",
       "            setTimeout(() => {\n",
       "                element.innerHTML = originalHTML;\n",
       "                element.style = originalStyle;\n",
       "            }, 2000);\n",
       "        })\n",
       "        .catch(err => {\n",
       "            console.error('Failed to copy:', err);\n",
       "            element.style.color = 'red';\n",
       "            element.innerHTML = \"Failed!\";\n",
       "            setTimeout(() => {\n",
       "                element.innerHTML = originalHTML;\n",
       "                element.style = originalStyle;\n",
       "            }, 2000);\n",
       "        });\n",
       "    return false;\n",
       "}\n",
       "\n",
       "document.querySelectorAll('.copy-paste-icon').forEach(function(element) {\n",
       "    const toggleableContent = element.closest('.sk-toggleable__content');\n",
       "    const paramPrefix = toggleableContent ? toggleableContent.dataset.paramPrefix : '';\n",
       "    const paramName = element.parentElement.nextElementSibling\n",
       "        .textContent.trim().split(' ')[0];\n",
       "    const fullParamName = paramPrefix ? `${paramPrefix}${paramName}` : paramName;\n",
       "\n",
       "    element.setAttribute('title', fullParamName);\n",
       "});\n",
       "\n",
       "\n",
       "/**\n",
       " * Adapted from Skrub\n",
       " * https://github.com/skrub-data/skrub/blob/403466d1d5d4dc76a7ef569b3f8228db59a31dc3/skrub/_reporting/_data/templates/report.js#L789\n",
       " * @returns \"light\" or \"dark\"\n",
       " */\n",
       "function detectTheme(element) {\n",
       "    const body = document.querySelector('body');\n",
       "\n",
       "    // Check VSCode theme\n",
       "    const themeKindAttr = body.getAttribute('data-vscode-theme-kind');\n",
       "    const themeNameAttr = body.getAttribute('data-vscode-theme-name');\n",
       "\n",
       "    if (themeKindAttr && themeNameAttr) {\n",
       "        const themeKind = themeKindAttr.toLowerCase();\n",
       "        const themeName = themeNameAttr.toLowerCase();\n",
       "\n",
       "        if (themeKind.includes(\"dark\") || themeName.includes(\"dark\")) {\n",
       "            return \"dark\";\n",
       "        }\n",
       "        if (themeKind.includes(\"light\") || themeName.includes(\"light\")) {\n",
       "            return \"light\";\n",
       "        }\n",
       "    }\n",
       "\n",
       "    // Check Jupyter theme\n",
       "    if (body.getAttribute('data-jp-theme-light') === 'false') {\n",
       "        return 'dark';\n",
       "    } else if (body.getAttribute('data-jp-theme-light') === 'true') {\n",
       "        return 'light';\n",
       "    }\n",
       "\n",
       "    // Guess based on a parent element's color\n",
       "    const color = window.getComputedStyle(element.parentNode, null).getPropertyValue('color');\n",
       "    const match = color.match(/^rgb\\s*\\(\\s*(\\d+)\\s*,\\s*(\\d+)\\s*,\\s*(\\d+)\\s*\\)\\s*$/i);\n",
       "    if (match) {\n",
       "        const [r, g, b] = [\n",
       "            parseFloat(match[1]),\n",
       "            parseFloat(match[2]),\n",
       "            parseFloat(match[3])\n",
       "        ];\n",
       "\n",
       "        // https://en.wikipedia.org/wiki/HSL_and_HSV#Lightness\n",
       "        const luma = 0.299 * r + 0.587 * g + 0.114 * b;\n",
       "\n",
       "        if (luma > 180) {\n",
       "            // If the text is very bright we have a dark theme\n",
       "            return 'dark';\n",
       "        }\n",
       "        if (luma < 75) {\n",
       "            // If the text is very dark we have a light theme\n",
       "            return 'light';\n",
       "        }\n",
       "        // Otherwise fall back to the next heuristic.\n",
       "    }\n",
       "\n",
       "    // Fallback to system preference\n",
       "    return window.matchMedia('(prefers-color-scheme: dark)').matches ? 'dark' : 'light';\n",
       "}\n",
       "\n",
       "\n",
       "function forceTheme(elementId) {\n",
       "    const estimatorElement = document.querySelector(`#${elementId}`);\n",
       "    if (estimatorElement === null) {\n",
       "        console.error(`Element with id ${elementId} not found.`);\n",
       "    } else {\n",
       "        const theme = detectTheme(estimatorElement);\n",
       "        estimatorElement.classList.add(theme);\n",
       "    }\n",
       "}\n",
       "\n",
       "forceTheme('sk-container-id-7');</script></body>"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 33
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. Визуализация предсказанных кривых"
   ],
   "id": "vis_title"
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2026-05-05T15:30:30.720782500Z",
     "start_time": "2026-05-05T15:30:30.525547600Z"
    }
   },
   "source": [
    "X_plot = np.linspace(-25, 25, 500).reshape(-1, 1)\n",
    "\n",
    "plt.figure(figsize=(10, 6))\n",
    "plt.scatter(X_feat, y_feat, c='steelblue', alpha=0.3, label='Данные')\n",
    "plt.plot(X_plot, poly_model.predict(X_plot),   color='red',   lw=2, label='PolynomialFeatures (degree=7)')\n",
    "plt.plot(X_plot, spline_model.predict(X_plot), color='green', lw=2, label='SplineTransformer (n_knots=10)')\n",
    "plt.xlabel('Разность торков (left - right)')\n",
    "plt.ylabel('Класс')\n",
    "plt.title('Polynomial and Spline Interpolation на balance-scale')\n",
    "plt.yticks([-1, 0, 1], ['R (-1)', 'B (0)', 'L (+1)'])\n",
    "plt.legend()\n",
    "plt.show()"
   ],
   "id": "vis",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data",
     "jetTransient": {
      "display_id": null
     }
    }
   ],
   "execution_count": 34
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5. Интерпретация результатов\n",
    "\n",
    "- **Наблюдаемые эффекты**:  \n",
    "  - Оба метода аппроксимируют знаковую зависимость: при положительной разности торков — класс L, при отрицательной — R, при нулевой — B.\n",
    "  - **PolynomialFeatures** даёт гладкую глобальную кривую, но на краях диапазона возникают нежелательные выбросы.\n",
    "  - **SplineTransformer** аппроксимирует функцию локально — более устойчив на краях и точнее передаёт более резкий переход у нуля.\n",
    "\n",
    "- **Практическая значимость**:  \n",
    "  - Физика задачи (закон момента сил) полностью описывается одним признаком — разностью торков. Оба трансформера позволяют линейной модели уловить эту нелинейную зависимость.\n",
    "  - SplineTransformer предпочтительнее там, где функция имеет резкие переходы или неравномерное распределение данных."
   ],
   "id": "interpretation"
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "name": "python",
   "version": "3.10.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}