Introdução
Neste tutorial, compararemos a Regressão de Ridge Kernel (KRR) e a Regressão Vetorial de Suporte (SVR) usando o Scikit-Learn, uma popular biblioteca de aprendizado de máquina em Python. Ambos os modelos aprendem uma função não linear empregando o truque do kernel. KRR e SVR diferem em suas funções de perda e métodos de ajuste. Usaremos um conjunto de dados artificial composto por uma função-alvo sinusoidal e ruído forte adicionado a cada quinto ponto de dados.
Dicas da Máquina Virtual
Após o início da VM, clique no canto superior esquerdo para mudar para a aba Notebook para acessar o Jupyter Notebook para praticar.
Às vezes, pode ser necessário aguardar alguns segundos para que o Jupyter Notebook termine de carregar. A validação de operações não pode ser automatizada devido a limitações no Jupyter Notebook.
Se você enfrentar problemas durante o aprendizado, sinta-se à vontade para perguntar ao Labby. Forneça feedback após a sessão e resolveremos prontamente o problema para você.
Gerar Dados de Amostra
Vamos gerar um conjunto de dados composto por uma função-alvo sinusoidal e ruído forte adicionado a cada quinto ponto de dados.
import numpy as np
## Gerar dados de amostra
rng = np.random.RandomState(42)
X = 5 * rng.rand(10000, 1)
y = np.sin(X).ravel()
## Adicionar ruído aos alvos
y[::5] += 3 * (0.5 - rng.rand(X.shape[0] // 5))
X_plot = np.linspace(0, 5, 100000)[:, None]
Construir os Modelos de Regressão Baseados em Kernel
Vamos construir os modelos KRR e SVR usando o GridSearchCV do Scikit-Learn para encontrar os melhores hiperparâmetros.
from sklearn.model_selection import GridSearchCV
from sklearn.svm import SVR
from sklearn.kernel_ridge import KernelRidge
train_size = 100
## Modelo SVR
svr = GridSearchCV(
SVR(kernel="rbf", gamma=0.1),
param_grid={"C": [1e0, 1e1, 1e2, 1e3], "gamma": np.logspace(-2, 2, 5)},
)
## Modelo KRR
kr = GridSearchCV(
KernelRidge(kernel="rbf", gamma=0.1),
param_grid={"alpha": [1e0, 0.1, 1e-2, 1e-3], "gamma": np.logspace(-2, 2, 5)},
)
Comparar Tempos de SVR e Regressão de Ridge Kernel
Vamos comparar os tempos de ajuste e previsão dos modelos SVR e KRR usando os melhores hiperparâmetros encontrados na Etapa 2.
import time
## Ajustar SVR
t0 = time.time()
svr.fit(X[:train_size], y[:train_size])
svr_fit = time.time() - t0
## Imprimir os melhores parâmetros e pontuação para o modelo SVR
print(f"Melhor SVR com parâmetros: {svr.best_params_} e pontuação R2: {svr.best_score_:.3f}")
print("Complexidade SVR e largura de banda selecionadas e modelo ajustado em %.3f s" % svr_fit)
## Ajustar KRR
t0 = time.time()
kr.fit(X[:train_size], y[:train_size])
kr_fit = time.time() - t0
## Imprimir os melhores parâmetros e pontuação para o modelo KRR
print(f"Melhor KRR com parâmetros: {kr.best_params_} e pontuação R2: {kr.best_score_:.3f}")
print("Complexidade KRR e largura de banda selecionadas e modelo ajustado em %.3f s" % kr_fit)
## Calcular a razão de vetores de suporte para SVR
sv_ratio = svr.best_estimator_.support_.shape[0] / train_size
print("Razão de vetores de suporte: %.3f" % sv_ratio)
## Prever usando SVR
t0 = time.time()
y_svr = svr.predict(X_plot)
svr_predict = time.time() - t0
print("Previsão SVR para %d entradas em %.3f s" % (X_plot.shape[0], svr_predict))
## Prever usando KRR
t0 = time.time()
y_kr = kr.predict(X_plot)
kr_predict = time.time() - t0
print("Previsão KRR para %d entradas em %.3f s" % (X_plot.shape[0], kr_predict))
Analisar os Resultados
Vamos visualizar o modelo aprendido do KRR e do SVR quando a complexidade/regularização e a largura de banda do kernel RBF são otimizadas usando a busca em grade.
import matplotlib.pyplot as plt
sv_ind = svr.best_estimator_.support_
plt.scatter(
X[sv_ind],
y[sv_ind],
c="r",
s=50,
label="Vetores de suporte SVR",
zorder=2,
edgecolors=(0, 0, 0),
)
plt.scatter(X[:100], y[:100], c="k", label="dados", zorder=1, edgecolors=(0, 0, 0))
plt.plot(
X_plot,
y_svr,
c="r",
label="SVR (ajuste: %.3fs, previsão: %.3fs)" % (svr_fit, svr_predict),
)
plt.plot(
X_plot, y_kr, c="g", label="KRR (ajuste: %.3fs, previsão: %.3fs)" % (kr_fit, kr_predict)
)
plt.xlabel("dados")
plt.ylabel("alvo")
plt.title("SVR versus Ridge Kernel")
_ = plt.legend()
Visualizar Tempos de Treinamento e Predição
Vamos visualizar o tempo de ajuste e previsão do KRR e do SVR para diferentes tamanhos do conjunto de treinamento.
_, ax = plt.subplots()
sizes = np.logspace(1, 3.8, 7).astype(int)
for name, estimator in {
"KRR": KernelRidge(kernel="rbf", alpha=0.01, gamma=10),
"SVR": SVR(kernel="rbf", C=1e2, gamma=10),
}.items():
train_time = []
test_time = []
for train_test_size in sizes:
t0 = time.time()
estimator.fit(X[:train_test_size], y[:train_test_size])
train_time.append(time.time() - t0)
t0 = time.time()
estimator.predict(X_plot[:1000])
test_time.append(time.time() - t0)
plt.plot(
sizes,
train_time,
"o-",
color="r" if name == "SVR" else "g",
label="%s (treinamento)" % name,
)
plt.plot(
sizes,
test_time,
"o--",
color="r" if name == "SVR" else "g",
label="%s (teste)" % name,
)
plt.xscale("log")
plt.yscale("log")
plt.xlabel("Tamanho do conjunto de treinamento")
plt.ylabel("Tempo (segundos)")
plt.title("Tempo de Execução")
_ = plt.legend(loc="best")
Visualizar as Curvas de Aprendizagem
Vamos visualizar as curvas de aprendizagem do KRR e do SVR.
from sklearn.model_selection import LearningCurveDisplay
_, ax = plt.subplots()
svr = SVR(kernel="rbf", C=1e1, gamma=0.1)
kr = KernelRidge(kernel="rbf", alpha=0.1, gamma=0.1)
common_params = {
"X": X[:100],
"y": y[:100],
"train_sizes": np.linspace(0.1, 1, 10),
"scoring": "neg_mean_squared_error",
"negate_score": True,
"score_name": "Erro Quadrático Médio",
"std_display_style": None,
"ax": ax,
}
LearningCurveDisplay.from_estimator(svr, **common_params)
LearningCurveDisplay.from_estimator(kr, **common_params)
ax.set_title("Curvas de Aprendizagem")
ax.legend(handles=ax.get_legend_handles_labels()[0], labels=["SVR", "KRR"])
plt.show()
Resumo
Neste tutorial, comparamos a Regressão de Ridge com Kernel (KRR) e a Regressão Vetorial de Suporte (SVR) usando o Scikit-Learn. Geramos um conjunto de dados composto por uma função-alvo sinusoidal com ruído significativo adicionado a cada quinto ponto de dados. Construímos modelos KRR e SVR usando o GridSearchCV do Scikit-Learn para encontrar os melhores hiperparâmetros. Comparamos os tempos de ajuste e previsão dos modelos SVR e KRR usando os melhores hiperparâmetros encontrados. Visualizamos o modelo aprendido do KRR e do SVR quando a complexidade/regularização e a largura de banda do kernel RBF são otimizadas usando busca em grade. Também visualizamos o tempo de ajuste e previsão do KRR e do SVR para diferentes tamanhos do conjunto de treinamento. Finalmente, visualizamos as curvas de aprendizagem do KRR e do SVR.