Pesquisa de site

Aumento de gradiente na classificação: não é mais uma caixa preta!

Introdução

Os algoritmos de aprendizado de máquina exigem mais do que apenas ajustar modelos e fazer previsões para melhorar a precisão. A maioria dos modelos vencedores na indústria ou em competições tem usado Ensemble Techniques ou Feature Engineering para ter um melhor desempenho.

As técnicas de conjunto, em particular, ganharam popularidade devido à sua facilidade de uso em comparação com a engenharia de recursos. Existem vários métodos de conjunto que comprovadamente aumentam a precisão quando usados com algoritmos avançados de aprendizado de máquina. Um desses métodos é o Gradient Boosting. Embora o Gradient Boosting seja frequentemente discutido como se fosse uma caixa preta, neste artigo iremos desvendar os segredos do Gradient Boosting passo a passo, de forma intuitiva e extensiva, para que você possa realmente entender como ele funciona.

Neste artigo abordaremos os seguintes tópicos:

  • O que é aumento de gradiente?

  • Aumento de gradiente na classificação

    • Uma compreensão intuitiva: visualizando o Gradient Boosting
    • Uma compreensão matemática
  • Implementação de Gradient Boosting em Python
  • Comparando e contrastando AdaBoost e Gradient Boost
  • Vantagens e desvantagens do Gradient Boost
  • Conclusão

Pré-requisitos

  • Conhecimento básico de aprendizado de máquina: Familiaridade com aprendizado supervisionado, especialmente tarefas de classificação.
  • Compreensão das árvores de decisão: Conhecimento das árvores de decisão, já que o Gradient Boosting se baseia em alunos fracos, normalmente árvores de decisão.
  • Conceito de métodos de conjunto: Compreensão de técnicas de conjunto como ensacamento e reforço, que combinam vários modelos para melhorar o desempenho.
  • Matemática: A compreensão básica de cálculo (diferenciação) e álgebra linear (vetores e matrizes) é útil para compreender o processo de otimização e descida de gradiente.
  • Programação Python: familiaridade com Python e bibliotecas comuns de ML, como Scikit-Learn, para implementação de algoritmos de Gradient Boosting.

O que é aumento de gradiente?

Vamos começar revisando brevemente o aprendizado por conjunto. Como o nome sugere, a aprendizagem em conjunto envolve a construção de um modelo forte usando uma coleção (ou “conjunto”) de modelos “mais fracos”. O reforço de gradiente se enquadra na categoria de métodos de reforço, que aprendem iterativamente com cada um dos alunos fracos para construir um modelo forte. Pode otimizar:

  • Regressão
  • Classificação
  • Classificação

O escopo deste artigo será limitado à classificação em particular.

A ideia por trás do boosting vem da intuição de que os alunos fracos poderiam ser modificados para se tornarem melhores. AdaBoost foi o primeiro algoritmo de boost. AdaBoost e algoritmos relacionados foram lançados pela primeira vez em uma estrutura estatística por Leo Breiman (1997), que lançou as bases para outros pesquisadores, como Jerome H. Friedman, modificarem este trabalho para o desenvolvimento do algoritmo de aumento de gradiente para regressão. Posteriormente, muitos pesquisadores desenvolveram esse algoritmo de reforço para muitos outros campos de aprendizado de máquina e estatística, muito além das aplicações iniciais em regressão e classificação.

O termo “Gradiente” em Gradient Boosting refere-se ao fato de você ter duas ou mais derivadas da mesma função (abordaremos isso com mais detalhes posteriormente). Gradient Boosting é um algoritmo de gradiente funcional iterativo, ou seja, um algoritmo que minimiza uma função de perda escolhendo iterativamente uma função que aponta para o gradiente negativo; uma hipótese fraca.

Aumento de gradiente na classificação

Ao longo dos anos, o aumento de gradiente encontrou aplicações em vários campos técnicos. O algoritmo pode parecer complicado no início, mas na maioria dos casos usamos apenas uma configuração predefinida para classificação e outra para regressão, que pode, obviamente, ser modificada com base em seus requisitos. Neste artigo vamos nos concentrar no Gradient Boosting para problemas de classificação. Começaremos dando uma olhada em como o algoritmo funciona nos bastidores, de forma intuitiva e matemática.

O Gradient Boosting tem três componentes principais:

  • Função de perda - A função da função de perda é estimar quão bom o modelo é em fazer previsões com os dados fornecidos. Isso pode variar dependendo do problema em questão. Por exemplo, se estivermos tentando prever o peso de uma pessoa dependendo de algumas variáveis de entrada (um problema de regressão), então a função de perda seria algo que nos ajudaria a encontrar a diferença entre os pesos previstos e os pesos observados. Por outro lado, se estivermos tentando categorizar se uma pessoa gostará de um determinado filme com base em sua personalidade, precisaremos de uma função de perda que nos ajude a entender quão preciso é nosso modelo na classificação de pessoas que gostaram ou não. como certos filmes.
  • Aprendizado fraco - Um aluno fraco é aquele que classifica nossos dados, mas o faz mal, talvez não melhor do que uma adivinhação aleatória. Em outras palavras, tem uma alta taxa de erro. Normalmente são árvores de decisão (também chamadas de tocos de decisão, porque são menos complicadas que as árvores de decisão típicas).
  • Modelo Aditivo - Esta é a abordagem iterativa e sequencial de adicionar as árvores (alunos fracos) uma etapa de cada vez. Após cada iteração, precisamos estar mais próximos do nosso modelo final. Em outras palavras, cada iteração deve reduzir o valor da nossa função de perda.

Uma compreensão intuitiva: visualizando o Gradient Boost

Vamos começar examinando um dos problemas mais comuns de aprendizado de máquina de classificação binária. O objetivo é prever o destino dos passageiros do Titanic com base em algumas características: idade, sexo, etc. Pegaremos apenas um subconjunto do conjunto de dados e escolheremos determinadas colunas, por conveniência. Nosso conjunto de dados é mais ou menos assim:

Dados de passageiros do Titanic

  • Pclass, ou Classe de Passageiro, é categórica: 1, 2 ou 3.
  • Idade é a idade do passageiro quando ele estava no Titanic.
  • Tarifa é a tarifa do passageiro.
  • Sexo é o gênero da pessoa.
  • Sobreviveu refere-se a se a pessoa sobreviveu ou não ao acidente; 0 se não o fizeram, 1 se o fizeram.

Agora vamos ver como o algoritmo Gradient Boosting resolve esse problema.

Começamos com um nó folha que prevê o valor inicial para cada passageiro individual. Para um problema de classificação, será o log(odds) do valor alvo. log(odds) é o equivalente à média em um problema de classificação. Como quatro passageiros em nosso caso sobreviveram e dois não sobreviveram, o log(probabilidade) de um passageiro sobreviver seria:

Esta se torna nossa folha inicial.

Nó folha inicial

A maneira mais fácil de usar o log(odds) para classificação é convertê-lo em probabilidade. Para fazer isso, usaremos esta fórmula:

Nota: Tenha em mente que arredondamos tudo para uma casa decimal aqui e, portanto, o log (probabilidades) e a probabilidade são os mesmos, o que pode não ser sempre o caso.

Se a probabilidade de sobrevivência for superior a 0,5, primeiro classificamos todos no conjunto de dados de treinamento como sobreviventes. (0,5 é um limite comum usado para decisões de classificação feitas com base na probabilidade; observe que o limite pode facilmente ser considerado outra coisa.)

Agora precisamos calcular o Pseudo Residual, ou seja, a diferença entre o valor observado e o valor previsto. Vamos desenhar os resíduos em um gráfico.

Os pontos azuis e amarelos são os valores observados. Os pontos azuis são os passageiros que não sobreviveram com probabilidade 0 e os pontos amarelos são os passageiros que sobreviveram com probabilidade 1. A linha pontilhada aqui representa a probabilidade prevista que é 0,7

Precisamos encontrar o resíduo que seria:

Aqui, 1 denota Sim e 0 denota Não.

Usaremos esse resíduo para obter a próxima árvore. Pode parecer absurdo considerarmos o valor residual em vez do valor real, mas lançaremos mais luz adiante.

Ramificando pontos de dados usando os valores residuais

Usamos aqui um limite de duas folhas para simplificar nosso exemplo, mas na realidade, o Gradient Boost tem um intervalo entre 8 folhas e 32 folhas.

Devido ao limite de folhas, uma folha pode ter vários valores. As previsões são em termos de log (probabilidades), mas essas folhas são derivadas de probabilidades que causam disparidade. Portanto, não podemos simplesmente adicionar a folha única que obtivemos anteriormente e esta árvore para obter novas previsões porque elas são derivadas de fontes diferentes. Temos que usar algum tipo de transformação. A forma mais comum de transformação usada no Gradient Boost for Classification é:

O numerador nesta equação é a soma dos resíduos naquela folha específica.

O denominador é a soma de (probabilidade de predição anterior para cada resíduo) * (1 - mesma probabilidade de predição anterior).

A derivação desta fórmula será explicada na seção Matemática deste artigo.

Por enquanto, vamos colocar a fórmula em prática:

A primeira folha possui apenas um valor residual que é 0,3, e por se tratar da primeira árvore, a probabilidade anterior será o valor da folha inicial, portanto, igual para todos os resíduos. Por isso,

Para a segunda folha,

Da mesma forma, para a última folha:

Agora a árvore transformada se parece com:

Árvore transformada

Agora que o transformamos, podemos adicionar nossa vantagem inicial à nossa nova árvore com uma taxa de aprendizado.

Taxa de aprendizagem é usada para dimensionar a contribuição da nova árvore. Isso resulta em um pequeno passo na direção certa da previsão. A evidência empírica provou que dar muitos pequenos passos na direção certa resulta em uma melhor previsão com um conjunto de dados de teste, ou seja, o conjunto de dados que o modelo nunca viu em comparação com a previsão perfeita na primeira etapa. A taxa de aprendizagem geralmente é um número pequeno como 0,1

Agora podemos calcular uma nova previsão de log (probabilidades) e, portanto, uma nova probabilidade.

Por exemplo, para o primeiro passageiro, Old Tree=0,7. A taxa de aprendizagem que permanece a mesma para todos os registros é igual a 0,1 e ao dimensionar a nova árvore, descobrimos que seu valor é -0,16. Assim, substituindo na fórmula obtemos:

Da mesma forma, substituímos e encontramos o novo log (probabilidades) para cada passageiro e, portanto, encontramos a probabilidade. Usando a nova probabilidade, calcularemos os novos resíduos.

Este processo se repete até que tenhamos atingido o número máximo de árvores especificado ou os resíduos fiquem super pequenos.

Uma compreensão matemática

Agora que entendemos como funciona um algoritmo de Gradient Boosting em um problema de classificação, intuitivamente, seria importante preencher muitas lacunas que deixamos na seção anterior, o que pode ser feito entendendo o processo matematicamente.

Passaremos por cada etapa, uma de cada vez, e tentaremos entendê-las.

xi - Estas são as variáveis de entrada que alimentamos em nosso modelo.

yi- Esta é a variável alvo que estamos tentando prever.

Podemos prever o log de probabilidade dos dados dada a probabilidade prevista

yi é o valor observado (0 ou 1).

p é a probabilidade prevista.

O objetivo seria maximizar a função de log de verossimilhança. Portanto, se usarmos o log(likelihood) como nossa função de perda, onde valores menores representam modelos de melhor ajuste, então:

Agora, o log (probabilidade) é uma função da probabilidade prevista p, mas precisamos que seja uma função do log preditivo (probabilidades). Então, vamos tentar converter a fórmula:

Sabemos que:

Substituindo,

Agora,

Por isso,

Agora que convertemos p em log(odds), esta se torna nossa Função de Perda.

Temos que mostrar que isso é diferenciável.

Isso também pode ser escrito como:

Agora podemos prosseguir para as etapas reais da construção do modelo.

Etapa 1: inicializar o modelo com um valor constante

Aqui, yi são os valores observados, L é a função de perda e gama é o valor de log (probabilidades).

Estamos somando a função de perda, ou seja, somamos a função de perda para cada valor observado.

argmin sobre gama significa que precisamos encontrar um valor de log(odds) que minimize essa soma.

Então, calculamos a derivada de cada função de perda:

… e assim por diante.

Etapa 2: para m=1 para M

(UM)

Esta etapa exige que você calcule o resíduo usando a fórmula fornecida. Já descobrimos que a função de perda é como:

Por isso,

(B) Ajustar uma árvore de regressão aos valores residuais e criar regiões terminais

Como as folhas são limitadas para um ramo, podemos ter mais de um valor em uma região terminal específica.

Em nossa primeira árvore, m=1 e j será o número único para cada nó terminal. Então R11, R21 e assim por diante.

©

Para cada folha da nova árvore, calculamos gama, que é o valor de saída. A soma deve ser apenas para os registros que compõem aquela folha. Em teoria, poderíamos encontrar a derivada em relação ao gama para obter o valor do gama, mas isso poderia ser extremamente cansativo devido às pesadas variáveis incluídas na nossa função de perda.

Substituindo a função de perda e i=1 na equação acima, obtemos:

Usamos o polinômio de Taylor de segunda ordem para aproximar esta função de perda:

Existem três termos em nossa aproximação. Derivando em relação ao gama nos dá:

Igualando isso a 0 e subtraindo o termo derivado único de ambos os lados.

Então, gama será igual a:

A equação gama pode parecer enorme, mas em termos simples, é:

Vamos apenas substituir o valor da derivada da Função Perda

Agora vamos resolver a segunda derivada da Função Perda. Depois de alguns cálculos pesados, obtemos:

Simplificamos o numerador e também o denominador. A solução gama final se parece com:

Estávamos tentando encontrar o valor de gama que, quando adicionado ao log (probabilidades) previsto mais recente, minimiza nossa função de perda. Esta gama funciona quando a nossa região terminal tem apenas um valor residual e, portanto, uma probabilidade prevista. Mas lembre-se do nosso exemplo acima que, devido às folhas restritas no Gradient Boosting, é possível que uma região terminal tenha muitos valores. Então a fórmula generalizada seria:

Portanto, calculamos os valores de saída para cada folha da árvore.

(D)

Esta fórmula nos pede para atualizar nossas previsões agora. Na primeira passagem, m=1 e substituiremos F0 (x), a previsão comum para todas as amostras, ou seja, o valor inicial da folha mais nu, que é a taxa de aprendizado no valor de saída da árvore que construímos anteriormente. O somatório é para os casos em que uma única amostra termina em múltiplas folhas.

Agora usaremos este novo valor F1(x) para obter novas previsões para cada amostra.

O novo valor previsto deve nos aproximar um pouco mais do valor real. Deve-se notar que, ao contrário de uma árvore em nossa consideração, o aumento de gradiente cria muitas árvores e M pode chegar a 100 ou mais.

Isso completa nosso loop for na Etapa 2 e estamos prontos para a etapa final do Gradient Boosting.

Etapa 3: Saída

Se obtivermos novos dados, usaremos esse valor para prever se o passageiro sobreviveu ou não. Isso nos daria o log (probabilidades) de que a pessoa sobreviveu. Conectando-o à fórmula 'p':

Se o valor resultante estiver acima do nosso limite, a pessoa sobreviveu, caso contrário, não.

Implementação de Gradient Boosting usando Python

Trabalharemos com o conjunto de dados completo do Titanic disponível no Kaggle. O conjunto de dados já está dividido em conjunto de treinamento e conjunto de teste para nossa conveniência.

O primeiro passo seria importar as bibliotecas que precisaremos no processo.

import pandas as pd
from sklearn.ensemble import GradientBoostingClassifier
import numpy as np
from sklearn import metrics

Em seguida, carregaremos nossos dados de treinamento e teste

train = pd.read_csv("train.csv")
test= pd.read_csv("test.csv")

Vamos imprimir os tipos de dados de cada coluna

train.info(), test.info()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 891 entries, 0 to 890
Data columns (total 12 columns):
PassengerId    891 non-null int64
Survived       891 non-null int64
Pclass         891 non-null int64
Name           891 non-null object
Sex            891 non-null object
Age            714 non-null float64
SibSp          891 non-null int64
Parch          891 non-null int64
Ticket         891 non-null object
Fare           891 non-null float64
Cabin          204 non-null object
Embarked       889 non-null object
dtypes: float64(2), int64(5), object(5)
memory usage: 83.6+ KB
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 418 entries, 0 to 417
Data columns (total 11 columns):
PassengerId    418 non-null int64
Pclass         418 non-null int64
Name           418 non-null object
Sex            418 non-null object
Age            332 non-null float64
SibSp          418 non-null int64
Parch          418 non-null int64
Ticket         418 non-null object
Fare           417 non-null float64
Cabin          91 non-null object
Embarked       418 non-null object
dtypes: float64(2), int64(4), object(5)
memory usage: 36.0+ KB

Defina PassengerID como nosso índice

# set "PassengerId" variable as index
train.set_index("PassengerId", inplace=True)
test.set_index("PassengerId", inplace=True)

Geramos um conjunto de metas de treinamento e um conjunto de entradas de treinamento e verificamos a forma. Todas as variáveis, exceto as colunas “Sobreviveu”, tornam-se as variáveis ou recursos de entrada e a coluna “Sobreviveu” sozinha se torna nossa variável de destino porque estamos tentando prever com base nas informações dos passageiros se o passageiro sobreviveu ou não.

Junte-se ao conjunto de dados train and test para obter um conjunto de dados train_test

train_test =  train.append(test)

A próxima etapa seria pré-processar os dados antes de inseri-los em nosso modelo.

Fazemos o seguinte pré-processamento:

  1. Remova as colunas “Nome”, “Idade”, “SibSp”, “Ticket”, “Cabin”, “Parch”.
  2. Converta objetos em números com pandas.get_dummies.
  3. Preencha os nulos com valor 0,0 e a ocorrência mais comum no caso de variável categórica.
  4. Transforme dados com o método MinMaxScaler().
  5. Divida aleatoriamente o conjunto de treinamento em subconjuntos de treinamento e validação.
# delete columns that are not used as features for training and prediction
columns_to_drop = ["Name", "Age", "SibSp", "Ticket", "Cabin", "Parch"]
train_test.drop(labels=columns_to_drop, axis=1, inplace=True)

train_test_dummies = pd.get_dummies(train_test, columns=["Sex"])
train_test_dummies.shape

Verifique os valores ausentes nos dados:

train_test_dummies.isna().sum().sort_values(ascending=False)

Embarked      2
Fare          1
Sex_male      0
Sex_female    0
Pclass        0
dtype: int64

Vamos lidar com esses valores ausentes. Para “Embarcado”, imputaremos o valor mais ocorrido e em seguida criaremos variáveis dummy, e para “Tarifa”, imputaremos 0.

train_test_dummies['Embarked'].value_counts()
train_test_dummies['Embarked'].fillna('S',inplace=True) # most common
train_test_dummies['Embarked_S'] = train_test_dummies['Embarked'].map(lambda i: 1 if i=='S' else 0)
train_test_dummies['Embarked_C'] = train_test_dummies['Embarked'].map(lambda i: 1 if i=='C' else 0)
train_test_dummies['Embarked_Q'] = train_test_dummies['Embarked'].map(lambda i: 1 if i=='Q' else 0)
train_test_dummies.drop(['Embarked'],axis=1,inplace=True)

train_test_dummies.fillna(value=0.0, inplace=True)

Uma última olhada para verificar se tratamos todos os valores ausentes.

train_test_dummies.isna().sum().sort_values(ascending=False)

Embarked_Q    0
Embarked_C    0
Embarked_S    0
Sex_male      0
Sex_female    0
Fare          0
Pclass        0
dtype: int64

Todos os valores ausentes parecem ser tratados.

Anteriormente, geramos nosso conjunto de metas. Agora iremos gerar nosso conjunto de recursos/conjunto de entradas.

X_train = train_test_dummies.values[0:891]
X_test = train_test_dummies.values[891:]

É hora de mais uma etapa final antes de ajustarmos nosso modelo, que seria transformar nossos dados para colocar tudo em uma escala específica.

from sklearn.preprocessing import MinMaxScaler
scaler = MinMaxScaler()
X_train_scale = scaler.fit_transform(X_train)
X_test_scale = scaler.transform(X_test)

Agora temos que dividir nosso conjunto de dados em treinamento e teste. Treinamento para treinar nosso modelo e testes para verificar se nosso modelo se ajusta bem ao conjunto de dados.

from sklearn.model_selection import train_test_split
X_train_sub, X_validation_sub, y_train_sub, y_validation_sub = train_test_split(X_train_scale, y_train, random_state=0)

Agora treinamos nosso algoritmo Gradient Boost e verificamos a precisão em diferentes taxas de aprendizado variando de 0 a 1.

learning_rates = [0.05, 0.1, 0.25, 0.5, 0.75, 1]
for learning_rate in learning_rates:
    gb = GradientBoostingClassifier(n_estimators=20, learning_rate = learning_rate, max_features=2, max_depth = 2, random_state = 0)
    gb.fit(X_train_sub, y_train_sub)
    print("Learning rate: ", learning_rate)
    print("Accuracy score (training): {0:.3f}".format(gb.score(X_train_sub, y_train_sub)))
    print("Accuracy score (validation): {0:.3f}".format(gb.score(X_validation_sub, y_validation_sub)))

('Learning rate: ', 0.05)
Accuracy score (training): 0.808
Accuracy score (validation): 0.834
('Learning rate: ', 0.1)
Accuracy score (training): 0.799
Accuracy score (validation): 0.803
('Learning rate: ', 0.25)
Accuracy score (training): 0.811
Accuracy score (validation): 0.803
('Learning rate: ', 0.5)
Accuracy score (training): 0.820
Accuracy score (validation): 0.794
('Learning rate: ', 0.75)
Accuracy score (training): 0.822
Accuracy score (validation): 0.803
('Learning rate: ', 1)
Accuracy score (training): 0.822
Accuracy score (validation): 0.816

Isso completa nosso código. Uma breve explicação sobre os parâmetros usados aqui.

  • n_estimators: o número de estágios de boosting a serem executados. O aumento de gradiente é bastante robusto ao ajuste excessivo, portanto, um número grande geralmente resulta em um melhor desempenho.
  • taxa_de_aprendizagem: a taxa de aprendizagem reduz a contribuição de cada árvore em taxa_de_aprendizagem. Existe uma compensação entre taxa de aprendizagem e n_estimadores.
  • max_features: o número de recursos a serem considerados ao procurar a melhor divisão.
  • max_profundidade: profundidade máxima dos estimadores de regressão individuais. A profundidade máxima limita o número de nós na árvore. Ajuste este parâmetro para melhor desempenho; o melhor valor depende da interação das variáveis de entrada.
  • random_state: random_state é a semente usada pelo gerador de números aleatórios.

Ajuste esses parâmetros para obter a melhor precisão.

Comparando e contrastando AdaBoost e GradientBoost

Tanto o AdaBoost quanto o Gradient Boost aprendem sequencialmente com um conjunto fraco de alunos. Um aluno forte é obtido a partir do modelo aditivo desses alunos fracos. O foco principal aqui é aprender com as deficiências de cada etapa da iteração.

AdaBoost exige que os usuários especifiquem um conjunto de alunos fracos (como alternativa, ele gerará aleatoriamente um conjunto de alunos fracos antes do processo real de aprendizagem). Aumenta os pesos das instâncias previstas incorretamente e diminui os das instâncias previstas corretamente. O aluno fraco, portanto, concentra-se mais nas instâncias difíceis. Depois de treinado, o aluno fraco é adicionado ao forte de acordo com seu desempenho (o chamado peso alfa). Quanto melhor for o seu desempenho, mais contribuirá para o aluno forte.

Por outro lado, o aumento de gradiente não modifica a distribuição da amostra. Em vez de treinar em uma distribuição recém-amostrada, o aluno fraco treina nos erros restantes do aluno forte. É outra forma de dar mais importância às instâncias difíceis. A cada iteração, os pseudo-resíduos são computados e um aluno fraco é ajustado a esses pseudo-resíduos. Então, a contribuição do aluno fraco para o forte não é calculada de acordo com seu desempenho na amostra recém-distribuída, mas usando um processo de otimização de gradiente descendente. A contribuição computada é aquela que minimiza o erro geral do aluno forte.

Adaboost é mais sobre 'votar pesos' e gradiente boosting é mais sobre ' adicionando gradiente otimização'.

Vantagens e desvantagens do Gradient Boost

As vantagens do Gradient Boosting são:

  • Freqüentemente fornece precisão preditiva que não pode ser superada.
  • Muita flexibilidade - pode otimizar diferentes funções de perda e fornece várias opções de ajuste de hiperparâmetros que tornam o ajuste da função muito flexível.
  • Não é necessário pré-processamento de dados - geralmente funciona muito bem com valores categóricos e numéricos como estão.
  • Lida com dados ausentes - imputação não é necessária.

Muito incrível, certo? Vejamos também algumas desvantagens.

  • Os modelos de Gradient Boosting continuarão melhorando para minimizar todos os erros. Isso pode enfatizar demais os valores discrepantes e causar overfitting.
  • Computacionalmente caro - geralmente requer muitas árvores (> 1000), o que pode consumir muito tempo e memória.
  • A alta flexibilidade resulta em muitos parâmetros que interagem e influenciam fortemente o comportamento da abordagem (número de iterações, profundidade da árvore, parâmetros de regularização, etc.). Isso requer uma grande pesquisa na grade durante o ajuste.
  • De natureza menos interpretativa, embora isto seja facilmente resolvido com várias ferramentas.

Conclusão

Neste artigo, foi proposta a abordagem teórica e prática sobre o Algoritmo Gradient Boosting. O Gradient Boosting provou repetidamente ser uma das técnicas mais poderosas para construir modelos preditivos tanto em classificação quanto em regressão. Devido ao fato de que os algoritmos Grading Boosting podem facilmente se ajustar demais a um conjunto de dados de treinamento, diferentes restrições ou métodos de regularização podem ser utilizados para melhorar o desempenho do algoritmo e combater o excesso de ajuste. Aprendizado penalizado, restrições de árvore, amostragem aleatória e redução podem ser utilizados para combater o overfitting.

Muitos dos desafios de aprendizado de máquina da vida real foram resolvidos pelo Gradient Boosting.

Espero que este artigo tenha encorajado você a explorar o Gradient Boosting em profundidade e começar a aplicá-lo em seus problemas de aprendizado de máquina da vida real para aumentar sua precisão!

Referências

  1. Classificadores Gradient Boosting em Python com Scikit-Learn
  2. Impulsionando com AdaBoost e Gradient Boosting - The Making Of… a Data Scientist
  3. Gradient Boost Parte 1: Idéias principais de regressão
  4. Máquinas de aumento de gradiente
  5. Impulsionando com AdaBoost e Gradient Boosting - The Making Of… a Data Scientist
  6. 3.2.4.3.6. sklearn.ensemble.GradientBoostingRegressor — documentação do scikit-learn 0.22.2
  7. Aumento de gradiente para problemas de regressão com exemplo | Noções básicas de algoritmo de regressão
  8. Uma introdução suave ao Gradient Boosting
  9. Compreendendo as máquinas de aumento de gradiente

Artigos relacionados: