Como escolher o número de estimadores para Gradient Boosting

Na Ciência de Dados, existem muitos algoritmos disponíveis para uso atualmente. Uma técnica útil, portanto, é combiná-los em um único modelo para obter o melhor de cada um, resultando em um modelo mais preciso.

Usando o Scikit-Learn, você encontrará o algoritmo Random Forest, que é o tipo de modelo de conjunto de ensacamento. Por outro lado, você também encontrará modelos Boosting, que treinam os estimadores em sequência, onde o resultado de um modelo é passado para o próximo, que tentará melhorar as previsões, até atingirem um resultado ótimo.

Ao criar um estimador Gradient Boosting, você encontrará este hiperparâmetro n_estimator=100 com um valor padrão de 100 árvores a serem criadas para chegar a um resultado. Muitas vezes, apenas definimos isso como padrão ou talvez aumentamos conforme necessário, mesmo usando técnicas de Grid Search.

Neste post, encontraremos uma maneira simples de chegar a um único número para treinar nosso modelo.

Gradient Boosting pode ser carregado do Scikit-Learn usando esta classe from sklearn.ensemble import GradientBoostingRegressor. O algoritmo Gradient Boosting pode ser usado para classificação ou para modelos de regressão. É um estimador baseado em árvore – o que significa que é composto por muitas árvores de decisão.

O resultado da Árvore 1 irá gerar erros. Esses erros serão usados ​​e a entrada para o Árvore 2. Mais uma vez serão utilizados os erros do último modelo e a entrada do próximo, até atingir o n_estimators valor.

Como cada estimador se ajustará ao erro do anterior, a expectativa é que a combinação das previsões seja melhor do que qualquer um dos estimadores isoladamente. Após cada iteração, tornamos o modelo mais complexo, reduzindo o viés, mas aumentando a variância, por outro lado. Portanto, devemos saber quando parar.

Vamos ver como fazer isso agora.

O código deste exercício é simples. Tudo o que devemos fazer é um loop após cada iteração e verificar em qual delas tivemos o menor erro.

Vamos começar escolhendo um conjunto de dados. Usaremos o acidentes de carro conjunto de dados, nativo da biblioteca seaborn (portanto, dados abertos sob licença BDS).

# Conjunto de dados
df = sns.load_dataset('car_crashes')

Aqui está uma rápida olhada nos dados. Tentaremos estimar o total quantidade usando os outros recursos como preditores. Como é uma saída de número real, estamos falando de um modelo de regressão.

Olhando rapidamente para as correlações.

# Correlações
df.corr().style.background_gradient(cmap='coolwarm')

Ok, sem grande multicolinearidade. Nós podemos ver isso ins_premium e ins_losses não se correlacionam muito bem com total , portanto não os consideraremos no modelo.

Se verificarmos os dados faltantes, não há nenhum

# Ausente
df.isnull (). sum ()
0

Legal, então vamos dividir os dados agora.

# X e y
X = df.drop(['ins_premium', 'ins_losses', 'abbrev', 'total'], eixo=1)
y = df['total']# Teste de trem
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=22)

Podemos criar um pipeline para dimensionar os dados e modelá-los (realmente não é muito necessário escalar esses dados, pois eles já estão na mesma escala, na base das dezenas). Em seguida, ajustamos os dados ao modelo e prevemos os resultados.

Estou usando 500 estimadores com um learning_rate de 0.3.

A taxa de aprendizagem é o tamanho do passo que damos para chegar ao erro mínimo. Se usarmos um valor muito alto, poderemos passar o mínimo. Se usarmos um número muito pequeno, podemos nem chegar perto dele. Portanto, uma regra prática que você pode considerar é: se você tiver um grande número de estimadores, poderá usar valores mais baixos de taxa de aprendizagem. Se você tiver apenas alguns estimadores, prefira usar valores mais altos de taxa de aprendizagem.

etapas = [('escala', StandardScaler()),
('GBR', GradientBoostingRegressor (n_estimators = 500, taxa de aprendizagem = 0.03))]# Pipeline de instância e ajuste
tubo = Pipeline (etapas).fit (X_train, y_train)# Prever
preds = pipe.predict(X_test)

Agora, avaliando.

# RMSE das previsões
print(f'RMSE: { round(np.sqrt(mean_squared_error(y_test, preds)),1 )}')[SAÍDA]: RMSE: 1.1# Média dos verdadeiros valores de Y
print(f'Dados e média: {round( y.mean(),1 )}')[OUT]: Média dos dados: 15.8

Bom. Nosso RMSE é cerca de 6.9% da média. Então, estamos perdendo isso, em média.

Agora vamos verificar uma maneira de ajustar nosso modelo escolhendo o número ideal de estimadores para treinar que nos dará a menor taxa de erro.

Como eu disse, não precisamos realmente dimensionar esses dados porque eles já estão na mesma proporção. Então, vamos ajustar o modelo.

#Modelo
gbr = GradientBoostingRegressor(n_estimators=500, taxa de aprendizagem=0.3).fit(X_train, y_train)

Agora são as coisas boas. Existe um método no Gradient Boosting que nos permite iterar sobre as previsões de cada estimador treinado, de 1 a 500. Assim, criaremos um loop que passa pelos 500 estimadores no gbr modelo, prevê resultados usando o método staged_predict(), calcula o erro quadrático médio e armazena o resultado na lista errors.

# Loop para o melhor número
erros = [mean_squared_error(y_test, preds) para preds em gbr.staged_predict(X_test)]# Número ideal de estimadores
optim_num_estimators = np.argmin(erros) + 1

A seguir, podemos traçar o resultado.

#Trama
g = sns.lineplot (x = intervalo (500), y = erros)
g.set_title(f'Melhor número de estimadores em {best_n_estimators}', size=15);

Vemos que a menor taxa de erro ocorre com 34 estimadores. Então, vamos treinar novamente nosso modelo com 34 estimadores e comparar com o resultado do modelo treinado com o pipeline.

# Retreinar
gbr = GradientBoostingRegressor(n_estimators=34, taxa de aprendizagem=0.3).fit(X_train, y_train)# Previsões
preds2 = gbr.predict(X_test)

Avaliando…

# RMSE das previsões
print(f'RMSE: { round(np.sqrt(mean_squared_error(y_test, preds2)),1 )}')
[SAÍDA]: RMSE: 1.0# Dados Y significam
print(f'Dados e média: {round( y.mean(),1 )}')[OUT]: Média dos dados: 15.8

Caímos de 6.9% para 6.3% de desconto agora. Aproximadamente. 9% melhor. Vejamos algumas previsões.

Resultados interessantes. Algumas das previsões do segundo modelo são melhores que o primeiro.

Aprendemos como determinar o melhor número de estimadores para ajustar um GradientBoostingRegressor do Scikit-Learn. Este é um hiperparâmetro que pode fazer a diferença neste tipo de modelo ensemble, que treina estimadores em sequência.

Às vezes, após algumas iterações, o modelo pode começar a se ajustar demais e, portanto, começará a aumentar muito a variância, impactando as previsões.

Vimos que um loop simples pode nos ajudar a encontrar a solução ideal neste caso. Mas, certamente, para grandes conjuntos de dados pode ser caro calcular, então uma ideia seria tentar um valor mais baixo. n_estimators primeiro e veja se você consegue atingir o erro mínimo em breve.

Aqui está o código completo no GitHub.

Se você gostou desse conteúdo, siga meu blog.

Encontre me em LinkedIn.

Este exercício foi baseado no excelente livro de Aurélien Géron, na referência.

Como escolher o número de estimadores para Gradient Boosting republicado da fonte https://towardsdatascience.com/how-to-choose-the-number-of-estimators-for-gradient-boosting-8d06920ab891?source=rss—-7f60cf5620c9— 4 via https://towardsdatascience.com/feed

<!–

->