Como Salvar e Carregar Modelos XGBoost em Python

Você passou incontáveis horas pesquisando, ajustando e treinando o modelo XGBoost perfeito.

Seu modelo está performando excepcionalmente bem e você está pronto para comemorar.

Mas espere, agora você precisa implementá-lo, e de repente, você se depara com um problema.

Como salvar seu modelo para uso futuro?

Neste artigo, vou ensiná-lo a salvar e carregar seus modelos XGBoost.

Isso significa que você pode treinar seu modelo uma vez, salvá-lo e depois recarregá-lo sempre que precisar fazer previsões.

Chega de treinar do zero toda vez!

Modelo XGBoost Simples para Demonstração

Antes de nos aprofundarmos em salvar e carregar modelos, vamos construir um modelo XGBoost simples que podemos usar para demonstração.

Usaremos o conjunto de dados de Qualidade do Vinho do Repositório de Machine Learning da UCI.

Este conjunto de dados contém informações sobre vinhos tintos, incluindo características como acidez e teor alcoólico, bem como uma variável alvo ‘quality’ que representa a qualidade do vinho em uma escala de 3 a 8.

Primeiro, precisamos importar as bibliotecas necessárias e carregar o conjunto de dados.

import pandas as pd
from sklearn.model_selection import train_test_split
from xgboost import XGBClassifier

# Carregar conjunto de dados
url = "https://archive.ics.uci.edu/ml/machine-learning-databases/wine-quality/winequality-red.csv"
data = pd.read_csv(url, delimiter=";")

Agora que temos nossos dados, vamos dividi-los em conjuntos de treinamento e teste. Usaremos a coluna ‘quality’ como nossa variável alvo.

# Dividir dados em X e y
X = data.drop('quality', axis=1)
y = data['quality']

# Dividir dados em conjuntos de treinamento e teste
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=7)

Com nossos dados preparados, podemos construir nosso modelo XGBoost.

Usaremos o XGBClassifier e faremos o treinamento do modelo com nossos dados de treinamento.

# Definir o modelo
model = XGBClassifier()

# Treinar o modelo
model.fit(X_train, y_train)

Ótimo! Agora temos um XGBoost simples treinado no conjunto de dados.

Usaremos este modelo nas próximas seções para demonstrar como salvar e carregar modelos.

Salvando Modelos XGBoost

Agora que temos nosso modelo XGBoost treinado, vamos salvá-lo para uso futuro.

O XGBoost fornece uma função chamada save_model que nos permite fazer isso.

model.save_model('xgb_model.json')

No código acima, estamos salvando nosso modelo em um arquivo chamado ‘xgb_model.json’.

A função save_model suporta diferentes formatos de arquivo, incluindo JSON e formato binário.

É importante notar que há uma diferença entre a API do sklearn e o método booster (API nativa) quando se trata de salvar modelos.

Ao usar a API do sklearn, você usa a função model.save_model() como mostrado acima.

No entanto, ao usar a API Nativa, você precisa usar booster.save_model().

# Salvar modelo usando booster
booster = model.get_booster()
booster.save_model('booster_model.json')

No código acima, primeiro obtemos o objeto booster do modelo usando model.get_booster(), e então salvamos o booster usando booster.save_model().

Se tivéssemos treinado nosso modelo usando a API Nativa, teríamos que usar booster.save_model() para salvar o modelo.

Lembre-se: se você usar a API do Scikit-learn para salvar o modelo, você deve carregá-lo usando a API do Scikit-learn, o mesmo vale para a API Nativa.

Carregando Modelos XGBoost Salvos

Agora que salvamos nosso modelo, vamos carregá-lo de volta para a memória.

Podemos fazer isso usando a função load_model fornecida pelo XGBoost.

# Carregar modelo do arquivo
loaded_model = XGBClassifier()
loaded_model.load_model('xgb_model.json')

No código acima, primeiro criamos uma nova instância de XGBClassifier, para que a biblioteca saiba qual tipo de modelo estamos carregando.

Então, carregamos o modelo do arquivo ‘xgb_model.json’ nesta nova instância.

Assim como com o salvamento de modelos, há uma diferença entre a API do sklearn e a API Nativa quando se trata de carregar modelos.

Ao usar a API do sklearn, você usa a função model.load_model() como mostrado acima.

No entanto, ao usar o método booster, você precisa usar booster.load_model().

# Carregar modelo usando booster
import xgboost

booster = xgboost.Booster()
booster.load_model('booster_model.json')

No código acima, primeiro criamos uma nova instância de um objeto Booster, e então carregamos o modelo nele usando booster.load_model().

Fazendo Previsões Com O Modelo Carregado

Agora que carregamos nosso modelo, podemos fazer previsões com ele assim como faria com qualquer outro modelo.

# Fazer previsões nos dados de teste
y_pred = loaded_model.predict(X_test)

Se você estiver usando a API Nativa, lembre-se de converter seus dados de entrada para DMatrix antes de fazer previsões.

Salvando e Carregando Modelos XGBoost Com Pickle

Pickle é um módulo Python usado para serializar (pickle) e desserializar (unpickle) estruturas de objetos Python.

É outra forma de salvar e carregar seus modelos XGBoost, e pode ser mais rápido para modelos grandes.

Vamos começar salvando nosso modelo XGBoost com Pickle.

import pickle

# Salvar o modelo em um arquivo
pickle.dump(model, open("xgb.pkl", "wb"))

No código acima, estamos usando a função dump do módulo pickle para salvar nosso modelo em um arquivo chamado ‘xgb.pkl’.

O argumento ‘wb’ indica que o arquivo é aberto para escrita em modo binário.

Agora, vamos carregar o modelo de volta para a memória usando Pickle.

# Carregar modelo do arquivo
loaded_model = pickle.load(open("xgb.pkl", "rb"))

Aqui, estamos usando a função load do módulo pickle para carregar nosso modelo do arquivo ‘xgb.pkl’.

O argumento ‘rb’ indica que o arquivo é aberto para leitura em modo binário.

Uma das vantagens de usar Pickle é que pode ser mais rápido para modelos grandes, e ele salva o objeto do modelo em um formato binário, então você não precisa criar uma nova instância dele antes de carregar.

No entanto, é importante notar que Pickle não é seguro contra dados com erro ou código malicioso.

Nunca faça unpickle de dados recebidos de uma fonte não confiável ou não autenticada.

Salvando e Carregando Modelos XGBoost Com Joblib

Joblib é outra biblioteca Python usada para serializar objetos Python, similar ao Pickle.

Este é o meu método preferido.

Vamos começar salvando nosso modelo XGBoost com Joblib.

from joblib import dump

# Salvar o modelo em um arquivo
dump(model, "xgb.pkl")

No código acima, estamos usando a função dump do módulo joblib para salvar nosso modelo em um arquivo chamado “xgb.pkl”.

Agora, vamos carregar o modelo de volta para a memória usando Joblib.

from joblib import load

# Carregar modelo do arquivo
loaded_model = load("xgb.pkl")

Aqui, estamos usando a função load do módulo joblib para carregar nosso modelo do arquivo “xgb.pkl”.

Uma das vantagens de usar Joblib sobre Pickle é que pode ser mais rápido e mais eficiente para modelos grandes, especialmente aqueles com grandes arrays numpy.

E tem a mesma vantagem de que você não precisa criar uma nova instância do modelo antes de carregá-lo.

No entanto, similar ao Pickle, Joblib não é seguro contra erros de dados ou código malicioso.

Nunca carregue um arquivo serializado joblib recebido de uma fonte não confiável ou não autenticada.