Primeira vez aqui? Seja bem vindo e cheque o FAQ!
x

Quais sãos as diferenças entre os modelos de regularização de regressões lineares Ridge e Lasso?

+1 voto
81 visitas
perguntada Jul 11 em Aprendizagem de Máquinas por Pedro Gomes (16 pontos)  

Principais diferenças entre os modelos, efeitos da variância e correlação entre variáveis na seleção do modelo estimado, efeito do tamanho da amostra na qualidade da previsão.

Compartilhe

1 Resposta

0 votos
respondida Jul 11 por Pedro Gomes (16 pontos)  
editado Jul 11 por Pedro Gomes

Para lidar com o problema de regularização de regressão lineares, temos que resolver o seguinte problema de minimização:
\[ min_{\beta } \left \| y - X\beta \right \|_{2}^{2} = min_{\beta} \sum_{i=1}^{n}(y_{i} - X_{i}\beta) \]

sujeito a

\[ \left \| \beta \right \|_{p} \leq c \]

Uma norma \( \left \| \beta \right \|_{p} \)diferente, trará soluções diferentes.
Podemos escrever esse problema na forma penalizada:

\[ min_{\beta } \left \| y - X\beta \right \|_{2}^{2} + \lambda\left \| \beta \right \|_{p} \]

Pode-se resolver o problema de várias maneiras. Uma maneira popular mas muito difícil de ser resolvida computacionalmente é a best subset selection, não veremos essa solução aqui.

A outra forma de resolver o problema é através do método Ridge Regression. É a solução dos mínimos quadrados penalizados, esse estimador puxa o beta em direção ao zero e seus componentes mais afetados são os que possuem menor escala. Quanto menor o valor da restrição, mais o modelo vai parecer com um modelo de regressão linear.

\[ \left \| \beta \right \|_{2} = \sum_{j=i}^{K} \beta_{j}^{2} \]

para algum parâmetro \( \lambda \geq 0 \) .

Finalmente, o método LASSO não só ajuda para reduzir o over-fitting mas também ajuda na seleção de varáveis. Novamente, se o valor da restrição tender a zero chegaremos em valores próximos ao valor da regressão linear. A maior diferença entre LASSO e Ridge é que o método LASSO reduz os coeficientes menos importantes para zero, removendo as variáveis de menor importância. Em LASSO, temos:

\[ \left \| \beta \right \|_{2} = \sum_{j=i}^{K}\left | \beta_{j} \right | \]

Para demonstrar as diferenças entre os métodos, vamos ao seguinte exemplo:
Gere 105 variáveis parcialmente correlacionadas com matriz de covariância pre-determinada.

import numpy as np
import pandas as pd
from sklearn.datasets import make_spd_matrix
from sklearn.linear_model import Ridge, Lasso
from scipy import stats
import statsmodels.formula.api as sm
import matplotlib.pyplot as plt
%matplotlib inline

n_var = 105
n_obs = 1000

#cov = make_sparse_spd_matrix(n_var, alpha= 0.0, random_state = RS)
cov = make_spd_matrix(n_var, random_state = 0)
diag = np.random.uniform(1,10,105)
cov[np.diag_indices_from(cov)] = diag
X = np.random.multivariate_normal(np.random.uniform(-100,100,n_var), cov, size=n_obs)
X = pd.DataFrame(X)

Usando modelo de regressão linear com erro distribuído normalmente e simulações Monte Carlo, use as 5 primeiras variáveis de sua matriz para criar uma variável y.

def gen_y(n_obs, intercepto, B):
    e = np.random.normal(0,2,n_obs)
    Y = []
    for i in range(n_obs):
        y = intercepto + X[0][i]*B[0] + X[1][i]*B[1] + X[2][i]*B[2] + X[3][i]*B[3] + X[4][i]*B[4] + e[i]
        Y = np.append(Y,y)
    return Y

def reg_linear(dados):
    reg = sm.ols(formula = "y ~ x_0 + x_1 + x_2 + x_3 + x_4", data=dados).fit()
    return reg

simulacoes=1000
x = X.iloc[:,:5]
B = np.random.normal(np.random.uniform(0,10,1),2,5)
print(B)
intercepto = 3

for i in range(0,simulacoes):
    y_ = gen_y(n_obs, intercepto, B)
    y_ = y_.reshape(-1,1)
    dados = pd.DataFrame(np.column_stack([y_,x]), columns = ['y','x_0', 'x_1', 'x_2', 'x_3', 'x_4'] )
    reg = reg_linear(dados)
    beta = pd.DataFrame(np.array(reg.params))
    if i == 0:
        betas = beta
    else:
        betas = pd.DataFrame(np.column_stack([betas,beta]))
interc_ = np.mean(betas.loc[[0]].T)
betas_ = np.empty([5])
for i in range(1,6):
    betas_[i-1] = np.mean(betas.loc[[i]].T)

y = gen_y(n_obs, interc_, betas_)

Use validação cruzada para estimar o melhor modelo linear regularizado considerando que a sua variável y pode ser gerada a partir das 105 variáveis geradas originalmente. O código a seguir mostra a validação cruzada com os dois métodos:

colnames = []
for i in range(0,n_var): 
    var = 'x_%d'%i
    colnames = np.append(colnames, var)

preditores = colnames
colnames = np.append(colnames, 'y')
data = pd.DataFrame(np.column_stack([X,y]))
data.columns = [colnames]

alphas = [0.00001, 0.0001, 0.001, 0.01, 0.1, 1, 10, 20]
clf = Ridge(alpha=alphas[0], normalize = True)
clf.fit(data[preditores],data['y'])
prev = clf.predict(data[preditores])
score = clf.score(data[preditores],data['y'])
intercepto = clf.intercept_
coef = clf.coef_
resultado_0 = pd.DataFrame(np.column_stack([score,intercepto, coef]))

for i in range(1,8):
    clf = Ridge(alpha=alphas[i], normalize = True)
    clf.fit(data[preditores],data['y'])
    prev = clf.predict(data[preditores])
    score = clf.score(data[preditores],data['y'])
    intercepto = clf.intercept_
    coef = clf.coef_
    resultado = pd.DataFrame(np.column_stack([score, intercepto, coef]))
    resultado_0 = pd.concat([resultado_0, resultado])

colunas = ['score' , 'intercepto']
for i in range(0,n_var): 
    var = 'x_%d'%i
    colunas = np.append(colunas, var)
linha = ['alpha_0_00001','alpha_0_0001', 'alpha_0_001', 'alpha_0_01', 'alpha_0_1', 'alpha_1', 'alpha_10', 'alpha_20']
resultado_0.columns = colunas
resultado_0.index = linha

clflasso = Ridge(alpha=alphas[0], normalize = True, max_iter=1e6)
clflasso.fit(data[preditores],data['y'])
prevlasso = clflasso.predict(data[preditores])
scorelasso = clflasso.score(data[preditores],data['y'])
intclasso = clflasso.intercept_
coeflasso = clflasso.coef_
resultado_lasso = pd.DataFrame(np.column_stack([scorelasso,intclasso,coeflasso]))

for i in range(1,8):
    clflasso = Lasso(alpha=alphas[i], normalize = True, max_iter=1e6)
    clflasso.fit(data[preditores],data['y'])
    prevlasso = clflasso.predict(data[preditores])
    scorelasso = clflasso.score(data[preditores],data['y'])
    intclasso = clf.intercept_
    coeflasso = [clflasso.coef_]
    resultadol = pd.DataFrame(np.column_stack([scorelasso,intclasso,coeflasso]))
    resultado_lasso = pd.concat([resultado_lasso, resultadol])

resultado_lasso.columns = colunas
resultado_lasso.index = linha

Primeiro exemplo gerado para amostra de tamanho 1.000.
O intercepto e os betas gerados foram:
Intercepto 3
Beta1 3,54
Beta2 -0,68
Beta3 -0,31
Beta4 0,66
Beta5 -2,42

Os resultados da Ridge Regression:
A imagem será apresentada aqui.

Os resultados para LASSO:
A imagem será apresentada aqui.

Agora para uma amostra de tamanho 10.000:
Intercepto 3,00
Beta1 5,13
Beta2 1,28
Beta3 5,21
Beta4 0,58
Beta5 5,61

Ridge:
A imagem será apresentada aqui.

LASSO:
A imagem será apresentada aqui.

A escolha do alpha parece fazer muita diferença para o resultado dos modelos, principalmente para encontrar o intercepto. Agora vamos testar o modelo sem intercepto e avaliar os resultados primeiro com a amostra igual a 1.000

Beta1 7,14
Beta2 6,81
Beta3 7,81
Beta4 4,97
Beta5 6,67

Ridge:
A imagem será apresentada aqui.

LASSO:
A imagem será apresentada aqui.

Agora com 10.000 amostras:

Beta1 1,29
Beta2 0,56
Beta3 -1,43
Beta4 3,44
Beta5 0,40

Ridge:
A imagem será apresentada aqui.

LASSO:
A imagem será apresentada aqui.

Observamos que para o modelo sem intercepto os resultados são melhores e com o aumento da amostra também obtemos resultados melhores.

Utilizando a ultima simulação podemos observar os efeitos da variância das 100 ultimas variáveis no nível do coeficiente (com menor alpha), no caso Ridge:
A imagem será apresentada aqui.

LASSO:
A imagem será apresentada aqui.

É nítido a preferência por variáveis com menor variância.

Analogamente, vemos a relação entre os coeficientes das 100 últimas variáveis da matriz com a correlação dessas variáveis com as 5 primeiras (utilizadas para gerar a variável y).
Ridge com o menor alpha:
A imagem será apresentada aqui.

LASSO:
A imagem será apresentada aqui.

É mais difícil perceber mas os coeficientes são tão maiores quanto a sua correlação com as variáveis utilizadas para gerar Y.

...