Parada Antecipada em Boosting de Gradiente

Introdução

O boosting de gradientes é uma técnica de conjunto onde vários aprendizes fracos (árvores de regressão) são combinados para produzir um único modelo poderoso, de forma iterativa. O suporte a parada antecipada no Boosting de Gradientes permite-nos encontrar o menor número de iterações suficiente para construir um modelo que generalize bem para dados não vistos.

Dicas de 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 praticar.

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 a aprendizagem, não hesite em contactar o Labby. Forneça feedback após a sessão e resolveremos prontamente o problema para si.

Carregar as Bibliotecas e Dados Necessários

Primeiro, precisamos carregar as bibliotecas e os dados necessários. Usaremos a biblioteca scikit-learn para a implementação do boosting de gradientes.

import time
import numpy as np
import matplotlib.pyplot as plt
from sklearn import ensemble
from sklearn import datasets
from sklearn.model_selection import train_test_split

data_list = [
    datasets.load_iris(return_X_y=True),
    datasets.make_classification(n_samples=800, random_state=0),
    datasets.make_hastie_10_2(n_samples=2000, random_state=0),
]
names = ["Dados Iris", "Dados de Classificação", "Dados de Hastie"]
n_estimators = 200

Preparar os Dados

Em seguida, prepararemos os dados dividindo-os em conjuntos de treino e teste.

for X, y in data_list:
    X_train, X_test, y_train, y_test = train_test_split(
        X, y, test_size=0.2, random_state=0
    )

Construir e Treinar o Modelo sem Parada Antecipada

Agora, construiremos e treinaremos um modelo de boosting de gradientes sem parada antecipada.

gb = ensemble.GradientBoostingClassifier(n_estimators=n_estimators, random_state=0)
start = time.time()
gb.fit(X_train, y_train)
time_gb.append(time.time() - start)

Construir e Treinar o Modelo com Parada Antecipada

Agora, construiremos e treinaremos um modelo de boosting de gradientes com parada antecipada. Especificamos uma fração de validação, que representa a fração do conjunto de dados inteiro que será mantida separada do treinamento para avaliar a perda de validação do modelo. O modelo de boosting de gradientes é treinado usando o conjunto de treinamento e avaliado usando o conjunto de validação. Quando cada estágio adicional de árvore de regressão é adicionado, o conjunto de validação é usado para avaliar o modelo. Isso continua até que as pontuações do modelo nos últimos n_iter_no_change estágios não melhorem em pelo menos tol. Depois disso, o modelo é considerado convergido e a adição adicional de estágios é "parada antecipadamente". O número de estágios do modelo final está disponível no atributo n_estimators*.

gbes = ensemble.GradientBoostingClassifier(
        n_estimators=n_estimators,
        validation_fraction=0.2,
        n_iter_no_change=5,
        tol=0.01,
        random_state=0,
    )
start = time.time()
gbes.fit(X_train, y_train)
time_gbes.append(time.time() - start)

Comparar Pontuações com e sem Parada Antecipada

Agora, compararemos as pontuações dos dois modelos.

score_gb.append(gb.score(X_test, y_test))
score_gbes.append(gbes.score(X_test, y_test))

Comparar Tempos de Ajustamento com e sem Parada Antecipada

Agora, compararemos os tempos de ajuste dos dois modelos.

plt.figure(figsize=(9, 5))

bar1 = plt.bar(
    index, time_gb, bar_width, label="Sem parada antecipada", color="crimson"
)
bar2 = plt.bar(
    index + bar_width, time_gbes, bar_width, label="Com parada antecipada", color="coral"
)

max_y = np.amax(np.maximum(time_gb, time_gbes))

plt.xticks(index + bar_width, names)
plt.yticks(np.linspace(0, 1.3 * max_y, 13))

autolabel(bar1, n_gb)
autolabel(bar2, n_gbes)

plt.ylim([0, 1.3 * max_y])
plt.legend(loc="best")
plt.grid(True)

plt.xlabel("Datasets")
plt.ylabel("Tempo de Ajuste")

plt.show()

Comparar Pontuações com e sem Parada Antecipada

Agora, compararemos as pontuações dos dois modelos.

plt.figure(figsize=(9, 5))

bar1 = plt.bar(
    index, score_gb, bar_width, label="Sem parada antecipada", color="crimson"
)
bar2 = plt.bar(
    index + bar_width, score_gbes, bar_width, label="Com parada antecipada", color="coral"
)

plt.xticks(index + bar_width, names)
plt.yticks(np.arange(0, 1.3, 0.1))

autolabel(bar1, n_gb)
autolabel(bar2, n_gbes)

plt.ylim([0, 1.3])
plt.legend(loc="best")
plt.grid(True)

plt.xlabel("Datasets")
plt.ylabel("Pontuação de Teste")

plt.show()

Resumo

Neste laboratório, aprendemos sobre a parada antecipada em boosting de gradiente, que nos permite encontrar o menor número de iterações suficientes para construir um modelo que generalize bem para dados não vistos. Comparamos o desempenho de um modelo de boosting de gradiente com e sem parada antecipada e observamos que a parada antecipada pode reduzir significativamente o tempo de treinamento, o uso de memória e a latência de previsão.