+ 
+ 
+
+
+# Regularização L1 e L2 - Esfinge
+
+
+
+
+  + Prof. Dr. Daniel R. Cassar + + |
+
+
+  + Vinícius Marianno de Marque Cutolo + + |
+
+
+
+
diff --git "a/Aprendizado de M\303\241quina/Regulariza\303\247\303\243o/T26 - Vin\303\255cius Marianno De Marque Cutolo/T26 - Vin\303\255cius Marianno De Marque Cutolo.ipynb" "b/Aprendizado de M\303\241quina/Regulariza\303\247\303\243o/T26 - Vin\303\255cius Marianno De Marque Cutolo/T26 - Vin\303\255cius Marianno De Marque Cutolo.ipynb"
new file mode 100644
index 0000000..a5d4483
--- /dev/null
+++ "b/Aprendizado de M\303\241quina/Regulariza\303\247\303\243o/T26 - Vin\303\255cius Marianno De Marque Cutolo/T26 - Vin\303\255cius Marianno De Marque Cutolo.ipynb"
@@ -0,0 +1,17366 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "0edc8983",
+ "metadata": {},
+ "source": [
+ "# [Regularização L1 e L2: escolhendo uma solução entre dados redundantes](#toc0_)\n",
+ "\n",
+ "Autor: Vinícius Marianno de Marque Cutolo\n",
+ "\n",
+ "RM: 2610042\n",
+ "\n",
+ "Professor: Daniel Roberto Cassar"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "dd6a3251",
+ "metadata": {},
+ "source": [
+ "**Sumário** \n",
+ "- [Regularização L1 e L2: escolhendo uma solução entre dados redundantes](#toc1_) \n",
+ " - [Introdução](#toc1_1_1_) \n",
+ " - [Regressão Linear simples](#toc1_1_2_) \n",
+ " - [Evidenciação do problema](#toc1_1_3_) \n",
+ " - [Sistemas mal-condicionados](#toc1_1_3_1_) \n",
+ " - [Sistemas sub-determinados](#toc1_1_3_2_) \n",
+ " - [L2: penalização nos pesos](#toc1_1_4_) \n",
+ " - [L1: regularização geométrica](#toc1_1_5_) \n",
+ " - [Exemplos teóricos](#toc1_1_6_) \n",
+ " - [Valor de casas em terrenos](#toc1_1_6_1_) \n",
+ " - [Sistema Linear possível e indeterminado](#toc1_1_6_2_) \n",
+ " - [Exemplo prático - EEG para prever tendência de movimento](#toc1_1_7_) \n",
+ " - [Pegando os dados do Dataset](#toc1_1_7_1_) \n",
+ " - [Tratando o EEG](#toc1_1_7_2_) \n",
+ " - [Separação de dados em treino e teste](#toc1_1_7_3_) \n",
+ " - [Modelos preditivos](#toc1_1_7_4_) \n",
+ " - [Apêndice](#toc1_1_8_) \n",
+ " - [Referências](#toc1_1_9_) \n",
+ "\n",
+ "\n",
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "b86a1d42",
+ "metadata": {},
+ "source": [
+ "### [Introdução](#toc0_)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "069f26ba",
+ "metadata": {},
+ "source": [
+ "\n",
+ "Imagine uma regressão linear $\\hat{y}=Xw$ e uma função de erro quadrático $J(w)=||y-Xw||_2^2$. Treinar um modelo significa minimizar $J(w)$ e achar o $w$ que melhor explica o problema, porém, nos deparamos com um grande problema.\n",
+ "\n",
+ "Imagine que os termos de $X$ não sejam independente, existe uma correlação entre eles e alguns são até redundantes. Isso ocorre principalmente quando há correlação forte entre os atributos ou uma quantidade muito maior de atributos do que exemplos, chamados de sistemas mal-condicionados (quando há uma correlação muito forte entre os termos) e sub-determinados (quando há muito mais atributos do que exemplos). \n",
+ "\n",
+ "Ambas as condições são definidas de forma simplificada, mal-condicionamento tem relação com a colinearidade das colunas da matriz de teste (algumas colunas podem ser aproximadas como combinações lineares das outra). Enquanto isso, sub-determinação nao só sobre disparidade entre atributos e exemplos, seria sobre a diferença entre exemplos linearmente independentes e incógnitas no nosso sistema. Com isso explicado, vamos nos referir a forma simplificada das condições daqui para frente, com o objetivo de tornar essa jornada mais didática.\n",
+ "\n",
+ "Para aprofundar esses problemas, algumas células de código foram criadas para mostrar, graficamente, como que esse problema existe. \n",
+ "\n",
+ "Como exemplo de cada caso, situações simples serão usadas para nos aprofundarmos na solução por L1 e L2. Para o caso mal-condicionado, iremos tentar prever o valor de uma casa usando a área em pés quadrados e em metros quadrados. Para o caso sub-determinado, continuaremos na algebra linear: prever o resultado de três parâmetros tendo somente duas equações que os correlacione. Cada qual será desenvolvido mais em suas respectivas sessões.\n",
+ "\n",
+ "Enfim, para testar a aplicabilidade dessa técnica, trataremos de um exemplo pratico a ser resolvido: interpretação de leitura de eletroencefalograma (EEG) para previsão de velocidade do punho. Esse problema é interessante pois os canais são fortemente correlacionados espacialmente, mal-condicionado, e há exemplos muito ruidosos. Ademais, existe muita redundância de informações dentro do sistema, podendo ser ou nao ser um caso de sub-determinação, mas não podemos garantir isso. Com isso, chegamos à pergunta motivadora:\n",
+ "\n",
+ "*Dado que existem vários w's que explicam igualmente, ou quase igualmente, bem o problema, qual devemos escolher?*\n",
+ "\n",
+ "Claro, a resposta poderia ser simplesmente 'aquele que diminua o erro', mas a regularização adiciona uma outra preferência. Ao invés de reduzir $J(w)$, a regularização L1 e L2 preza por reduzir (1).\n",
+ "\n",
+ "$$\n",
+ "(1)\\qquad J(w)+\\lambda R(w) \\qquad \n",
+ "$$\n",
+ "[[1]](#toceq_1_) [[3]](#toceq_3_)\n",
+ "\n",
+ "em que:\n",
+ "\n",
+ "1. $J(w)$ ajusta os dados\n",
+ "2. $R(w)$ penaliza os parâmetros\n",
+ "3. $\\lambda$ representa o compromisso entre o ajuste dos dados e a regularização de $R(w)$\n",
+ "\n",
+ "Aos que ainda não estão familiarizados com a formula, aguarde até a próxima sessão [Regressão Linear simples](#toc1_1_2_) que isso será melhor explicado. Aviso de antemão que o leitor deve ter um conhecimento mínimo de algebra linear para entender algumas das discussões, em especial, a noção que sistemas lineares podem ser escritos na forma matricial $X\\omega = \\hat{y}$. Com $X$ sendo a tabela de dados, $\\omega$ sendo o vetor de pesos da resposta e $\\hat{y}$ o vetor resposta.\n",
+ "\n",
+ "Uma das maiores utilidades dessa técnica é evitar algo denominado de overfitting,que é um fenômeno que ocorre quando um modelo se ajusta muito aos dados fornecidos e não consegue generalizar para outros [[2]](#toceq_2_). Isso ocorre porque a regularização permite mudar a preferencia estrutural do problema [[3]](#toceq_3_), que impedem uma supervalorização da interpolação pura. Contudo, a regularização L1 e L2 não está restrita a ser somente uma técnica para evitar overfitting, a sua aplicação gera um restrição do próprio espaço de soluções, sendo ótimo para forçar condições de contorno na estrutura da solução.\n",
+ "\n",
+ "A seguir, o notebook irá seguir a seguinte forma:\n",
+ "\n",
+ "Regressão Linear $\\rightarrow$ Evidenciação do problema $\\rightarrow$ L2 $\\rightarrow$ L1 $\\rightarrow$ exemplos teóricos $\\rightarrow$ exemplo prático\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "89357ebb",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Bibliotecas que serão usadas no projeto\n",
+ "from pathlib import Path\n",
+ "\n",
+ "import matplotlib.pyplot as plt\n",
+ "import numpy as np\n",
+ "import pandas as pd\n",
+ "from scipy.io import loadmat\n",
+ "from scipy.signal import butter, resample_poly, savgol_filter, sosfilt, sosfilt_zi\n",
+ "from sklearn.linear_model import (\n",
+ " Lasso,\n",
+ " LassoCV,\n",
+ " LinearRegression,\n",
+ " MultiTaskLassoCV,\n",
+ " Ridge,\n",
+ " RidgeCV,\n",
+ ")\n",
+ "from sklearn.metrics import mean_absolute_error, mean_squared_error, r2_score\n",
+ "from sklearn.model_selection import (\n",
+ " GroupKFold,\n",
+ " GroupShuffleSplit,\n",
+ " cross_val_score,\n",
+ " train_test_split,\n",
+ ")\n",
+ "from sklearn.pipeline import make_pipeline\n",
+ "from sklearn.preprocessing import StandardScaler # type: ignore\n",
+ "\n",
+ "# RNG padrão para reprodutibilidade\n",
+ "rng = np.random.default_rng(42)\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "5d335b2f",
+ "metadata": {},
+ "source": [
+ "---\n",
+ "### [Regressão Linear simples](#toc0_)\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "bbd89d6f",
+ "metadata": {},
+ "source": [
+ "Imagine a seguinte situação, você tem um conjunto de dados distribuídos de tal forma que haja uma certa tendência linear entre eles. Porém, o grande problema: não existe uma reta específica que consiga passar por todos os pontos.\n",
+ "\n",
+ "Queremos um modelo capaz de se ajustar aos dados que temos com uma boa precisão, mas como escolher a reta ideal que melhor explique essa distribuição de dados? Para começarmos, imagine que estamos usando a seguinte reta para modelar o nosso problema [[1]](#toceq_1_):\n",
+ "\n",
+ "$$\\hat{y} = b+ \\omega x$$\n",
+ "\n",
+ "Em que:\n",
+ "\n",
+ "1. $\\hat{y}$ é o valor previsto pelo nosso modelo.\n",
+ "\n",
+ "2. $b$ é o coeficiente linear da reta, chamado também de valor basal da reta.\n",
+ "\n",
+ "3. $\\omega$ é o coeficiente angular da reta.\n",
+ "\n",
+ "4. $x$ variável de entrada\n",
+ "\n",
+ "5. $y$ é o valor real da previsão\n",
+ "\n",
+ "Para podermos chamar essa reta de boa, sabemos que $\\hat{y}$ tem que se aproximar o máximo de $y$ para cada $x$ testado. Uma forma de mensurarmos isso é avaliar o resíduo deixado por cada previsão, denotado por $e_i=y-\\hat{y}_i$. Cada resíduo irá dizer o quanto o modelo errou naquela previsão, agora basta somar todos e minimizar o resíduo, né? Um problema logo surge, podem existir componentes negativas nessa soma, o que artificialmente reduziriam o resíduo resultante mesmo o modelo não sendo bom. Para resolver isso, diversas formas foram desenvolvidas, mas duas são mais reconhecidas nesse assunto: podemos tirar o módulo de todos os termos ou elevar termo a termo ao quadrado. \n",
+ "\n",
+ "Ambos são válidos, mas nesse notebook usaremos o mais comum para a função de perda: o erro quadrático (segunda opção). Porque? É bem simples na realidade, a sua derivação é mais conveniente. Mais a frente, trataremos da derivação de funções absolutas, mas, no momento, seguiremos com aquela que torna a derivação mais suave e apresenta solução analítica fixa por **Mínimos Quadrados**, que será apresentado posteriormente. Entretanto, quero deixar algo bem claro: nenhuma é superior a outra, cada tipo de erro tem seus pontos fortes e fracos, não existe um inatamente superior [[1]](#toceq_1_).\n",
+ "\n",
+ "A minimização da soma dos resíduos ao quadrado é chamada de **Mínimos Quadrados** e é uma técnica de minimização de erro muito utilizado dentro do ramo. Ele não surge de alguma propriedade da natureza, é uma escolha de modelagem, isso também irá justificar as regularizações logo abaixo. Além desse somatório, dividimos tudo por $2n$, com $n$ sendo o número de previsões disponíveis. Contudo, porque faríamos isso? Tirar a média dos erros não diminui o valor comparativo dentro do mesmo contexto, um erro maior continua sendo maior que os outros. A vantagem disso está no valor comparativo entre retas do mesmo problema com números de observações diferentes. Sem ele, adicionar uma previsão a mair aumentaria o erro mesmo que, talvez, melhorasse a reta, por isso tiramos a média.\n",
+ "\n",
+ "Entretanto, porque o $2$? Simples, por estética. Quando derivamos essa função para minimizá-la, surge um fator de $2$ advindo do expoente, colocamos o meio para que ele suma e so precisemos trabalhar com matrizes e números puros (sem fatores multiplicativos). Como dividir todos os erros que existem por uma constante não irá mudar nada, que mal tem? Esse fator do $2$ é uma escolha da modelagem, por isso, pode ser removido e adicionado dentro de qualquer problema do gênero, tanto que isso será feito dentro da sessão de L1.\n",
+ "\n",
+ "Depois de toda essa discussão, temos, enfim, a função final do erro de uma reta:\n",
+ "\n",
+ "$$J(\\omega, b)=\\frac{1}{2n}\\sum_{i=1}^n [y_i-(b+\\omega x_i)]^2$$\n",
+ "\n",
+ "Veja agora esse princípio em ação."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 131,
+ "id": "65cfaa20",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# valores teste de b e omega\n",
+ "b_values = np.linspace(-10,10, 1001)\n",
+ "w_values = np.linspace(-10,10, 1001)\n",
+ "\n",
+ "b_true = rng.choice(b_values)\n",
+ "w_true = rng.choice(w_values)\n",
+ "\n",
+ "x = np.linspace(0, 10, 501)\n",
+ "\n",
+ "y_true = b_true+w_true*x + rng.normal(0,0.9,x.shape)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 132,
+ "id": "f97b42a8",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ "| \n", + " | Área em m² | \n", + "Área em cm² | \n", + "Área em pés² | \n", + "Área em palmos² | \n", + "
|---|---|---|---|---|
| 0 | \n", + "632.006331 | \n", + "6.324051e+06 | \n", + "6778.125508 | \n", + "13038.470867 | \n", + "
| 1 | \n", + "869.178634 | \n", + "8.645061e+06 | \n", + "9292.698800 | \n", + "17829.160761 | \n", + "
| 2 | \n", + "104.222668 | \n", + "1.042248e+06 | \n", + "1120.522942 | \n", + "2152.968103 | \n", + "
| 3 | \n", + "866.647337 | \n", + "8.654786e+06 | \n", + "9319.596593 | \n", + "17978.652678 | \n", + "
| 4 | \n", + "657.769480 | \n", + "6.578684e+06 | \n", + "7075.453973 | \n", + "13556.772071 | \n", + "
| ... | \n", + "... | \n", + "... | \n", + "... | \n", + "... | \n", + "
| 295 | \n", + "717.094191 | \n", + "7.156473e+06 | \n", + "7696.617114 | \n", + "14818.920791 | \n", + "
| 296 | \n", + "120.900704 | \n", + "1.212176e+06 | \n", + "1305.527248 | \n", + "2498.760558 | \n", + "
| 297 | \n", + "460.315756 | \n", + "4.588131e+06 | \n", + "4942.843136 | \n", + "9501.948586 | \n", + "
| 298 | \n", + "889.522076 | \n", + "8.904447e+06 | \n", + "9534.056064 | \n", + "18377.129458 | \n", + "
| 299 | \n", + "646.912721 | \n", + "6.491615e+06 | \n", + "6987.428026 | \n", + "13390.106007 | \n", + "
300 rows × 4 columns
\n", + "Pipeline(steps=[('standardscaler', StandardScaler()),\n",
+ " ('linearregression', LinearRegression())])In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook. | Name | \n", + "Type | \n", + "Value | \n", + "
|---|---|---|
| \n",
+ " \n",
+ " n_features_in_\n",
+ " \n",
+ " n_features_in_: int Number of features seen during :term:`fit`. Only defined if the underlying first estimator in `steps` exposes such an attribute when fit. .. versionadded:: 0.24\n", + " \n", + " | \n",
+ " int | \n", + "4 | \n", + "\n", + "\n", + "
| x0 | \n", + "
| x1 | \n", + "
| x2 | \n", + "
| x3 | \n", + "
Pipeline(steps=[('standardscaler', StandardScaler()), ('ridgecv', RidgeCV())])In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook. | Name | \n", + "Type | \n", + "Value | \n", + "
|---|---|---|
| \n",
+ " \n",
+ " n_features_in_\n",
+ " \n",
+ " n_features_in_: int Number of features seen during :term:`fit`. Only defined if the underlying first estimator in `steps` exposes such an attribute when fit. .. versionadded:: 0.24\n", + " \n", + " | \n",
+ " int | \n", + "4 | \n", + "\n", + "\n", + "
| x0 | \n", + "
| x1 | \n", + "
| x2 | \n", + "
| x3 | \n", + "
Pipeline(steps=[('standardscaler', StandardScaler()), ('lassocv', LassoCV())])In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook. | Name | \n", + "Type | \n", + "Value | \n", + "
|---|---|---|
| \n",
+ " \n",
+ " n_features_in_\n",
+ " \n",
+ " n_features_in_: int Number of features seen during :term:`fit`. Only defined if the underlying first estimator in `steps` exposes such an attribute when fit. .. versionadded:: 0.24\n", + " \n", + " | \n",
+ " int | \n", + "4 | \n", + "\n", + "\n", + "
| x0 | \n", + "
| x1 | \n", + "
| x2 | \n", + "
| x3 | \n", + "
| Name | \n", + "Type | \n", + "Value | \n", + "
|---|---|---|
| \n",
+ " \n",
+ " alpha_\n",
+ " \n",
+ " alpha_: float The amount of penalization chosen by cross validation.\n", + " \n", + " | \n",
+ " float64 | \n", + "598.6 | \n", + "\n", + "\n", + "
| \n",
+ " \n",
+ " alphas_\n",
+ " \n",
+ " alphas_: ndarray of shape (n_alphas,) The grid of alphas used for fitting.\n", + " \n", + " | \n",
+ " ndarray[float64](100,) | \n", + "[520647.31,485557.42,452832.48,..., 598.62, 558.27, 520.65] | \n", + "\n", + "\n", + "
| \n",
+ " \n",
+ " coef_\n",
+ " \n",
+ " coef_: ndarray of shape (n_features,) or (n_targets, n_features) Parameter vector (w in the cost function formula).\n", + " \n", + " | \n",
+ " ndarray[float64](4,) | \n", + "[520011.06, 51.54, 0. , 0. ] | \n", + "\n", + "\n", + "
| \n",
+ " \n",
+ " dual_gap_\n",
+ " \n",
+ " dual_gap_: float or ndarray of shape (n_targets,) The dual gap at the end of the optimization for the optimal alpha (``alpha_``).\n", + " \n", + " | \n",
+ " float64 | \n", + "1.34e+07 | \n", + "\n", + "\n", + "
| \n",
+ " \n",
+ " intercept_\n",
+ " \n",
+ " intercept_: float or ndarray of shape (n_targets,) Independent term in decision function.\n", + " \n", + " | \n",
+ " float64 | \n", + "1.215e+06 | \n", + "\n", + "\n", + "
| \n",
+ " \n",
+ " mse_path_\n",
+ " \n",
+ " mse_path_: ndarray of shape (n_alphas, n_folds) Mean square error for the test set on each fold, varying alpha.\n", + " \n", + " | \n",
+ " ndarray[float64](100, 5) | \n", + "[[2.87e+11,2.78e+11,2.94e+11,3.00e+11,2.02e+11],\n", + " [2.56e+11,2.45e+11,2.65e+11,2.73e+11,1.76e+11],\n", + " [2.22e+11,2.13e+11,2.31e+11,2.38e+11,1.53e+11],\n", + " ...,\n", + " [1.49e+09,1.67e+09,1.74e+09,1.81e+09,1.67e+09],\n", + " [1.49e+09,1.67e+09,1.74e+09,1.81e+09,1.66e+09],\n", + " [1.49e+09,1.67e+09,1.74e+09,1.81e+09,1.66e+09]] | \n", + "\n", + "\n", + "
| \n",
+ " \n",
+ " n_features_in_\n",
+ " \n",
+ " n_features_in_: int Number of features seen during :term:`fit`. .. versionadded:: 0.24\n", + " \n", + " | \n",
+ " int | \n", + "4 | \n", + "\n", + "\n", + "
| \n",
+ " \n",
+ " n_iter_\n",
+ " \n",
+ " n_iter_: int Number of iterations run by the coordinate descent solver to reach the specified tolerance for the optimal alpha.\n", + " \n", + " | \n",
+ " int | \n", + "2 | \n", + "\n", + "\n", + "
Pipeline(steps=[('linearregression', LinearRegression())])In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook. | Name | \n", + "Type | \n", + "Value | \n", + "
|---|---|---|
| \n",
+ " \n",
+ " n_features_in_\n",
+ " \n",
+ " n_features_in_: int Number of features seen during :term:`fit`. Only defined if the underlying first estimator in `steps` exposes such an attribute when fit. .. versionadded:: 0.24\n", + " \n", + " | \n",
+ " int | \n", + "200 | \n", + "\n", + "\n", + "
Pipeline(steps=[('ridgecv', RidgeCV())])In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook. | Name | \n", + "Type | \n", + "Value | \n", + "
|---|---|---|
| \n",
+ " \n",
+ " n_features_in_\n",
+ " \n",
+ " n_features_in_: int Number of features seen during :term:`fit`. Only defined if the underlying first estimator in `steps` exposes such an attribute when fit. .. versionadded:: 0.24\n", + " \n", + " | \n",
+ " int | \n", + "200 | \n", + "\n", + "\n", + "
Pipeline(steps=[('lassocv', LassoCV())])In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook. | Name | \n", + "Type | \n", + "Value | \n", + "
|---|---|---|
| \n",
+ " \n",
+ " n_features_in_\n",
+ " \n",
+ " n_features_in_: int Number of features seen during :term:`fit`. Only defined if the underlying first estimator in `steps` exposes such an attribute when fit. .. versionadded:: 0.24\n", + " \n", + " | \n",
+ " int | \n", + "200 | \n", + "\n", + "\n", + "
| Name | \n", + "Type | \n", + "Value | \n", + "
|---|---|---|
| \n",
+ " \n",
+ " alpha_\n",
+ " \n",
+ " alpha_: float The amount of penalization chosen by cross validation.\n", + " \n", + " | \n",
+ " float64 | \n", + "0.214 | \n", + "\n", + "\n", + "
| \n",
+ " \n",
+ " alphas_\n",
+ " \n",
+ " alphas_: ndarray of shape (n_alphas,) The grid of alphas used for fitting.\n", + " \n", + " | \n",
+ " ndarray[float64](100,) | \n", + "[86.38,80.56,75.13,..., 0.1 , 0.09, 0.09] | \n", + "\n", + "\n", + "
| \n",
+ " \n",
+ " coef_\n",
+ " \n",
+ " coef_: ndarray of shape (n_features,) or (n_targets, n_features) Parameter vector (w in the cost function formula).\n", + " \n", + " | \n",
+ " ndarray[float64](200,) | \n", + "[ 0.,-0., 0.,..., 0.,-0., 0.] | \n", + "\n", + "\n", + "
| \n",
+ " \n",
+ " dual_gap_\n",
+ " \n",
+ " dual_gap_: float or ndarray of shape (n_targets,) The dual gap at the end of the optimization for the optimal alpha (``alpha_``).\n", + " \n", + " | \n",
+ " float64 | \n", + "0.4124 | \n", + "\n", + "\n", + "
| \n",
+ " \n",
+ " intercept_\n",
+ " \n",
+ " intercept_: float or ndarray of shape (n_targets,) Independent term in decision function.\n", + " \n", + " | \n",
+ " float64 | \n", + "0.006865 | \n", + "\n", + "\n", + "
| \n",
+ " \n",
+ " mse_path_\n",
+ " \n",
+ " mse_path_: ndarray of shape (n_alphas, n_folds) Mean square error for the test set on each fold, varying alpha.\n", + " \n", + " | \n",
+ " ndarray[float64](100, 5) | \n", + "[[30016.91,18039.08,22881.53,22390.5 ,26395.98],\n", + " [29004.41,18036.99,22456.98,22390.5 ,26242.22],\n", + " [28049.61,18069.88,21202.75,21096.51,25506.67],\n", + " ...,\n", + " [ 0.94, 0.86, 1.96, 4.4 , 2.31],\n", + " [ 0.94, 0.86, 1.96, 4.4 , 2.31],\n", + " [ 0.94, 0.86, 1.96, 4.4 , 2.31]] | \n", + "\n", + "\n", + "
| \n",
+ " \n",
+ " n_features_in_\n",
+ " \n",
+ " n_features_in_: int Number of features seen during :term:`fit`. .. versionadded:: 0.24\n", + " \n", + " | \n",
+ " int | \n", + "200 | \n", + "\n", + "\n", + "
| \n",
+ " \n",
+ " n_iter_\n",
+ " \n",
+ " n_iter_: int Number of iterations run by the coordinate descent solver to reach the specified tolerance for the optimal alpha.\n", + " \n", + " | \n",
+ " int | \n", + "143 | \n", + "\n", + "\n", + "
Pipeline(steps=[('linearregression', LinearRegression())])In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook. | Name | \n", + "Type | \n", + "Value | \n", + "
|---|---|---|
| \n",
+ " \n",
+ " n_features_in_\n",
+ " \n",
+ " n_features_in_: int Number of features seen during :term:`fit`. Only defined if the underlying first estimator in `steps` exposes such an attribute when fit. .. versionadded:: 0.24\n", + " \n", + " | \n",
+ " int | \n", + "200 | \n", + "\n", + "\n", + "
Pipeline(steps=[('ridgecv', RidgeCV())])In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook. | Name | \n", + "Type | \n", + "Value | \n", + "
|---|---|---|
| \n",
+ " \n",
+ " n_features_in_\n",
+ " \n",
+ " n_features_in_: int Number of features seen during :term:`fit`. Only defined if the underlying first estimator in `steps` exposes such an attribute when fit. .. versionadded:: 0.24\n", + " \n", + " | \n",
+ " int | \n", + "200 | \n", + "\n", + "\n", + "
Pipeline(steps=[('lassocv', LassoCV())])In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook. | Name | \n", + "Type | \n", + "Value | \n", + "
|---|---|---|
| \n",
+ " \n",
+ " n_features_in_\n",
+ " \n",
+ " n_features_in_: int Number of features seen during :term:`fit`. Only defined if the underlying first estimator in `steps` exposes such an attribute when fit. .. versionadded:: 0.24\n", + " \n", + " | \n",
+ " int | \n", + "200 | \n", + "\n", + "\n", + "
| Name | \n", + "Type | \n", + "Value | \n", + "
|---|---|---|
| \n",
+ " \n",
+ " alpha_\n",
+ " \n",
+ " alpha_: float The amount of penalization chosen by cross validation.\n", + " \n", + " | \n",
+ " float64 | \n", + "1.266 | \n", + "\n", + "\n", + "
| \n",
+ " \n",
+ " alphas_\n",
+ " \n",
+ " alphas_: ndarray of shape (n_alphas,) The grid of alphas used for fitting.\n", + " \n", + " | \n",
+ " ndarray[float64](100,) | \n", + "[313.57,292.44,272.73,..., 0.36, 0.34, 0.31] | \n", + "\n", + "\n", + "
| \n",
+ " \n",
+ " coef_\n",
+ " \n",
+ " coef_: ndarray of shape (n_features,) or (n_targets, n_features) Parameter vector (w in the cost function formula).\n", + " \n", + " | \n",
+ " ndarray[float64](200,) | \n", + "[-118.91, -0. , 0. ,..., -42.26, 0. , -49.71] | \n", + "\n", + "\n", + "
| \n",
+ " \n",
+ " dual_gap_\n",
+ " \n",
+ " dual_gap_: float or ndarray of shape (n_targets,) The dual gap at the end of the optimization for the optimal alpha (``alpha_``).\n", + " \n", + " | \n",
+ " float64 | \n", + "236.1 | \n", + "\n", + "\n", + "
| \n",
+ " \n",
+ " intercept_\n",
+ " \n",
+ " intercept_: float or ndarray of shape (n_targets,) Independent term in decision function.\n", + " \n", + " | \n",
+ " float64 | \n", + "-100.1 | \n", + "\n", + "\n", + "
| \n",
+ " \n",
+ " mse_path_\n",
+ " \n",
+ " mse_path_: ndarray of shape (n_alphas, n_folds) Mean square error for the test set on each fold, varying alpha.\n", + " \n", + " | \n",
+ " ndarray[float64](100, 5) | \n", + "[[678850.11,529204.56,464296.78,614183.78,583961.8 ],\n", + " [675497.55,531102.77,459930.89,608131.31,578930.22],\n", + " [663357.35,533323.76,446579.03,604586.58,567157.31],\n", + " ...,\n", + " [346866.65,348664.16,498566.68,638426. ,423978.09],\n", + " [346866.65,348664.16,498566.68,638426. ,423978.09],\n", + " [346866.65,348664.16,498566.68,638426. ,423978.09]] | \n", + "\n", + "\n", + "
| \n",
+ " \n",
+ " n_features_in_\n",
+ " \n",
+ " n_features_in_: int Number of features seen during :term:`fit`. .. versionadded:: 0.24\n", + " \n", + " | \n",
+ " int | \n", + "200 | \n", + "\n", + "\n", + "
| \n",
+ " \n",
+ " n_iter_\n",
+ " \n",
+ " n_iter_: int Number of iterations run by the coordinate descent solver to reach the specified tolerance for the optimal alpha.\n", + " \n", + " | \n",
+ " int | \n", + "1000 | \n", + "\n", + "\n", + "
| \n", + " | RMSE_x | \n", + "RMSE_y | \n", + "RMSE_z | \n", + "MAE_x | \n", + "MAE_y | \n", + "MAE_z | \n", + "R2_x | \n", + "R2_y | \n", + "R2_z | \n", + "RMSE_3D | \n", + "
|---|---|---|---|---|---|---|---|---|---|---|
| Zero | \n", + "9.152011 | \n", + "17.244415 | \n", + "7.400191 | \n", + "3.858986 | \n", + "6.826493 | \n", + "3.862836 | \n", + "-1.716020e-04 | \n", + "-0.000192 | \n", + "-0.000069 | \n", + "20.878026 | \n", + "
| Média | \n", + "9.151230 | \n", + "17.242770 | \n", + "7.399945 | \n", + "3.878953 | \n", + "6.873428 | \n", + "3.865411 | \n", + "-9.914723e-07 | \n", + "-0.000001 | \n", + "-0.000002 | \n", + "20.876238 | \n", + "
| OLS | \n", + "7.390744 | \n", + "14.099833 | \n", + "6.663814 | \n", + "5.080020 | \n", + "9.439512 | \n", + "4.359965 | \n", + "3.477445e-01 | \n", + "0.331326 | \n", + "0.189058 | \n", + "17.257891 | \n", + "
| Ridge | \n", + "7.872509 | \n", + "15.013576 | \n", + "6.974713 | \n", + "4.965117 | \n", + "9.145764 | \n", + "4.263579 | \n", + "2.599384e-01 | \n", + "0.241851 | \n", + "0.111624 | \n", + "18.331134 | \n", + "
| Ridge (sem diferenciação de eixos) | \n", + "7.863540 | \n", + "14.987137 | \n", + "6.964946 | \n", + "4.942919 | \n", + "9.123380 | \n", + "4.251408 | \n", + "2.616239e-01 | \n", + "0.244519 | \n", + "0.114110 | \n", + "18.301913 | \n", + "
| Lasso | \n", + "7.854833 | \n", + "14.999359 | \n", + "6.954901 | \n", + "4.892087 | \n", + "9.013651 | \n", + "4.231553 | \n", + "2.632580e-01 | \n", + "0.243286 | \n", + "0.116664 | \n", + "18.304366 | \n", + "
| Lasso (sem diferenciação de eixos) | \n", + "7.848058 | \n", + "14.956426 | \n", + "7.015712 | \n", + "4.901228 | \n", + "9.024146 | \n", + "4.217838 | \n", + "2.645284e-01 | \n", + "0.247612 | \n", + "0.101149 | \n", + "18.289530 | \n", + "