Seleção de Modelo para Regressão Lasso

Introdução

Neste laboratório, aprenderemos sobre a seleção do melhor hiperparâmetro alfa para modelos de regressão Lasso. Dois métodos serão discutidos: (1) seleção do valor ótimo de alfa usando apenas o conjunto de treino e algum critério de informação, e (2) seleção do melhor hiperparâmetro usando validação cruzada. Usaremos o conjunto de dados de diabetes neste exemplo.

Dicas da Máquina Virtual

Após o arranque da VM, clique no canto superior esquerdo para mudar para a aba Notebook para aceder ao Jupyter Notebook para a prática.

Por vezes, pode ser necessário esperar alguns segundos para o Jupyter Notebook terminar de carregar. A validação das operações não pode ser automatizada devido a limitações no Jupyter Notebook.

Se tiver problemas durante o aprendizado, não hesite em contactar o Labby. Forneça feedback após a sessão e resolveremos o problema rapidamente para si.

Conjunto de Dados

Primeiro, carregaremos o conjunto de dados de diabetes usando a função load_diabetes de sklearn.datasets. O conjunto de dados consiste em 10 variáveis ​​de base, idade, sexo, índice de massa corporal, pressão arterial média e seis medições de soro sanguíneo, e uma medida quantitativa da progressão da doença um ano após a linha de base.

from sklearn.datasets import load_diabetes

X, y = load_diabetes(return_X_y=True, as_frame=True)
X.head()

Adicionando Recursos Aleatórios

Vamos adicionar alguns recursos aleatórios aos dados originais para melhor ilustrar a seleção de recursos realizada pelo modelo Lasso. Os recursos aleatórios serão gerados usando a função RandomState do numpy.

import numpy as np
import pandas as pd

rng = np.random.RandomState(42)
n_random_features = 14
X_random = pd.DataFrame(
    rng.randn(X.shape[0], n_random_features),
    columns=[f"random_{i:02d}" for i in range(n_random_features)],
)
X = pd.concat([X, X_random], axis=1)
X[X.columns[::3]].head()

Selecionando Lasso via um Critério de Informação

Usaremos a função LassoLarsIC de sklearn.linear_model para fornecer um estimador Lasso que utiliza o critério de informação de Akaike (AIC) ou o critério de informação de Bayes (BIC) para selecionar o valor ótimo do parâmetro de regularização alfa. Primeiro, ajustaremos um modelo Lasso com o critério AIC.

import time
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LassoLarsIC
from sklearn.pipeline import make_pipeline

start_time = time.time()
lasso_lars_ic = make_pipeline(StandardScaler(), LassoLarsIC(criterion="aic")).fit(X, y)
fit_time = time.time() - start_time

Armazenando Resultados e Verificando Alfa Ótimo

Armazenaremos a métrica AIC para cada valor de alfa usado durante o fit. Em seguida, realizaremos a mesma análise usando o critério BIC. Finalmente, verificaremos qual valor de alpha leva ao AIC e BIC mínimos.

results = pd.DataFrame(
    {
        "alphas": lasso_lars_ic[-1].alphas_,
        "AIC criterion": lasso_lars_ic[-1].criterion_,
    }
).set_index("alphas")
alpha_aic = lasso_lars_ic[-1].alpha_

lasso_lars_ic.set_params(lassolarsic__criterion="bic").fit(X, y)
results["BIC criterion"] = lasso_lars_ic[-1].criterion_
alpha_bic = lasso_lars_ic[-1].alpha_

def highlight_min(x):
    x_min = x.min()
    return ["font-weight: bold" if v == x_min else "" for v in x]

results.style.apply(highlight_min)

Plotando Valores de AIC e BIC

Finalmente, plotaremos os valores de AIC e BIC para os diferentes valores de alfa. As linhas verticais no gráfico correspondem ao alfa escolhido para cada critério. O alfa selecionado corresponde ao mínimo do critério AIC ou BIC.

ax = results.plot()
ax.vlines(
    alpha_aic,
    results["AIC criterion"].min(),
    results["AIC criterion"].max(),
    label="alpha: estimativa AIC",
    linestyles="--",
    color="tab:blue",
)
ax.vlines(
    alpha_bic,
    results["BIC criterion"].min(),
    results["BIC criterion"].max(),
    label="alpha: estimativa BIC",
    linestyle="--",
    color="tab:orange",
)
ax.set_xlabel(r"$\alpha$")
ax.set_ylabel("critério")
ax.set_xscale("log")
ax.legend()
_ = ax.set_title(
    f"Critério de informação para seleção de modelo (tempo de treinamento {fit_time:.2f}s)"
)

Selecionando Lasso via Validação Cruzada

Usaremos dois estimadores diferentes para selecionar o melhor hiperparâmetro alfa com validação cruzada integrada: LassoCV e LassoLarsCV. Para ambos os algoritmos, usaremos uma estratégia de validação cruzada de 20 dobras.

Lasso via Descida de Coordenadas

Realizaremos a afinação de hiperparâmetros usando LassoCV.

from sklearn.linear_model import LassoCV

start_time = time.time()
model = make_pipeline(StandardScaler(), LassoCV(cv=20)).fit(X, y)
fit_time = time.time() - start_time

Lasso via Regressão de Ângulo Mínimo

Realizaremos a afinação de hiperparâmetros usando LassoLarsCV.

from sklearn.linear_model import LassoLarsCV

start_time = time.time()
model = make_pipeline(StandardScaler(), LassoLarsCV(cv=20)).fit(X, y)
fit_time = time.time() - start_time

Resumo da Abordagem de Validação Cruzada

Ambos os algoritmos produzem resultados aproximadamente iguais. O Lars calcula um caminho de solução apenas para cada ponto de inflexão no caminho. Como resultado, é muito eficiente quando existem poucos pontos de inflexão, o que ocorre se houver poucas características ou amostras. Por outro lado, a descida de coordenadas calcula os pontos do caminho em uma grade pré-especificada (aqui usamos o padrão). Portanto, é mais eficiente se o número de pontos da grade for menor que o número de pontos de inflexão no caminho. Essa estratégia pode ser interessante se o número de características for realmente grande e houver amostras suficientes para serem selecionadas em cada uma das dobras de validação cruzada. Em termos de erros numéricos, para variáveis fortemente correlacionadas, o Lars acumulará mais erros, enquanto o algoritmo de descida de coordenadas apenas amostrará o caminho em uma grade.

Sumário

Neste laboratório, aprendemos sobre a seleção do melhor hiperparâmetro alfa para modelos de regressão Lasso. Discutimos duas abordagens: (1) selecionar o valor ótimo de alfa usando apenas o conjunto de treinamento e algum critério de informação, e (2) selecionar o melhor hiperparâmetro usando validação cruzada. Usamos o conjunto de dados de diabetes neste exemplo. Ambas as abordagens podem funcionar de forma semelhante, mas a seleção de hiperparâmetros intra-amostra demonstra sua eficácia em termos de desempenho computacional. No entanto, ela só pode ser usada quando o número de amostras é suficientemente grande em comparação com o número de características. A otimização de hiperparâmetros por meio de validação cruzada é uma estratégia segura que funciona em diferentes cenários.