Hoje é dia de seguir com a minha promessa de abordar mais Machine Learning em Python, algo que acabei negligenciando nos últimos meses. Dessa vez, você vai aprender como rodar um XGBoost em Python. Tal qual ocorreu em Regressão Logística em Python e Random Forest em Python, a ideia é você ter um esqueleto para apenas inserir seu dataset e correr para o abraço. Vamos lá!
PRIMEIROS PASSOS
Primeiro, tenha em mente que estou assumindo aqui que você já dividiu sua base em treino e teste – ou em treino, teste e validação, o que acho até melhor. Como de costume, X_train será os regressores para o treino e y_train a variável resposta para o treino.
Em seguida, agora que você já está com seus dados divididos e pronto para treiná-los, vamos instalar a biblioteca xgboost. Para isso, vá ao Terminal e digite:
pip install xgboost
Uma vez que a execução estiver finalizada, você pode carregar a biblioteca com o nome que desejar. No meu caso, carreguei-a como xgb:
import xgboost as xgb
TREINANDO O MODELO
Na sequência, para rodar o modelo no modo padrão, sem tunar os hiperparâmetros, você só precisa fazer o mesmo de sempre. Instanciar a classe da regressão em um objeto e em seguida aplicar o fit desse objeto:
# Instancia o objeto xg_reg = xgb.XGBRegressor() # treina o modelo xg_reg.fit(X_train, y_train)
AVALIANDO O MODELO TREINADO
Agora, você precisa rodar a predição e avaliar o modelo:
# roda predição
xg_reg.predict(X_test)
# métricas de avaliação
print("Mean Absolute Error:", metrics.mean_absolute_error(y_test, xg_pred))
print("Mean Squared Error:", metrics.mean_squared_error(y_test, xg_pred))
print("Root Mean Squared Error:", np.sqrt(metrics.mean_squared_error(y_test, xg_pred)))
# cria dataset com actual e predicted
xg_results = pd.DataFrame(
{"actual": y_test["revenue_lag0"].array, "predicted": xg_pred,}
)
xg_results["residual_perc"] = xg_results["actual"] / xg_results["predicted"] - 1
xg_results["residual_abs"] = xg_results["actual"] - xg_results["predicted"]
# dataset com resultados
display(xg_results)
# plot dos residuos
plt.title("Residual Plot")
xg_results["residual_abs"].plot()
TUNANDO OS HIPERPARÂMETROS
Por fim, você pode tunar os hiperparâmetros do modelo. No post de Regressão logística, mostrei como fazer isso na força bruta, utilizando o GridSearchCV. Porém, o GridSearchCV pode ser muito demorado, já que faz roda todas as combinações possíveis. Aqui, você utilizará o RandomizedSearchCV. A principal diferença é que ele tentará um número fixo de combinações dos hiperparâmetros, e não todas possíveis. Esse número é determinado pelo parâmetro n_iter:
xg_reg = xgb.XGBRegressor()
learning_rate = np.linspace(start=0.01, stop=1, num=200)
objective = [
"reg:squarederror",
]
colsample_bytree = np.linspace(start=0.01, stop=1, num=50)
max_depth = [int(x) for x in np.linspace(1, 1000, num=50)]
alpha = [int(x) for x in np.linspace(1, 50, num=50)]
n_estimators = [int(x) for x in np.linspace(start=1, stop=2000, num=10)]
subsample=np.linspace(start=0.01, stop=1, num=50)
gamma=[int(x) for x in np.linspace(1, 1000, num=30)]
random_grid = {
"learning_rate": learning_rate,
"objective": objective,
"colsample_bytree": colsample_bytree,
"max_depth": max_depth,
"alpha": alpha,
"n_estimators": n_estimators,
"subsample":subsample,
"gamma": gamma
}
# testa 100 combinações
randomsearch = RandomizedSearchCV(xg_reg, param_distributions=random_grid, cv=5, n_iter = 100)
randomsearch.fit(X_train, y_train)
randomsearch.best_params_
Agora que você já tem os melhores parâmetros, basta substituí-los dentro da classe XGBRegressor() quando instanciá-la. Por exemplo:
xg_reg = xgb.XGBRegressor( objective="reg:squarederror", n_estimators=1111, max_depth=245, learning_rate=0.029899497487437185, colsample_bytree=0.656530612244898, alpha=32, subsample=0.45448979591836736, gamma=793, ) xg_reg.fit(X_train, y_train) xg_pred = xg_reg.predict(X_test)
Em tempo, veja que estou rodando um XGBoost para variáveis contínuas. Porém, a estrutura é exatamente igual para o caso de você rodar um classificador. Muda somente a classe a ser instanciada e os hiperparâmetros. Mas a estrutura é a mesma!
Veja também:
- Random Forest em Python
- Regressão Linear no Python
- Regressão Logística em Python
- Introdução aos Pipelines no Scikit-Learn
- Pipeline usando Scikit-Learn: Exemplos Práticos
E aí? Gostou do conteúdo? Se inscreva para receber as novidades! Deixe seu e-mail em INSCREVA-SE na barra à direita, logo abaixo de pesquisar. E, por favor, não deixe de comentar, dar seu feedback e, principalmente, compartilhar com seus amigos. De verdade, isso faz toda a diferença. Além disso, você também pode acompanhar mais do meu trabalho seguindo a conta de Twitter @EstatSite ou por alguma das redes que você encontra em Sobre o Estatsite / Contato, como meu canal de Youtube Canal do Yukio. E se você gosta de tecnologia, escute o Pitacotech!
Bons estudos!