Arquivo de Python - Página 60 de 94

Regularização L1 e Seleção de Features

Analogamente à Regressão de Ridge, o Laço (Lasso) constitui outra técnica fundamental de regularização em modelos lineares. Ademais, enquanto a Ridge utiliza penalização L2, o Lasso emprega penalização L1, o que confere propriedades únicas e particularmente úteis para seleção de features.

Fundamentação Matemática do Lasso

Conforme especificado na documentação do scikit-learn, o Lasso resolve o seguinte problema de otimização:

\(\min_{w} \frac{1}{2n} ||X w – y||_2^2 + \alpha ||w||_1\)

Primordialmente, a diferença crucial reside no termo de penalização \(\alpha ||w||_1\), que utiliza a norma L1 em vez da norma L2. Certamente, esta mudança aparentemente sutil produz comportamentos radicalmente diferentes.

Características Distintivas do Lasso

Seleção de features: Capaz de definir coeficientes exatamente para zero
Esparsidade: Produz vetores de coeficientes esparsos
Interpretabilidade: Modelos mais simples e interpretáveis
Regularização L1: Penalização baseada na soma dos valores absolutos

Comparação: Lasso vs Ridge

Enquanto a Ridge regression apenas reduz a magnitude dos coeficientes, o Lasso pode eliminá-los completamente. Similarmente a um processo de seleção natural, apenas as features mais importantes sobrevivem no modelo final.

Exemplo Prático com Lasso

import numpy as np
import matplotlib.pyplot as plt
from sklearn.linear_model import Lasso, Ridge
from sklearn.datasets import make_regression
 
print("=" * 60)
print("DEMONSTRAÇÃO PRÁTICA - REGRESSÃO LASSO COM LEGENDAS")
print("=" * 60)
 
# Gerar dados com features redundantes
X, y = make_regression(n_samples=100, n_features=6, n_informative=3, 
                       noise=0.5, random_state=42)
 
print(f"Dimensões: X {X.shape}, y {y.shape}")
print(f"Features informativas geradas: 3 de 6")
 
# Configurar parâmetros de regularização
n_alphas = 200
alphas = np.logspace(-3, 1, n_alphas)
 
# Armazenar resultados
lasso_coefs = []
ridge_coefs = []
 
for alpha in alphas:
    # Lasso regression
    lasso = Lasso(alpha=alpha, max_iter=10000)
    lasso.fit(X, y)
    lasso_coefs.append(lasso.coef_)
    
    # Ridge regression para comparação
    ridge = Ridge(alpha=alpha)
    ridge.fit(X, y)
    ridge_coefs.append(ridge.coef_)
 
lasso_coefs = np.array(lasso_coefs)
ridge_coefs = np.array(ridge_coefs)
 
# Visualização comparativa com legendas
plt.figure(figsize=(16, 8))
 
# Gráfico Lasso com legendas
plt.subplot(1, 2, 1)
cores = ['red', 'blue', 'green', 'orange', 'purple', 'brown']
for i in range(lasso_coefs.shape[1]):
    plt.plot(alphas, lasso_coefs[:, i], 
             color=cores[i], linewidth=2, 
             label=f'Feature {i+1}')
 
plt.xscale('log')
plt.xlabel('Alpha (escala logarítmica)', fontsize=12)
plt.ylabel('Valor do Coeficiente', fontsize=12)
plt.title('LASSO: Regularização L1\n(Convergência para Zero Exato)', 
          fontsize=14, fontweight='bold')
plt.axhline(y=0, color='black', linestyle='-', alpha=0.3)
plt.grid(True, alpha=0.3)
 
# Adicionar legenda fora do gráfico para melhor visualização
plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left', 
           borderaxespad=0., fontsize=10)
 
# Gráfico Ridge com legendas
plt.subplot(1, 2, 2)
for i in range(ridge_coefs.shape[1]):
    plt.plot(alphas, ridge_coefs[:, i], 
             color=cores[i], linewidth=2, 
             label=f'Feature {i+1}')
 
plt.xscale('log')
plt.xlabel('Alpha (escala logarítmica)', fontsize=12)
plt.ylabel('Valor do Coeficiente', fontsize=12)
plt.title('RIDGE: Regularização L2\n(Convergência Suave para Zero)', 
          fontsize=14, fontweight='bold')
plt.axhline(y=0, color='black', linestyle='-', alpha=0.3)
plt.grid(True, alpha=0.3)
 
# Adicionar legenda fora do gráfico
plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left', 
           borderaxespad=0., fontsize=10)
 
plt.tight_layout()
plt.show()
 
# 💡 ANÁLISE DETALHADA COM DESTAQUE PARA FEATURES SELECIONADAS
print("\n" + "=" * 50)
print("ANÁLISE DE SELEÇÃO DE FEATURES")
print("=" * 50)
 
# Testar diferentes valores de alpha
alpha_valores = [0.001, 0.01, 0.1, 0.5, 1.0]
 
for alpha in alpha_valores:
    lasso_model = Lasso(alpha=alpha, max_iter=10000)
    lasso_model.fit(X, y)
    
    features_nao_nulas = np.where(lasso_model.coef_ != 0)[0]
    features_nulas = np.where(lasso_model.coef_ == 0)[0]
    
    print(f"\nAlpha = {alpha:.3f}:")
    print(f"  Features selecionadas: {features_nao_nulas + 1}")
    print(f"  Features eliminadas: {features_nulas + 1}")
    print(f"  Coeficientes: {lasso_model.coef_}")
 
# 🎯 VISUALIZAÇÃO ALTERNATIVA: GRÁFICO DE BARRAS PARA COEFICIENTES
plt.figure(figsize=(14, 6))
 
# Selecionar um alpha específico para demonstração
alpha_demo = 0.1
lasso_demo = Lasso(alpha=alpha_demo, max_iter=10000)
lasso_demo.fit(X, y)
ridge_demo = Ridge(alpha=alpha_demo)
ridge_demo.fit(X, y)
 
# Gráfico de barras comparativo
plt.subplot(1, 2, 1)
indices = np.arange(len(lasso_demo.coef_))
largura = 0.35
 
plt.bar(indices - largura/2, lasso_demo.coef_, largura, 
        label='Lasso', alpha=0.7, color='red')
plt.bar(indices + largura/2, ridge_demo.coef_, largura, 
        label='Ridge', alpha=0.7, color='blue')
 
plt.xlabel('Features')
plt.ylabel('Valor do Coeficiente')
plt.title(f'Comparação Lasso vs Ridge (alpha={alpha_demo})')
plt.xticks(indices, [f'F{i+1}' for i in range(len(lasso_demo.coef_))])
plt.legend()
plt.grid(True, alpha=0.3)
 
# Gráfico de sparsidade
plt.subplot(1, 2, 2)
coeficientes_nao_nulos = (lasso_demo.coef_ != 0).astype(int)
plt.bar(range(len(coeficientes_nao_nulos)), coeficientes_nao_nulos, 
        color=['red' if x == 0 else 'green' for x in coeficientes_nao_nulos])
plt.xlabel('Features')
plt.ylabel('Selecionada (1) / Eliminada (0)')
plt.title('Sparsidade do Lasso: Features Selecionadas')
plt.xticks(range(len(coeficientes_nao_nulos)), 
           [f'F{i+1}' for i in range(len(coeficientes_nao_nulos))])
 
plt.tight_layout()
plt.show()
 
print("\n" + "=" * 50)
print("INTERPRETAÇÃO DOS RESULTADOS")
print("=" * 50)
 
print("""
🔍 OBSERVAÇÕES:
 
1. LASSO (L1):
   • Coeficientes podem se tornar EXATAMENTE zero
   • Efeito de seleção de features
   • Modelos esparsos e interpretáveis
 
2. RIDGE (L2):
   • Coeficientes apenas se aproximam de zero
   • Sem eliminação completa de features
   • Convergência mais suave
 
3. LEGENDAS:
   • Agora cada feature é claramente identificada
   • Cores consistentes facilitam a comparação
   • Posicionamento evita sobreposição
""")

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

import numpy as np

import matplotlib.pyplot as plt

from sklearn.linear_model import Lasso, Ridge

from sklearn.datasets import make_regression

print("=" * 60)

print("DEMONSTRAÇÃO PRÁTICA - REGRESSÃO LASSO COM LEGENDAS")

print("=" * 60)

# Gerar dados com features redundantes

X, y = make_regression(n_samples=100, n_features=6, n_informative=3,

noise=0.5, random_state=42)

print(f"Dimensões: X {X.shape}, y {y.shape}")

print(f"Features informativas geradas: 3 de 6")

# Configurar parâmetros de regularização

n_alphas = 200

alphas = np.logspace(-3, 1, n_alphas)

# Armazenar resultados

lasso_coefs = []

ridge_coefs = []

for alpha in alphas:

# Lasso regression

lasso = Lasso(alpha=alpha, max_iter=10000)

lasso.fit(X, y)

lasso_coefs.append(lasso.coef_)

# Ridge regression para comparação

ridge = Ridge(alpha=alpha)

ridge.fit(X, y)

ridge_coefs.append(ridge.coef_)

lasso_coefs = np.array(lasso_coefs)

ridge_coefs = np.array(ridge_coefs)

# Visualização comparativa com legendas

plt.figure(figsize=(16, 8))

# Gráfico Lasso com legendas

plt.subplot(1, 2, 1)

cores = ['red', 'blue', 'green', 'orange', 'purple', 'brown']

for i in range(lasso_coefs.shape[1]):

plt.plot(alphas, lasso_coefs[:, i],

color=cores[i], linewidth=2,

label=f'Feature {i+1}')

plt.xscale('log')

plt.xlabel('Alpha (escala logarítmica)', fontsize=12)

plt.ylabel('Valor do Coeficiente', fontsize=12)

plt.title('LASSO: Regularização L1\n(Convergência para Zero Exato)',

fontsize=14, fontweight='bold')

plt.axhline(y=0, color='black', linestyle='-', alpha=0.3)

plt.grid(True, alpha=0.3)

# Adicionar legenda fora do gráfico para melhor visualização

plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left',

borderaxespad=0., fontsize=10)

# Gráfico Ridge com legendas

plt.subplot(1, 2, 2)

for i in range(ridge_coefs.shape[1]):

plt.plot(alphas, ridge_coefs[:, i],

color=cores[i], linewidth=2,

label=f'Feature {i+1}')

plt.xscale('log')

plt.xlabel('Alpha (escala logarítmica)', fontsize=12)

plt.ylabel('Valor do Coeficiente', fontsize=12)

plt.title('RIDGE: Regularização L2\n(Convergência Suave para Zero)',

fontsize=14, fontweight='bold')

plt.axhline(y=0, color='black', linestyle='-', alpha=0.3)

plt.grid(True, alpha=0.3)

# Adicionar legenda fora do gráfico

plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left',

borderaxespad=0., fontsize=10)

plt.tight_layout()

plt.show()

# 💡 ANÁLISE DETALHADA COM DESTAQUE PARA FEATURES SELECIONADAS

print("\n" + "=" * 50)

print("ANÁLISE DE SELEÇÃO DE FEATURES")

print("=" * 50)

# Testar diferentes valores de alpha

alpha_valores = [0.001, 0.01, 0.1, 0.5, 1.0]

for alpha in alpha_valores:

lasso_model = Lasso(alpha=alpha, max_iter=10000)

lasso_model.fit(X, y)

features_nao_nulas = np.where(lasso_model.coef_ != 0)[0]

features_nulas = np.where(lasso_model.coef_ == 0)[0]

print(f"\nAlpha = {alpha:.3f}:")

print(f" Features selecionadas: {features_nao_nulas + 1}")

print(f" Features eliminadas: {features_nulas + 1}")

print(f" Coeficientes: {lasso_model.coef_}")

# 🎯 VISUALIZAÇÃO ALTERNATIVA: GRÁFICO DE BARRAS PARA COEFICIENTES

plt.figure(figsize=(14, 6))

# Selecionar um alpha específico para demonstração

alpha_demo = 0.1

lasso_demo = Lasso(alpha=alpha_demo, max_iter=10000)

lasso_demo.fit(X, y)

ridge_demo = Ridge(alpha=alpha_demo)

ridge_demo.fit(X, y)

# Gráfico de barras comparativo

plt.subplot(1, 2, 1)

indices = np.arange(len(lasso_demo.coef_))

largura = 0.35

plt.bar(indices - largura/2, lasso_demo.coef_, largura,

label='Lasso', alpha=0.7, color='red')

plt.bar(indices + largura/2, ridge_demo.coef_, largura,

label='Ridge', alpha=0.7, color='blue')

plt.xlabel('Features')

plt.ylabel('Valor do Coeficiente')

plt.title(f'Comparação Lasso vs Ridge (alpha={alpha_demo})')

plt.xticks(indices, [f'F{i+1}' for i in range(len(lasso_demo.coef_))])

plt.legend()

plt.grid(True, alpha=0.3)

# Gráfico de sparsidade

plt.subplot(1, 2, 2)

coeficientes_nao_nulos = (lasso_demo.coef_ != 0).astype(int)

plt.bar(range(len(coeficientes_nao_nulos)), coeficientes_nao_nulos,

color=['red' if x == 0 else 'green' for x in coeficientes_nao_nulos])

plt.xlabel('Features')

plt.ylabel('Selecionada (1) / Eliminada (0)')

plt.title('Sparsidade do Lasso: Features Selecionadas')

plt.xticks(range(len(coeficientes_nao_nulos)),

[f'F{i+1}' for i in range(len(coeficientes_nao_nulos))])

plt.tight_layout()

plt.show()

print("\n" + "=" * 50)

print("INTERPRETAÇÃO DOS RESULTADOS")

print("=" * 50)

print("""

🔍 OBSERVAÇÕES:

1. LASSO (L1):

• Coeficientes podem se tornar EXATAMENTE zero

• Efeito de seleção de features

• Modelos esparsos e interpretáveis

2. RIDGE (L2):

• Coeficientes apenas se aproximam de zero

• Sem eliminação completa de features

• Convergência mais suave

3. LEGENDAS:

• Agora cada feature é claramente identificada

• Cores consistentes facilitam a comparação

• Posicionamento evita sobreposição

""")

Vantagens Práticas do Lasso

Inegavelmente, a capacidade de produzir modelos esparsos confere ao Lasso vantagens significativas em cenários específicos. Afinal, em problemas com muitas features, a seleção automática simplifica consideravelmente a interpretação do modelo.

Aplicações Típicas do Lasso

Seleção de variáveis: Identificar features mais relevantes
Modelos interpretáveis: Construir modelos com poucas variáveis
Redução de dimensionalidade: Eliminar features redundantes
Regularização agressiva: Controle rigoroso de overfitting

Considerações de Implementação

Embora poderoso, o Lasso requer alguns cuidados na implementação. Ocasionalmente, pode ser necessário aumentar o número máximo de iterações (max_iter) para garantir convergência, especialmente com muitos dados.

Contudo, o scikit-learn oferece implementações otimizadas como LassoCV que automatizam a seleção do melhor parâmetro alpha através de validação cruzada.

Geometria da Penalização L1

A propriedade de sparsidade do Lasso decorre da geometria da norma L1. Similarmente a um contorno com “cantos”, a interseção entre a função de erro e a restrição L1 tende a ocorrer nos eixos, onde alguns coeficientes são exatamente zero.

Conclusão

Portanto, o Lasso representa uma ferramenta valiosa no arsenal do cientista de dados. Analogamente a um filtro de precisão, ele é capaz de separar sinais importantes de ruído estatístico.

Enfim, a compreensão das diferenças entre Lasso e Ridge é essencial para selecionar a técnica apropriada para cada problema. Inclusive, em muitos casos práticos, uma combinação de ambas através do Elastic Net pode oferecer o melhor dos dois mundos.

A convergência para Zero na Regressão de Ridge

Analogamente a um sistema físico que busca equilíbrio, a Regressão de Ridge possui uma propriedade matemática fundamental de convergir os coeficientes para zero. Ademais, este comportamento é uma consequência direta da formulação de sua função objetivo, conforme documentado no scikit-learn.

Fundamentação Teórica da Convergência

Primordialmente, a Regressão de Ridge modifica o problema dos Mínimos Quadrados Ordinários através da adição de um termo de penalização. Conforme a documentação oficial, a função objetivo é expressa por:

\(\min_{w} ||X w – y||_2^2 + \alpha ||w||_2^2\)

Certamente, o termo \(\alpha ||w||_2^2\) introduz uma penalização que cresce quadraticamente com a magnitude dos coeficientes. Similarmente a uma força restauradora, este termo puxa os coeficientes em direção à origem.

Análise do Comportamento Assintótico

Quando examinamos os limites matemáticos, observamos que:

Para \(\alpha \to 0\): Recuperamos a solução dos Mínimos Quadrados Ordinários
Para \(\alpha \to \infty\): Os coeficientes convergem necessariamente para zero
O termo dominante na função objetivo torna-se \(\alpha ||w||_2^2\)

Exemplo Prático com Matriz de Hilbert

import numpy as np
import matplotlib.pyplot as plt
from sklearn import linear_model

# X é a matriz de Hilbert 10x10 - notoriamente mal condicionada
X = 1. / (np.arange(1, 11) + np.arange(0, 10)[:, np.newaxis])
y = np.ones(10)

print("=" * 60)
print("ANÁLISE DA CONVERGÊNCIA - MATRIZ DE HILBERT")
print("=" * 60)

print(f"Condicionamento da matriz: {np.linalg.cond(X):.2e}")
print("Matriz extremamente mal condicionada - ideal para demonstrar Ridge")

# Computar os caminhos
n_alphas = 200
alphas = np.logspace(-10, -2, n_alphas)

coefs = []
for a in alphas:
    ridge = linear_model.Ridge(alpha=a, fit_intercept=False)
    ridge.fit(X, y)
    coefs.append(ridge.coef_)

# Análise quantitativa
coefs_array = np.array(coefs)
print(f"\nVariação dos coeficientes:")
print(f"Alpha mínimo ({alphas[0]:.2e}): Norma L2 = {np.linalg.norm(coefs_array[0]):.2e}")
print(f"Alpha máximo ({alphas[-1]:.2e}): Norma L2 = {np.linalg.norm(coefs_array[-1]):.2e}")

# Mostrar resultados
ax = plt.gca()
ax.plot(alphas, coefs)
ax.set_xscale('log')
plt.xlabel('alpha')
plt.ylabel('weights')
plt.title('Ridge coefficients as a function of the regularization')
plt.axis('tight')

# Salvar a imagem com alta qualidade
plt.savefig('ridge_coefficients.png', dpi=300, bbox_inches='tight')
print("\nGráfico salvo como 'ridge_coefficients.png' com 300 DPI")

plt.show()

# 💡 ANÁLISE ADICIONAL
print("\n" + "=" * 50)
print("VERIFICAÇÃO MATEMÁTICA")
print("=" * 50)

# Verificação para alpha extremo
alpha_extremo = 1e6
ridge_extremo = linear_model.Ridge(alpha=alpha_extremo, fit_intercept=False)
ridge_extremo.fit(X, y)

print(f"Para alpha = {alpha_extremo:.1e}:")
print(f"Coeficientes: {ridge_extremo.coef_}")
print(f"Próximos de zero? {np.allclose(ridge_extremo.coef_, 0, atol=1e-4)}")

# Explicação matemática
print(f"\nExplicação matemática:")
print("Quando α → ∞, temos: (XᵀX + αI) ≈ αI")
print("Portanto: w ≈ (αI)⁻¹Xᵀy = (1/α) * Xᵀy → 0")

import numpy as np

import matplotlib.pyplot as plt

from sklearn import linear_model

# X é a matriz de Hilbert 10x10 - notoriamente mal condicionada

X = 1. / (np.arange(1, 11) + np.arange(0, 10)[:, np.newaxis])

y = np.ones(10)

print("=" * 60)

print("ANÁLISE DA CONVERGÊNCIA - MATRIZ DE HILBERT")

print("=" * 60)

print(f"Condicionamento da matriz: {np.linalg.cond(X):.2e}")

print("Matriz extremamente mal condicionada - ideal para demonstrar Ridge")

# Computar os caminhos

n_alphas = 200

alphas = np.logspace(-10, -2, n_alphas)

coefs = []

for a in alphas:

ridge = linear_model.Ridge(alpha=a, fit_intercept=False)

ridge.fit(X, y)

coefs.append(ridge.coef_)

# Análise quantitativa

coefs_array = np.array(coefs)

print(f"\nVariação dos coeficientes:")

print(f"Alpha mínimo ({alphas[0]:.2e}): Norma L2 = {np.linalg.norm(coefs_array[0]):.2e}")

print(f"Alpha máximo ({alphas[-1]:.2e}): Norma L2 = {np.linalg.norm(coefs_array[-1]):.2e}")

# Mostrar resultados

ax = plt.gca()

ax.plot(alphas, coefs)

ax.set_xscale('log')

plt.xlabel('alpha')

plt.ylabel('weights')

plt.title('Ridge coefficients as a function of the regularization')

plt.axis('tight')

# Salvar a imagem com alta qualidade

plt.savefig('ridge_coefficients.png', dpi=300, bbox_inches='tight')

print("\nGráfico salvo como 'ridge_coefficients.png' com 300 DPI")

plt.show()

# 💡 ANÁLISE ADICIONAL

print("\n" + "=" * 50)

print("VERIFICAÇÃO MATEMÁTICA")

print("=" * 50)

# Verificação para alpha extremo

alpha_extremo = 1e6

ridge_extremo = linear_model.Ridge(alpha=alpha_extremo, fit_intercept=False)

ridge_extremo.fit(X, y)

print(f"Para alpha = {alpha_extremo:.1e}:")

print(f"Coeficientes: {ridge_extremo.coef_}")

print(f"Próximos de zero? {np.allclose(ridge_extremo.coef_, 0, atol=1e-4)}")

# Explicação matemática

print(f"\nExplicação matemática:")

print("Quando α → ∞, temos: (XᵀX + αI) ≈ αI")

print("Portanto: w ≈ (αI)⁻¹Xᵀy = (1/α) * Xᵀy → 0")

Interpretação do Mecanismo de Convergência

Inegavelmente, a convergência para zero decorre do fato de que, para valores muito grandes de alpha, o termo de penalização domina completamente a função objetivo. Afinal, minimizar \(\alpha ||w||_2^2\) requer necessariamente que \(||w||_2^2 \to 0\).

Benefícios Práticos Desta Convergência

Embora possa parecer contra-intuitivo, esta convergência oferece vantagens significativas:

Estabilidade numérica: Previne coeficientes explosivos em problemas mal condicionados
Controle de variância: Reduz a sensibilidade do modelo a pequenas variações nos dados
Prevenção de overfitting: Coeficientes menores resultam em modelos mais conservadores
Seleção implícita de features: Coeficientes próximos de zero indicam features menos importantes

Salvamento de Gráficos para Documentação

No código apresentado, a linha plt.savefig('ridge_coefficients.png', dpi=300, bbox_inches='tight') é fundamental para documentação. Analogamente a registrar resultados experimentais, salvar gráficos permite:

Análise posterior dos resultados
Inclusão em relatórios e publicações
Comparação com outros experimentos
Reprodutibilidade da pesquisa

O parâmetro dpi=300 garante alta resolução, enquanto bbox_inches='tight' remove bordas desnecessárias.

O Caso Específico da Matriz de Hilbert

No exemplo, a matriz de Hilbert é particularmente interessante porque é extremamente mal condicionada. Ocasionalmente, na regressão linear ordinária, os coeficientes podem atingir valores absurdamente grandes devido a instabilidade numérica.

Contudo, a Regressão de Ridge resolve este problema através da penalização L2. Similarmente a um amortecedor, ela controla as oscilações excessivas dos coeficientes.

Conclusão

Portanto, a convergência para zero não é um defeito da Regressão de Ridge, mas sim sua característica definidora. Analogamente a um sistema de controle que mantém variáveis dentro de limites seguros, a regularização L2 garante que os coeficientes permaneçam em magnitudes razoáveis.

Enfim, compreender este mecanismo é fundamental para aplicar corretamente técnicas de regularização em problemas práticos de machine learning. Inclusive, a capacidade de salvar e documentar visualizações é igualmente importante para o processo científico.

Modelos Lineares Generalizados: Regressão Laço (Lasso)

Regularização L1 e Seleção de Features

Fundamentação Matemática do Lasso

Características Distintivas do Lasso

Comparação: Lasso vs Ridge

Exemplo Prático com Lasso

Vantagens Práticas do Lasso

Aplicações Típicas do Lasso

Considerações de Implementação

Geometria da Penalização L1

Conclusão

Modelos Lineares Generalizados: Regressão de Ridge

A convergência para Zero na Regressão de Ridge

Fundamentação Teórica da Convergência

Análise do Comportamento Assintótico

Exemplo Prático com Matriz de Hilbert

Interpretação do Mecanismo de Convergência

Benefícios Práticos Desta Convergência

Salvamento de Gráficos para Documentação

O Caso Específico da Matriz de Hilbert

Conclusão