Assim como o bagging e a otimização, a otimização de gradiente é uma metodologia aplicada com base em outro algoritmo de machine learning. Internamente, a otimização de gradiente envolve dois tipos de modelo:
- um modelo de machine learning "fraco, que normalmente é uma árvore de decisão.
- um modelo de machine learning "strong", composto por vários modelos fracos.
Na otimização de gradiente, um novo modelo fraco é treinado em cada etapa para prever o erro do modelo forte atual (chamado de pseudoresposta). Vamos detalhar "error" mais tarde. Por enquanto, suponha que "quot;error"" seja a diferença entre a previsão e um rótulo regressivo. O modelo fraco (ou seja, "error") é adicionado ao modelo forte com um sinal negativo para reduzir o erro do modelo forte.
O aumento de gradiente é iterativo. Cada iteração invoca a seguinte fórmula:
\[ F_{i+1} = F_i - f_i \]
onde:
- $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 interrupção seja atendido, como um número máximo de iterações ou se o modelo (forte) começar a sobrecarregar, conforme medido em um conjunto de dados de validação separado.
Vamos ilustrar o aumento 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 este código no seguinte conjunto de dados:
Figura 25. Um conjunto de dados regressivos sintéticos com um atributo numérico.
Veja abaixo três gráficos após a primeira iteração do algoritmo de otimização de gradiente:
Figura 26. Três gráficos após a primeira iteração.
Observe o seguinte sobre os gráficos na Figura 26:
- A primeira plotagem mostra as previsões do modelo forte, que atualmente é sempre 0.
- O segundo gráfico mostra o erro, que é o identificador do modelo fraco.
- O terceiro gráfico mostra o modelo fraco.
O primeiro modelo fraco é aprender uma representação aproximada do rótulo e se concentrar principalmente na parte esquerda do espaço do recurso (a parte com mais variação e, portanto, o maior erro no modelo constante constante).
Veja a seguir os mesmos gráficos para outra iteração do algoritmo:
Figura 27. Três gráficos após a segunda iteração.
Observe o seguinte sobre os gráficos na Figura 27:
- O modelo forte agora contém a previsão do modelo fraco da 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 espaço do recurso.
Executamos o algoritmo para mais oito iterações:
Figura 28. Três gráficos após a terceira iteração e a 10a iteração.
Na Figura 28, observe que a previsão de um modelo forte começa a se parecer com o gráfico do conjunto de dados.
Essas figuras ilustram o algoritmo de otimização de gradiente usando árvores de decisão como alunos fracos. Essa combinação é chamada de árvores otimizadas com gradiente (de decisão).
Os gráficos anteriores sugerem a essência da otimização de gradiente. No entanto, este exemplo não tem as duas operações reais a seguir:
- A redução
- A 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 ser adicionado ao modelo forte $f_i$. Esse pequeno valor é chamado de redução. Em outras palavras, em vez de cada iteração usando a seguinte 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 na otimização de gradiente é análoga à taxa de aprendizado em redes neurais. A redução controla a velocidade com que o modelo forte está aprendendo, o que ajuda a limitar o overfitting. Ou seja, um valor de redução mais próximo de 0,0 reduz o overfitting mais 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