Introdução ao

Extreme Gradient
Boosting

Odemir Depieri Jr
Ronisson Lucas C. da Conceição
Yan Vianna Sym
SOBRE ESSE EBOOK
Nesse e-book vamos realizar uma introdução ao
algoritmo Extreme Gradient Boosting (aprendizado
de máquina).
Esse algoritmo é um dos melhores em questão de
precisão e mais utilizado em competições da Kaggle
pelos competidores de dados.

CONTEÚDO
Vamos introduzir ao tema do que seria
o Extreme Gradient Boosting em seguida vamos
realizar um case usando dados sintéticos para
demonstrar a aplicação do algoritmo.
xbboost: https://xgboost.readthedocs.io/en/stable/index.html

Iremos aplicar algumas visualizações

gráficas usando o Yellowbrick para demonstrar
análises gráficas nos modelos de Machine Learning
fugindo um pouco da forma clássica de apresentar os
resultados do modelo de machine learning.
Yellowbrick: https://www.scikit-yb.org/en/latest/

AUTORES
Odemir Depieri Jr
Ronisson Lucas Calmon da Conceição
Yan Vianna Sym

APOIO
Data Viking
INDICE
XGBOOST
o O QUE É EXTREME GRADIENT BOOSTING - 4

TUTORIAL
o IMPORTAR FRAMEWORKS - 5
o DADOS SINTÉTICOS - 6
o TABULAR OS DADOS - 7
o ANÁLISE DA CLASSE - 8
o ANÁLISE DAS CARACTERÍSTICAS - 9
o DIVISÃO DOS DADOS - 10
o CRIAÇÃO DO MODELO - 11
o MATRIZ DE CONFUSÃO - 12
o MATRIZ DE CONFUSÃO - 13
o REPORT DE CLASSIFICAÇÃO - 14
o REPORT DE CLASSIFICAÇÃO - 15
o CURVA ROC - 16
o CROSS VALIDADOR - 17
o MATRIZ DE CONFUSÃO - 18
o CÓDIGO - 19
o REFERÊNCIAS - 20
 O que é extreme gradient boosting?
Extreme Gradient Boosting é um algoritmo baseado em
árvore, que fica sob a ramificação supervisionada do Machine
Learning. Embora possa ser usado para problemas de
classificação e regressão, todas as fórmulas e exemplos desta
história se referem ao uso do algoritmo para classificação .

Noções básicas de XGBoost e aumento de gradiente

Antes de mergulhar nos detalhes, vamos revisar o básico
desses algoritmos.
•Tree-based algorithms — tanto o XGBoost quanto o
Gradient Boosting usam árvores de decisão como seus
estimadores básicos.
•Tree depth — as árvores são construídas usando resíduos,
não os rótulos de classe reais. Assim, apesar de focarmos em
problemas de classificação, os estimadores básicos nesses
algoritmos são árvores de regressão e não árvores de
classificação. Isso ocorre porque os resíduos são contínuos e
não discretos. Ao mesmo tempo, porém, algumas das fórmulas
que você verá abaixo são exclusivas para classificação,
portanto, não assuma que exatamente o mesmo se aplica a
problemas de regressão.
•Tree depth — ambos os algoritmos permitem controlar o
tamanho máximo das árvores para minimizar o risco de ajuste
excessivo dos dados.
•Ensemble methods — semelhantes ao Random Forest ou
AdaBoost, esses algoritmos constroem muitas árvores no
processo. No final, a previsão final é baseada em todas as
árvores.
•Learning rate— o valor de cada árvore é dimensionado pela
taxa de aprendizado. Isso permite que o algoritmo tenha uma
melhoria mais gradual e constante a cada etapa.
•Process map— finalmente, aqui está uma ilustração simples do
processo usado pelo Gradient Boosting e XGBoost.

Fonte: https://towardsdatascience.com/xgboost-extreme-gradient-boosting-
how-to-improve-on-regular-gradient-boosting-5c6acf66c70a
O que é extreme gradient boosting - 4
 # Libs para manipular dados
import pandas as pd
import numpy as np

# Lib Gráfica
import matplotlib.pyplot as plt
import seaborn as sns

# Biblioteca do XGbossting
import xgboost

print(f'Versão do XGBoost: {xgboost.__version__}'

)
Versão do XGBoost: 0.90

Importar os frameworks
Primeiramente vamos importar os frameworks que iremos
utilizar.
Mais para frente vamos importar diversas funções de alguns
frameworks como Yellowbrick, Sklearn. Então caso não tenha
esses frameworks instalados sugiro instalar logo no início.
Caso não tenha algum framework instalado, basta abrir o ‘CMD’
e instalar com o comando ‘pip install bibliotecaquequeira’.
Para Linux, Mac ou outro sistema consulte a documentação do
python.
Link: https://packaging.python.org/en/latest/tutorials/installing-packages/

Importar Frameworks - 5
 # Função para criar dataset
from sklearn.datasets import make_classification

# Vetores
Eixo_x, Eixo_y = make_classification(
# Numero de amostras
n_samples=2000,

# Quantidade de Features da base

n_features=10,

# Informações nas Features

n_informative=5,

# Features redudantes
n_redundant=5,

# Determinar flag de aleatório

random_state=10)

# Dimensão
print( Eixo_x.shape, Eixo_y.shape)

(2000, 10) (2000,)

Gerar dados sintéticos

Para nosso tutorial iremos gerar dados sintéticos usando o
framework sklearn.
A função sklearn.datasets.make_classification prove a geração
de dados sintéticos baseado em um algoritmo estatístico.
Com ele podemos gerar dados com certos padrões para nos
auxiliar na criação de datasets para testes.
Caso queira conhecer mais sobre essa função, acessa
documentação.
Fonte: https://scikit-learn.org/stable/modules/generated/sklearn.datasets.make_classification.html

Dados Sintéticos - 6
 # Criando uma tabela para melhor visualização

# Função com uma lista alfabética

from string import ascii_uppercase as Lista_Alfabe
tica

# Nomear as colunas e filtrar até a letra igual nume

ro de colunas
Nome_Colunas = list( Lista_Alfabetica )
Nome_Colunas = Nome_Colunas[ 0:Eixo_x.shape[1] ]

# Criando a Tabela
Base_Dados = pd.DataFrame( Eixo_x, columns=Nom
e_Colunas )
Base_Dados['Target'] = Eixo_y

# Verificar
Base_Dados.head()

Tabula os dados
Na geração dos dados criamos 10 colunas (Features) e uma
variável ‘target’ que será nossa classe previsora.
A própria função do sklearn já fez essa criação.
Inclui as colunas com letra alfabéticas para melhor visualização.
O que é uma Feature?
No aprendizado de máquina e no reconhecimento de padrões,
um recurso (feature) é uma propriedade individual mensurável
ou característica de um fenômeno. A escolha de recursos
informativos, discriminantes e independentes é um elemento
crucial de algoritmos eficazes no reconhecimento, classificação
e regressão de padrões.
Tabular os dados - 7
# Analisar nossa classe previsora [ Target ]

# Gráfico do Yellow brick - Balanço de Classe

from yellowbrick.target import ClassBalance

# Tamanho do gráfico
plt.figure( figsize=(10, 5) )

# Instanciando o gráfico
Visualizador = ClassBalance( labels=[0,1] )
Visualizador.fit( Eixo_y )

# titulo
plt.title('Análise da Classe [Target]');

Análise da Classe
Utilizamos o Yellowbrick para gerar um gráfico com a
quantidade de cada classe (Previsor).
Com o intuito de avaliar se há um desbalanceamento na sua
variável previsora, como estamos usando dados sintéticos
poderia ter forçado essa curva, porém vamos manter o
balanceamento para efeito de estudo.

Análise da Classe - 8
# Analisar os dados de características

# Gráfico do Yellow brick - Coordenadas paralelas

from yellowbrick.features import ParallelCoordinate
s

# Tamanho do gráfico
plt.figure( figsize=(10, 5) )

# Parâmetros para o gráfico

Features = Nome_Colunas
Classes = [0, 1]

# Instanciando o gráfico
Visualizador_02 = ParallelCoordinates( classes=Class
es, features=Features, sample=0.05, shuffle=True)
Visualizador_02.fit_transform( Eixo_x, Eixo_y )

# Titulo
plt.title('Coordenadas paralelas -[Características]');

Análise das Características

Utilizamos o Yellowbrick para gerar um gráfico com as variáveis
de características usando ‘coordenadas paralelas', esse gráfico é
ótimo para entender de uma forma visual como está a relação
entre os valores e classe previsores.

Análise das Características - 9

# Divisão dos dados

# Função sklearn para dividir os dados

from sklearn.model_selection import train_test_spl
it

# Vetores
x_Treino, x_Teste, y_Treino, y_Teste = train_test
_split(
# características
Eixo_x,

# previsor
Eixo_y,

# tamanho da amostra
test_size=0.25,

# flag do aleatório
random_state=10 )

# Dimensão
print( f'Treinar o modelo com { x_Treino.shape[0] }
registros' )
print( f'Testar com { x_Teste.shape[0] } registros'
)

Treinar o modelo com 1500 registros

Testar com 500 registros

Divisão dos dados

Vamos fazer a divisão dos dados de treino e teste usando
o sklearn com a função ‘train_test_split’.
Essa função proporciona a separação dos nossos dados em
vetores. A porcentagem de divisão fica a seu critério, aqui
mantive 75% em treino e 25% em teste.

Divisão dos dados - 10

 # Função do modelo
from xgboost import XGBClassifier

# Atribuindo o modelo
Modelo_XGB = XGBClassifier(

# Numero de arvores no algoritmo

n_estimators=500,

# definido para controlar a ponderação de novas árvores

adicionadas ao modelo
learning_rate=0.1,

# Profundidade máxima de uma árvore

# Detalhe XGBoost consome muita memoria, então quant
o maior mais memoria
max_depth=5,

# Soma mínima do peso da instância

min_child_weight=1,

# Redução de perda mínima necessária para fazer uma pa

rtição adicional em um nó folha da árvore.
# Quanto maior 'gamma' for, mais conservador será o alg
oritmo
gamma=0,

# Proporção de subamostra das instâncias de treinament

o.
subsample=0.8,

# Denota a fração de colunas a serem amostras aleatória

s para cada árvore.
colsample_bytree=0.8,
)

# Fitar o modelo
Modelo_XGB.fit( x_Treino, y_Treino )

XGBClassifier(colsample_bytree=0.8,
max_depth=5, n_estimators=500, subsample=0.8)

Criação do Modelo
Deixei comentado cada parâmetros no modelo.
Fonte: https://xgboost.readthedocs.io/en/stable/python/python_api.html Criação do Modelo - 11
# Avaliar o modelo - Matriz de Confusão

# Criar as previsões
Previsoes = Modelo_XGB.predict( x_Teste )

# Matriz de confusão
from sklearn.metrics import confusion_matrix
print('Matriz de Confusão: \n', confusion_matrix( y_Test
e, Previsoes ), '\n' )

Matriz de Confusão:
[[230 22]
[ 15 233]]

# Gráfico do Yellow brick - Matrix de Confusão

from yellowbrick.classifier import ConfusionMatrix

# Tamanho do gráfico
plt.figure( figsize=(10, 5) )

# Atribuir a Matrix
Matriz_Confusao = ConfusionMatrix(Modelo_XGB, classes
=[0, 1])

# Fitar o modelo
Matriz_Confusao.fit(x_Treino, y_Treino)

# Calcular o score
Matriz_Confusao.score(x_Teste, y_Teste)

# Plot do gráfico
Matriz_Confusao.show()

Matriz de Confusão - 12
Matriz de Confusão
Nos exemplos utilizei 2 formas para gerar a matriz de confusão,
a forma mais clássica usando apenas o sklearn e utilizando
o Yellowbrick que nos fornece uma forma mais visual da matriz.
Caso não conheça nada sobre Matriz de confusão, temos um
slide bem legal mostrando os parâmetros.

Caso queira saber mais acesse o site do skelarn para mais

informações sobre o método.
Fonte: https://scikit-learn.org/stable/modules/generated/sklearn.metrics.confusion_matrix.html

Matriz de Confusão - 13
# Relatorio de Classificação
from sklearn.metrics import classification_report
print('Relatório de Classificação: \n', classification_repor
t( y_Teste, Previsoes ) )

# Gráfico do Yellow brick - Report de Classificação

from yellowbrick.classifier import ClassificationReport

# Tamanho do gráfico
plt.figure( figsize=(10, 5) )

# Atribuir o Report
Class_Report = ClassificationReport(Modelo_XGB, classes
=[0, 1], support=True)

# Fitar o modelo
Class_Report.fit(x_Treino, y_Treino)

# Calcular o score
Class_Report.score(x_Teste, y_Teste)

# Plot do gráfico
Class_Report.show();

Report de Classificação - 14
Report de Classificação
Nos exemplos utilizei 2 formas para gerar o report de
classificação, a forma mais clássica usando apenas o sklearn e
utilizando o Yellowbrick que nos fornece uma forma mais visual
da matriz.
Caso não conheça nada sobre o report de classificação, temos
um slide bem legal mostrando os parâmetros.

Caso queira saber mais acesse o site do sklearn para mais

informações sobre o método.
Fonte: https://scikit-learn.org/stable/modules/generated/sklearn.metrics.classification_report.html

Report de Classificação - 15
 # Gráfico do Yellow brick - Curva ROC
from yellowbrick.classifier import ROCAUC

# Tamanho do gráfico
plt.figure( figsize=(10, 5) )

# Atribuir o Report
Curva_ROC = ROCAUC(Modelo_XGB, classes=[0, 1])

# Fitar o modelo
Curva_ROC.fit(x_Treino, y_Treino)

# Calcular o score
Curva_ROC.score(x_Teste, y_Teste)

# Plot do gráfico
Curva_ROC.show();

Curva ROC
Utilizamos o Yellowbrick para plotar uma curva ROC.
Esse gráfico é baseado em algumas estatísticas, caso queira
aprofundar mais acesse o link da documentação.

Fonte: https://www.scikit-yb.org/en/latest/api/classifier/rocauc.html

Curva ROC - 16
# Funções
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import RepeatedStratifiedK
Fold

# Atribuindo o modelo
Modelo_XGB_v2 = XGBClassifier()

# Atrinuindo o modelo - Validação cruzada

Validacao_Cruzada = RepeatedStratifiedKFold(
# Numero de splits
n_splits=10,

# Quantidade de repetições
n_repeats=3,

# Flag do aleatorio
random_state=10 )

# Fitando o modelo
Resultado_Scores = cross_val_score(
# Modelo
Modelo_XGB_v2,

# Caracteristicas
Eixo_x,

# Previsor
Eixo_y,

# Metrica de avaliação
scoring='accuracy',

# Validação cruzado
cv=Validacao_Cruzada,

# Numero de jobs em paralelo [-

1 significa usar todos os processadores]
n_jobs=-1 )

# Avaliando o 'ACCURACY' final

print(f'Média da Acurácia nos Scores: { np.mean(Resultado
_Scores) } ')

Média da Acurácia nos Scores: 0.92283

Cross Validador - 17
Cross Validador
Cross Validation é uma técnica muito utilizada para avaliação de
desempenho de modelos de aprendizado de máquina. O CV
consiste em particionar os dados em conjuntos(partes), onde
um conjunto é utilizado para treino e outro conjunto é utilizado
para teste e avaliação do desempenho do modelo.

Muitas vezes é interessante usar o cross validador para verificar

se não há uma fatia de dados ‘ruins’.

Matriz de Confusão - 18
Código (script)
Para acessar esse script acesse o qrcode abaixo.

Código - 19
Referências
https://packaging.python.org/en/latest/tutorials/in
stalling-packages/
https://en.wikipedia.org/wiki/Feature_(machine_lea
rning)
https://www.scikit-
yb.org/en/latest/api/target/class_balance.html
https://www.scikit-
yb.org/en/latest/api/features/pcoords.html
https://scikit-
learn.org/stable/modules/generated/sklearn.model_
selection.train_test_split.html
https://xgboost.readthedocs.io/en/stable/python/p
ython_api.html
https://www.scikit-
yb.org/en/latest/api/classifier/confusion_matrix.ht
ml
https://scikit-
learn.org/stable/modules/generated/sklearn.metrics
.confusion_matrix.html
https://scikit-
learn.org/stable/modules/generated/sklearn.metrics
.classification_report.html
https://www.scikit-
yb.org/en/latest/api/classifier/rocauc.html
http://scikit-
learn.org/stable/modules/generated/sklearn.model_
selection.cross_val_score.html
http://scikit-
learn.org/stable/modules/generated/sklearn.model_
selection.RepeatedStratifiedKFold.html

Referências - 20