Árvores de decisão com aumento de gradiente

Assim como o bagging e o reforço, o aumento do gradiente é uma metodologia aplicada outro algoritmo de machine learning. informalmente, a intensificação do gradiente envolve dois tipos de modelos:

  • "fraco" de machine learning, que normalmente é uma árvore de decisão.
  • uma "forte" de machine learning, que é composto por várias camadas de modelos de machine learning.

No aumento do gradiente, a cada etapa, um novo modelo fraco é treinado para prever "erro" do modelo forte atual (chamado de pseudoresposta). Vamos detalhar o termo "erro" mais tarde. Por enquanto, suponha "erro" é a diferença entre previsão e um rótulo regressivo. O modelo fraco (ou seja, o "erro") é é adicionado ao modelo forte com um sinal negativo para reduzir o erro da um modelo forte.

A otimização do gradiente é iterativo. Cada iteração invoca a seguinte fórmula:

\[ F_{i+1} = F_i - f_i \]

em que:

  • $F_i$ é o modelo forte na etapa $i$.
  • $f_i$ é o modelo fraco na etapa $i$.

Essa operação é repetida até que um critério de parada seja atendido, como um valor máximo o número de iterações ou se o modelo (forte) começar a ter overfitting conforme medido em uma conjunto de dados de validação separado.

Vamos ilustrar a otimização de gradiente em um conjunto de dados de regressão simples em que:

  • O objetivo é prever $y$ a partir de $x$.
  • O modelo forte é inicializado como uma constante zero: $F_0(x) = 0$.
. 
# Simplified example of regressive gradient boosting.

y = ... # the labels
x = ... # the features

strong_model = []
strong_predictions = np.zeros_like(y) # Initially, the strong model is empty.

for i in range(num_iters):

    # Error of the strong model
    error = strong_predictions - y

    # The weak model is a decision tree (see CART chapter)
    # without pruning and a maximum depth of 3.
    weak_model = tfdf.keras.CartModel(
        task=tfdf.keras.Task.REGRESSION,
        validation_ratio=0.0,
        max_depth=3)
    weak_model.fit(x=x, y=error)

    strong_model.append(weak_model)

    weak_predictions = weak_model.predict(x)[:,0]

    strong_predictions -= weak_predictions

Vamos aplicar esse código no seguinte conjunto de dados:

Um gráfico de informações empíricas para um atributo, x, e seu rótulo, y. O enredo é um série de seno um pouco amortecido ondas

Figura 25. Um conjunto de dados regressivo sintético com um atributo numérico. .

 

Aqui estão três gráficos após a primeira iteração da otimização de gradiente algoritmo:

Três gráficos. O primeiro gráfico mostra a previsão do modelo forte, que é uma reta com inclinação 0 e interseção y 0. O segundo gráfico mostra o erro o modelo forte, que é uma série de ondas senoidal. O terceiro gráfico mostra previsão do modelo fraco, que é um conjunto de valores ondas

Figura 26. Três gráficos após a primeira iteração. .

 

Observe o seguinte sobre os gráficos da Figura 26:

  • O primeiro gráfico mostra as previsões do modelo forte, sempre zero.
  • O segundo gráfico mostra o erro, que é o rótulo do modelo fraco.
  • O terceiro gráfico mostra o modelo fraco.

O primeiro modelo fraco é aprender uma representação aproximada do rótulo e foca na parte esquerda do espaço de atributos (a parte com mais variação, e, portanto, a maior quantidade de erros para o modelo errado constante).

Veja a seguir os mesmos gráficos de outra iteração do algoritmo:

Três gráficos. O primeiro gráfico mostra a previsão do modelo forte, que é um inverso do gráfico da previsão do modelo fraco do gráfico anterior Figura. O segundo gráfico mostra o erro do modelo forte, que é um ruído conjunto de ondas senoidal. O terceiro gráfico mostra a previsão do modelo fraco, que é um par de quadrados ondas

Figura 27. Três gráficos após a segunda iteração. .

 

Observe o seguinte sobre os gráficos da Figura 27:

  • O modelo forte agora contém a previsão do modelo fraco iteração anterior.
  • O novo erro do modelo forte é um pouco menor.
  • A nova previsão do modelo fraco agora se concentra na parte certa do modelo espaço de atributos.

Executamos o algoritmo por mais oito iterações:

Os gráficos mostram o modelo forte se aproximando gradualmente da verdade enquanto a previsão do modelo fraco se torna gradualmente mais fracas.

Figura 28. Três gráficos após a terceira e a décima iteração. .

 

Na Figura 28, observe que a previsão do modelo forte começa a se parecer o gráfico do conjunto de dados.

Essas figuras ilustram o algoritmo de aumento do gradiente usando árvores de decisão como estudantes fracos. Essa combinação é chamada de árvores otimizadas para gradiente (decisão).

Os gráficos anteriores sugerem a essência da otimização do gradiente. No entanto, não tem as duas operações reais a seguir:

  • A redução
  • Otimização de valores de folha com uma etapa do método de Newton.
.

Redução

O modelo fraco $f_i$ é multiplicado por um pequeno valor $\nu$ (por exemplo, $\nu = 0,1$) antes de serem adicionados ao modelo forte $F_i$. Esse pequeno valor é chamado a redução. Em outras palavras, em vez de cada iteração usando os atributos fórmula:

\[ F_{i+1} = F_i - f_i \]

Cada iteração usa a seguinte fórmula:

\[ F_{i+1} = F_i - \nu f_i \]

A redução no aumento do gradiente é análoga à taxa de aprendizado em redes neurais. O encolhimento controla a velocidade de aprendizado do modelo forte, o que ajuda a limitar o overfitting. Ou seja, um valor de redução mais próximo de 0,0 reduz mais o overfitting do que um valor de redução mais próximo de 1,0.

No código acima, a redução seria implementada da seguinte forma:

shrinkage = 0.1   # 0.1 is a common shrinkage value.
strong_predictions -= shrinkage * weak_predictions
Anterior
Outros temas
Próxima
O algoritmo de otimização de gradiente (opcional)