Validação Cruzada com Modelos Lineares

Introdução

Neste laboratório, utilizaremos validação cruzada com modelos lineares. Usaremos o conjunto de dados de diabetes e aplicaremos GridSearchCV para encontrar o melhor valor de alfa para a regressão Lasso. Em seguida, plotaremos os erros e usaremos LassoCV para ver o quão confiável é a seleção de alfa.

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.

Às 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.

Carregar e preparar o conjunto de dados

Primeiro, carregaremos e prepararemos o conjunto de dados de diabetes. Apenas usaremos as primeiras 150 amostras neste exercício.

import matplotlib.pyplot as plt
import numpy as np
from sklearn import datasets

X, y = datasets.load_diabetes(return_X_y=True)
X = X[:150]
y = y[:150]

Aplicar GridSearchCV

Em seguida, aplicaremos GridSearchCV para encontrar o melhor valor de alfa para a regressão Lasso. Usaremos uma gama de valores de alfa de 10^-4 a 10^-0.5 com 30 valores intermédios. Usaremos 5 dobras para a validação cruzada.

from sklearn.linear_model import Lasso
from sklearn.model_selection import GridSearchCV

lasso = Lasso(random_state=0, max_iter=10000)
alphas = np.logspace(-4, -0.5, 30)

tuned_parameters = [{"alpha": alphas}]
n_folds = 5

clf = GridSearchCV(lasso, tuned_parameters, cv=n_folds, refit=False)
clf.fit(X, y)

Plotar os erros

Agora, plotaremos os erros para visualizar o melhor valor de alfa. Plotaremos as pontuações médias de teste e os erros padrão das pontuações.

scores = clf.cv_results_["mean_test_score"]
scores_std = clf.cv_results_["std_test_score"]

plt.figure().set_size_inches(8, 6)
plt.semilogx(alphas, scores)

std_error = scores_std / np.sqrt(n_folds)

plt.semilogx(alphas, scores + std_error, "b--")
plt.semilogx(alphas, scores - std_error, "b--")

plt.fill_between(alphas, scores + std_error, scores - std_error, alpha=0.2)

plt.ylabel("Pontuação CV +/- erro padrão")
plt.xlabel("alfa")
plt.axhline(np.max(scores), linestyle="--", color=".5")
plt.xlim([alphas[0], alphas[-1]])

Utilizar LassoCV para verificar a seleção de alfa

Finalmente, utilizaremos LassoCV para avaliar a confiabilidade da seleção de alfa. Usaremos KFold com 3 dobras.

from sklearn.linear_model import LassoCV
from sklearn.model_selection import KFold

lasso_cv = LassoCV(alphas=alphas, random_state=0, max_iter=10000)
k_fold = KFold(3)

print("Resposta à pergunta bônus:", "quanto você pode confiar na seleção de alfa?")
print()
print("Parâmetros Alfa maximizando a pontuação de generalização em diferentes")
print("subconjuntos dos dados:")
for k, (train, test) in enumerate(k_fold.split(X, y)):
    lasso_cv.fit(X[train], y[train])
    print(
        "[dobra {0}] alfa: {1:.5f}, pontuação: {2:.5f}".format(
            k, lasso_cv.alpha_, lasso_cv.score(X[test], y[test])
        )
    )

print()
print("Resposta: Não muito, pois obtivemos alfas diferentes para diferentes")
print("subconjuntos dos dados e, além disso, as pontuações para esses alfas diferem")
print("consideravelmente.")

Resumo

Neste laboratório, aprendemos como usar validação cruzada com modelos lineares. Usamos GridSearchCV para encontrar o melhor valor de alfa para a regressão Lasso e plotamos os erros para visualizar a seleção. Também usamos LassoCV para verificar a seleção de alfa.