Tutorial: equação normal para regressão linear

A maioria dos problemas que enfrentamos pode ser resolvida de várias formas. Por exemplo, se quisermos ir de um lado a outro de uma sala, podemos dar a volta caminhando até chegar ao lado oposto — ou simplesmente atravessar em linha reta.

A equação normal reforça exatamente esse conceito. É só mais uma maneira de resolver um problema. Que problema? Vamos explicar no restante deste artigo. Por ora, tudo que você precisa saber é que é uma abordagem eficaz que pode economizar muito tempo ao implementar regressão linear em certas condições.

Vamos aprofundar…

O que é a equação normal?

A equação normal é uma solução em forma fechada usada para encontrar o valor de θ que minimiza a função de custo na regressão linear por mínimos quadrados ordinários (OLS). Outra forma de descrevê-la é como uma abordagem analítica para encontrar os coeficientes que minimizam a função de perda. As duas descrições funcionam, mas o que isso significa na prática? 

A regressão linear faz uma previsão, y_hat, calculando a soma ponderada das features de entrada mais um termo de viés (bias). Em termos matemáticos, podemos representar assim:

Onde θ representa os parâmetros e n é o número de features.

Essencialmente, o que ocorre na equação acima é o produto escalar de θ e x sendo somado. Assim, uma forma mais concisa de representar isso é usar a forma vetorizada:

h(θ) é a função hipótese.

A partir dessa função-alvo aproximada, podemos usar o modelo para fazer previsões. Para saber se o modelo aprendeu bem, é importante medir seu desempenho nos dados de treino. Para isso, calculamos uma função de perda. O objetivo do treinamento é encontrar os valores de theta (θ) que minimizam essa função.

Veja como podemos representar a função de perda matematicamente:

Na equação acima, theta (θ) é um vetor de dimensão n + 1, e nossa função de perda é função desse vetor. Consequentemente, a derivada parcial da função de perda, J, precisa ser tomada em relação a cada parâmetro θ_j. Todas devem ser iguais a zero. Seguindo esse processo e resolvendo todos os valores de θ de θ_0 a θ_n, obtemos os valores de θ que minimizam a perda.

Resolver os parâmetros de θ_0 a θ_n pelo processo descrito acima leva a uma dedução bem trabalhosa. Existe, de fato, uma solução mais rápida.

Veja a fórmula da equação normal:

Onde:

θ → os parâmetros que minimizam a função de perda X → os valores das features de entrada para cada instância y → o vetor de valores de saída para cada instância

Equação normal vs. gradient descent

Embora ambos os métodos busquem encontrar os parâmetros theta (θ) que minimizam a função de perda, a forma de chegar lá é bem diferente em cada caso.

Como já vimos como funciona a equação normal na seção anterior, vamos passar rapidamente pelo gradient descent e depois destacar em que os dois diferem.

Gradient descent

O gradient descent é um dos algoritmos mais usados em machine learning. Ele é aplicado para, iterativamente, encontrar os parâmetros theta (θ) que minimizam a função de perda.

O processo começa avaliando o desempenho do modelo. Em seguida, calcula-se a derivada parcial da função de perda, que indica a inclinação no ponto atual. Por fim, damos passos proporcionais ao gradiente negativo para descer até o mínimo da função de perda, atualizando o conjunto corrente de parâmetros — veja a fórmula abaixo.

Esse processo se repete até a convergência no mínimo da função de perda.

Em que eles diferem?

A diferença mais clara é que a equação normal é analítica. Já o gradient descent é iterativo, ou seja, os parâmetros são ajustados gradualmente até a convergência. Uma diferença adicional embutida nisso é que o gradient descent exige definir uma taxa de aprendizado, que controla o tamanho dos passos rumo ao mínimo da perda. A equação normal dispensa taxa de aprendizado porque não há etapas iterativas — obtemos o resultado diretamente.

Além disso, o escalonamento de features não é necessário quando usamos a equação normal; normalmente fazemos esse escalonamento para garantir que as features tenham faixas de valores semelhantes, pois o gradient descent é sensível às escalas dos dados. Se não normalizarmos as features ao usar gradient descent, podemos introduzir distorções no contorno da função de perda — problema do qual a equação normal não sofre.

Quando usar a equação normal

A melhor forma de decidir se você deve usar a equação normal em vez do gradient descent é entender suas desvantagens.

Calcular a equação normal se torna pesado quando o número de features do dataset é grande. Isso porque, para resolver os parâmetros θ, é preciso computar o termo (X’ X)^-1. O produto X’ X gera uma matriz n x n e, em muitas implementações, a inversão de matriz cresce aproximadamente com o cubo da dimensão. Ou seja, a operação de inversão roda com complexidade O(n^3), o que torna a equação normal muito lenta quando n é muito grande — saiba mais sobre complexidade de tempo.

Assim, é melhor usar gradient descent quando o número de features é grande. Andrew Ng, referência em machine learning e IA, recomenda considerar gradient descent quando o número de features, n, for maior que 10.000. Para 10.000 ou menos, pode valer a pena usar uma abordagem analítica como a equação normal, já que você não precisa escolher uma taxa de aprendizado — ou seja, é um hiperparâmetro a menos para ajustar. No entanto, vale dizer que linguagens como R ou Python geralmente usam decomposição QR para encontrar os coeficientes na regressão linear OLS, pois a decomposição QR é numericamente mais estável e eficiente do que a equação normal. 

Equação normal do zero em Python

Vamos gerar um problema de regressão para testar a equação:

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_regression

# Gera um problema de regressão
X, y = make_regression(
    n_samples=100,
    n_features=2,
    n_informative=2,
    noise = 10,
    random_state=25
    )

# Visualiza a feature no índice 1 vs. o alvo
plt.subplots(figsize=(8, 5))
plt.scatter(X[:, 1], y, marker='o')
plt.xlabel("Feature no índice 1")
plt.ylabel("Alvo")
plt.show()
Tecnologia

Agora vamos implementar a equação normal:

# adiciona x0 = 1 a cada instância
X_b = np.concatenate([np.ones((len(X), 1)), X], axis=1)
# calcula a equação normal
theta_best = np.linalg.inv(X_b.T.dot(X_b)).dot(X_b.T).dot(y)
# melhores valores para theta
intercept, *coef = theta_best
print(f"Intercepto: {intercept}\n\
Coeficientes: {coef}")

Intercept: 0.35921242677977794
Coefficients: [6.129199175400593, 96.44309685893134]
Tecnologia

Vamos colocar o modelo à prova fazendo uma previsão:

# criando uma nova amostra
new_sample = np.array([[-2, 0.25]])
# adicionando o termo de bias à instância
new_sample_b = np.concatenate([np.ones((len(new_sample), 1)), new_sample], axis=1)
# prevendo o valor da nova amostra
new_sample_pred = new_sample_b.dot(theta_best)
print(f"Previsão: {new_sample_pred}")
Prediction: [12.21158829]
Tecnologia

Sempre que você implementar um algoritmo de machine learning do zero, é útil ter um método para validar sua solução; a Scikit-learn é uma das bibliotecas de machine learning mais populares em Python. Ela oferece diversas implementações de algoritmos, incluindo regressão linear, que usaremos para validar nossa equação normal.

from sklearn.linear_model import LinearRegression

lr = LinearRegression()
lr.fit(X, y)

print(f"Intercepto: {lr.intercept_}\n\
Coeficientes: {lr.coef_}")
print(f"Previsão: {lr.predict(new_sample)}")

Intercept: 0.3592124267797807
Coefficients: [ 6.12919918 96.44309686]
Prediction: [12.21158829]
Tecnologia

As soluções são aproximadamente iguais, então podemos confirmar que nossa implementação está correta.