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:
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:
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:
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:
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