Arquivo de regressao - Página 3 de 4

Analogamente a um montanhista que escala uma montanha envolta em neblina espessa, os Algoritmos Passivo-Agressivos constituem uma abordagem inteligente para aprendizado online. Ademais, conforme documentado no scikit-learn, estes algoritmos ajustam-se apenas quando necessário, economizando recursos computacionais enquanto mantêm performance.

A Analogia do Montanhista na Neblina

Primordialmente, imagine um montanhista tentando encontrar o vale mais profundo em uma montanha coberta por densa neblina. Certamente, ele não pode ver além de alguns metros. Similarmente aos algoritmos passivo-agressivos, sua estratégia é:

Movimento conservador: Fica parado quando está no caminho certo
Correção agressiva: Move-se decisivamente quando erra a direção
Ajuste proporcional ao erro: Quanto maior o engano, maior o passo
Economia de energia: Não se move desnecessariamente

Fundamentação Matemática dos Algoritmos PA

Os algoritmos Passivo-Agressivos resolvem o seguinte problema de otimização a cada passo:

\(\min_{w} \frac{1}{2} ||w – w_t||^2 \quad \text{sujeito a} \quad \ell(w; (x_t, y_t)) = 0\)

Quando a condição não é satisfeita, a atualização torna-se:

\(w_{t+1} = w_t + \tau_t y_t x_t\)

Onde \(\tau_t = \frac{\ell_t}{||x_t||^2}\) é o tamanho do passo agressivo.

Variações do Algoritmo

Conforme a documentação do scikit-learn, existem três variações principais:

PA-I: Com parâmetro de agressividade C upper-bounded
PA-II: Com termo quadrático de suavização

PA: Versão padrão sem parâmetros adicionais

Exemplo Prático: O Montanhista na Neblina

import numpy as np
import matplotlib.pyplot as plt
from sklearn.linear_model import PassiveAggressiveClassifier, PassiveAggressiveRegressor
from sklearn.datasets import make_classification, make_regression
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score, mean_squared_error
from sklearn.preprocessing import StandardScaler

print("=" * 60)
print("ALGORITMOS PASSIVO-AGRESSIVOS: O MONTANHISTA NA NEBLINA")
print("=" * 60)

# 1. CLASSIFICAÇÃO COM PASSIVE AGGRESSIVE
print("\n" + "=" * 50)
print("1. CLASSIFICAÇÃO: O MONTANHISTA BINÁRIO")
print("=" * 50)

# Gerar dados para classificação
X_class, y_class = make_classification(
    n_samples=1000,
    n_features=2,
    n_redundant=0,
    n_informative=2,
    n_clusters_per_class=1,
    random_state=42
)

print(f"Dados de classificação: {X_class.shape[0]} amostras")
print(f"Distribuição das classes: {np.unique(y_class, return_counts=True)}")

# Dividir dados
X_class_train, X_class_test, y_class_train, y_class_test = train_test_split(
    X_class, y_class, test_size=0.3, random_state=42
)

# Normalizar dados
scaler_class = StandardScaler()
X_class_train_scaled = scaler_class.fit_transform(X_class_train)
X_class_test_scaled = scaler_class.transform(X_class_test)

# Treinar Passive Aggressive Classifier
print(f"\n🌫️  MONTANHISTA INICIA NA NEBLINA (CLASSIFICAÇÃO):")

pa_classifier = PassiveAggressiveClassifier(
    C=1.0,           # Parâmetro de agressividade
    max_iter=1000,
    tol=1e-3,
    random_state=42,
    shuffle=True
)

pa_classifier.fit(X_class_train_scaled, y_class_train)

# Fazer previsões
y_class_pred = pa_classifier.predict(X_class_test_scaled)
accuracy_pa = accuracy_score(y_class_test, y_class_pred)

print(f"✅ Acurácia do montanhista: {accuracy_pa:.4f}")
print(f"📊 Número de atualizações: {pa_classifier.n_iter_}")

# 2. REGRESSÃO COM PASSIVE AGGRESSIVE
print("\n" + "=" * 50)
print("2. REGRESSÃO: O MONTANHISTA CONTÍNUO")
print("=" * 50)

# Gerar dados para regressão
X_reg, y_reg = make_regression(
    n_samples=1000,
    n_features=2,
    noise=10.0,
    random_state=42
)

print(f"Dados de regressão: {X_reg.shape[0]} amostras")

# Dividir dados
X_reg_train, X_reg_test, y_reg_train, y_reg_test = train_test_split(
    X_reg, y_reg, test_size=0.3, random_state=42
)

# Normalizar dados
scaler_reg = StandardScaler()
X_reg_train_scaled = scaler_reg.fit_transform(X_reg_train)
X_reg_test_scaled = scaler_reg.transform(X_reg_test)
y_reg_train_scaled = (y_reg_train - y_reg_train.mean()) / y_reg_train.std()
y_reg_test_scaled = (y_reg_test - y_reg_train.mean()) / y_reg_train.std()

# Treinar Passive Aggressive Regressor
print(f"\n🌫️  MONTANHISTA INICIA NA NEBLINA (REGRESSÃO):")

pa_regressor = PassiveAggressiveRegressor(
    C=1.0,
    max_iter=1000,
    tol=1e-3,
    random_state=42,
    shuffle=True
)

pa_regressor.fit(X_reg_train_scaled, y_reg_train_scaled)

# Fazer previsões
y_reg_pred = pa_regressor.predict(X_reg_test_scaled)
mse_pa = mean_squared_error(y_reg_test_scaled, y_reg_pred)

print(f"✅ MSE do montanhista: {mse_pa:.4f}")
print(f"📊 Número de atualizações: {pa_regressor.n_iter_}")

# 🎨 VISUALIZAÇÃO DA ESTRATÉGIA DO MONTANHISTA
print("\n" + "=" * 50)
print("VISUALIZAÇÃO: ESTRATÉGIA NA NEBLINA")
print("=" * 50)

# Criar função de custo para visualização
def montanha_neblina(x, y):
    """Montanha com múltiplos vales - representando a função custo"""
    return (x**2 + y**2) + 3*np.sin(3*x) + 2*np.cos(2*y)

# Gerar coordenadas
x = np.linspace(-3, 3, 100)
y = np.linspace(-3, 3, 100)
X, Y = np.meshgrid(x, y)
Z = montanha_neblina(X, Y)

# Simular estratégia do montanhista PA
np.random.seed(42)
posicao_atual = np.array([2.5, 2.0])
caminho_pa = [posicao_atual.copy()]
custos_pa = [montanha_neblina(posicao_atual[0], posicao_atual[1])]
atualizacoes = [0]  # 0 = passivo, 1 = agressivo

print(f"\n🧭 SIMULAÇÃO DA ESTRATÉGIA PASSIVO-AGRESSIVA:")
print(f"Posição inicial: ({posicao_atual[0]:.2f}, {posicao_atual[1]:.2f})")
print(f"Custo inicial: {custos_pa[0]:.2f}")

# Gradiente numérico
def sentir_inclinacao(x, y, h=0.01):
    grad_x = (montanha_neblina(x + h, y) - montanha_neblina(x - h, y)) / (2 * h)
    grad_y = (montanha_neblina(x, y + h) - montanha_neblina(x, y - h)) / (2 * h)
    return np.array([grad_x, grad_y])

# Estratégia Passivo-Agressiva
num_passos = 30
limiar_erro = 0.5  # Limiar para ativar modo agressivo

for passo in range(num_passos):
    inclinacao = sentir_inclinacao(posicao_atual[0], posicao_atual[1])
    magnitude_erro = np.linalg.norm(inclinacao)
    
    # Decisão: Passivo ou Agressivo?
    if magnitude_erro < limiar_erro:
        # Modo PASSIVO: fica parado ou dá passo muito pequeno
        tamanho_passo = 0.01
        tipo_atualizacao = 0
        status = "PASSIVO"
    else:
        # Modo AGRESSIVO: passo proporcional ao erro
        tamanho_passo = min(0.3, magnitude_erro * 0.2)  # Limitado
        tipo_atualizacao = 1
        status = "AGRESSIVO"
    
    # Atualizar posição
    direcao = -inclinacao / (magnitude_erro + 1e-8)  # Normalizar
    posicao_atual = posicao_atual + tamanho_passo * direcao
    
    # Armazenar trajetória
    caminho_pa.append(posicao_atual.copy())
    custos_pa.append(montanha_neblina(posicao_atual[0], posicao_atual[1]))
    atualizacoes.append(tipo_atualizacao)
    
    if passo % 5 == 0:
        print(f"Passo {passo:2d}: {status:>8} | "
              f"Posição=({posicao_atual[0]:6.3f}, {posicao_atual[1]:6.3f}) | "
              f"Custo={custos_pa[-1]:7.3f} | "
              f"Erro={magnitude_erro:6.3f}")

caminho_pa = np.array(caminho_pa)

print(f"\n🏁 ESTRATÉGIA CONCLUÍDA:")
atualizacoes_agressivas = sum(atualizacoes)
print(f"Total de atualizações agressivas: {atualizacoes_agressivas}/{num_passos}")
print(f"Redução do custo: {custos_pa[0]:.2f} → {custos_pa[-1]:.2f}")

# Visualização comparativa
plt.figure(figsize=(16, 12))

# Gráfico 1: Trajetória do montanhista PA
plt.subplot(2, 3, 1)
contour = plt.contour(X, Y, Z, levels=15, alpha=0.6)
plt.clabel(contour, inline=True, fontsize=8)

# Colorir trajetória por tipo de atualização
for i in range(len(caminho_pa)-1):
    cor = 'red' if atualizacoes[i+1] == 1 else 'blue'
    estilo = '-' if atualizacoes[i+1] == 1 else '--'
    plt.plot([caminho_pa[i,0], caminho_pa[i+1,0]], 
             [caminho_pa[i,1], caminho_pa[i+1,1]], 
             color=cor, linestyle=estilo, linewidth=2)

plt.scatter(caminho_pa[0,0], caminho_pa[0,1], color='green', s=100, label='Início')
plt.scatter(caminho_pa[-1,0], caminho_pa[-1,1], color='black', s=100, label='Fim')
plt.xlabel('Parâmetro X')
plt.ylabel('Parâmetro Y')
plt.title('Estratégia Passivo-Agressiva\n🔴 Agressivo | 🔵 Passivo')
plt.legend()
plt.grid(True, alpha=0.3)

# Gráfico 2: Evolução do custo
plt.subplot(2, 3, 2)
plt.plot(custos_pa, 'b-', linewidth=2, label='Custo')
# Destacar atualizações agressivas
for i, (custo, atualizacao) in enumerate(zip(custos_pa, atualizacoes)):
    if atualizacao == 1 and i > 0:
        plt.scatter(i, custo, color='red', s=50, zorder=5)

plt.xlabel('Passo')
plt.ylabel('Custo')
plt.title('Evolução do Custo\n🔴 Atualizações Agressivas')
plt.grid(True, alpha=0.3)

# Gráfico 3: Tipo de atualização por passo
plt.subplot(2, 3, 3)
plt.step(range(len(atualizacoes)), atualizacoes, where='post', linewidth=2)
plt.xlabel('Passo')
plt.ylabel('Tipo de Atualização')
plt.title('Estratégia: 0=Passivo, 1=Agressivo')
plt.yticks([0, 1], ['Passivo', 'Agressivo'])
plt.grid(True, alpha=0.3)

# Gráfico 4: Comparação com SGD tradicional
plt.subplot(2, 3, 4)
# Simular SGD tradicional para comparação
posicao_sgd = np.array([2.5, 2.0])
caminho_sgd = [posicao_sgd.copy()]
custos_sgd = [montanha_neblina(posicao_sgd[0], posicao_sgd[1])]

for _ in range(num_passos):
    inclinacao = sentir_inclinacao(posicao_sgd[0], posicao_sgd[1])
    posicao_sgd = posicao_sgd - 0.1 * inclinacao  # Passo fixo
    caminho_sgd.append(posicao_sgd.copy())
    custos_sgd.append(montanha_neblina(posicao_sgd[0], posicao_sgd[1]))

caminho_sgd = np.array(caminho_sgd)

plt.plot(custos_pa, 'r-', linewidth=2, label='Passivo-Agressivo')
plt.plot(custos_sgd, 'b-', linewidth=2, label='SGD Tradicional')
plt.xlabel('Passo')
plt.ylabel('Custo')
plt.title('Comparação: PA vs SGD')
plt.legend()
plt.grid(True, alpha=0.3)

# Gráfico 5: Eficiência computacional
plt.subplot(2, 3, 5)
atualizacoes_eficiencia = np.cumsum(atualizacoes)
plt.plot(atualizacoes_eficiencia, 'r-', linewidth=2, label='PA (Atualizações)')
plt.plot(range(len(atualizacoes)), 'b--', linewidth=1, label='SGD (Todas iterações)')
plt.xlabel('Passo')
plt.ylabel('Atualizações Realizadas')
plt.title('Eficiência Computacional')
plt.legend()
plt.grid(True, alpha=0.3)

# Gráfico 6: Impacto do parâmetro C
plt.subplot(2, 3, 6)
valores_C = [0.1, 0.5, 1.0, 2.0, 5.0]
acuracias_C = []

for C_val in valores_C:
    pa_temp = PassiveAggressiveClassifier(C=C_val, random_state=42)
    pa_temp.fit(X_class_train_scaled, y_class_train)
    y_temp_pred = pa_temp.predict(X_class_test_scaled)
    acuracias_C.append(accuracy_score(y_class_test, y_temp_pred))

plt.plot(valores_C, acuracias_C, 'go-', linewidth=2, markersize=6)
plt.xlabel('Parâmetro C (Agressividade)')
plt.ylabel('Acurácia')
plt.title('Impacto do Parâmetro C')
plt.grid(True, alpha=0.3)

plt.tight_layout()
plt.show()

# 💡 ANÁLISE FINAL E RECOMENDAÇÕES
print("\n" + "=" * 50)
print("LIÇÕES DO MONTANHISTA NA NEBLINA")
print("=" * 50)

print(f"\n🎯 VANTAGENS DOS ALGORITMOS PASSIVO-AGRESSIVOS:")
print("• ✅ Eficiência computacional (apenas atualiza quando necessário)")
print("• ✅ Robustez a outliers (passos proporcionais ao erro)")
print("• ✅ Bom para aprendizado online e streaming")
print("• ✅ Performance competitiva com menos recursos")

print(f"\n🌫️  QUANDO USAR ESTA ESTRATÉGIA:")
print("• Datasets muito grandes ou streaming de dados")
print("• Recursos computacionais limitados")
print("• Problemas onde a maioria das amostras é fácil")
print("• Cenários de aprendizado online")

print(f"\n⚙️  CONFIGURAÇÃO PRÁTICA:")
print("• C baixo: Mais conservador, menos atualizações")
print("• C alto: Mais agressivo, mais atualizações")
print("• Normalizar dados para melhor performance")
print("• Monitorar n_iter_ para verificar convergência")

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

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

import numpy as np

import matplotlib.pyplot as plt

from sklearn.linear_model import PassiveAggressiveClassifier, PassiveAggressiveRegressor

from sklearn.datasets import make_classification, make_regression

from sklearn.model_selection import train_test_split

from sklearn.metrics import accuracy_score, mean_squared_error

from sklearn.preprocessing import StandardScaler

print("=" * 60)

print("ALGORITMOS PASSIVO-AGRESSIVOS: O MONTANHISTA NA NEBLINA")

print("=" * 60)

# 1. CLASSIFICAÇÃO COM PASSIVE AGGRESSIVE

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

print("1. CLASSIFICAÇÃO: O MONTANHISTA BINÁRIO")

print("=" * 50)

# Gerar dados para classificação

X_class, y_class = make_classification(

n_samples=1000,

n_features=2,

n_redundant=0,

n_informative=2,

n_clusters_per_class=1,

random_state=42

)

print(f"Dados de classificação: {X_class.shape[0]} amostras")

print(f"Distribuição das classes: {np.unique(y_class, return_counts=True)}")

# Dividir dados

X_class_train, X_class_test, y_class_train, y_class_test = train_test_split(

X_class, y_class, test_size=0.3, random_state=42

)

# Normalizar dados

scaler_class = StandardScaler()

X_class_train_scaled = scaler_class.fit_transform(X_class_train)

X_class_test_scaled = scaler_class.transform(X_class_test)

# Treinar Passive Aggressive Classifier

print(f"\n🌫️ MONTANHISTA INICIA NA NEBLINA (CLASSIFICAÇÃO):")

pa_classifier = PassiveAggressiveClassifier(

C=1.0, # Parâmetro de agressividade

max_iter=1000,

tol=1e-3,

random_state=42,

shuffle=True

)

pa_classifier.fit(X_class_train_scaled, y_class_train)

# Fazer previsões

y_class_pred = pa_classifier.predict(X_class_test_scaled)

accuracy_pa = accuracy_score(y_class_test, y_class_pred)

print(f"✅ Acurácia do montanhista: {accuracy_pa:.4f}")

print(f"📊 Número de atualizações: {pa_classifier.n_iter_}")

# 2. REGRESSÃO COM PASSIVE AGGRESSIVE

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

print("2. REGRESSÃO: O MONTANHISTA CONTÍNUO")

print("=" * 50)

# Gerar dados para regressão

X_reg, y_reg = make_regression(

n_samples=1000,

n_features=2,

noise=10.0,

random_state=42

)

print(f"Dados de regressão: {X_reg.shape[0]} amostras")

# Dividir dados

X_reg_train, X_reg_test, y_reg_train, y_reg_test = train_test_split(

X_reg, y_reg, test_size=0.3, random_state=42

)

# Normalizar dados

scaler_reg = StandardScaler()

X_reg_train_scaled = scaler_reg.fit_transform(X_reg_train)

X_reg_test_scaled = scaler_reg.transform(X_reg_test)

y_reg_train_scaled = (y_reg_train - y_reg_train.mean()) / y_reg_train.std()

y_reg_test_scaled = (y_reg_test - y_reg_train.mean()) / y_reg_train.std()

# Treinar Passive Aggressive Regressor

print(f"\n🌫️ MONTANHISTA INICIA NA NEBLINA (REGRESSÃO):")

pa_regressor = PassiveAggressiveRegressor(

C=1.0,

max_iter=1000,

tol=1e-3,

random_state=42,

shuffle=True

)

pa_regressor.fit(X_reg_train_scaled, y_reg_train_scaled)

# Fazer previsões

y_reg_pred = pa_regressor.predict(X_reg_test_scaled)

mse_pa = mean_squared_error(y_reg_test_scaled, y_reg_pred)

print(f"✅ MSE do montanhista: {mse_pa:.4f}")

print(f"📊 Número de atualizações: {pa_regressor.n_iter_}")

# 🎨 VISUALIZAÇÃO DA ESTRATÉGIA DO MONTANHISTA

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

print("VISUALIZAÇÃO: ESTRATÉGIA NA NEBLINA")

print("=" * 50)

# Criar função de custo para visualização

def montanha_neblina(x, y):

"""Montanha com múltiplos vales - representando a função custo"""

return (x**2 + y**2) + 3*np.sin(3*x) + 2*np.cos(2*y)

# Gerar coordenadas

x = np.linspace(-3, 3, 100)

y = np.linspace(-3, 3, 100)

X, Y = np.meshgrid(x, y)

Z = montanha_neblina(X, Y)

# Simular estratégia do montanhista PA

np.random.seed(42)

posicao_atual = np.array([2.5, 2.0])

caminho_pa = [posicao_atual.copy()]

custos_pa = [montanha_neblina(posicao_atual[0], posicao_atual[1])]

atualizacoes = [0] # 0 = passivo, 1 = agressivo

print(f"\n🧭 SIMULAÇÃO DA ESTRATÉGIA PASSIVO-AGRESSIVA:")

print(f"Posição inicial: ({posicao_atual[0]:.2f}, {posicao_atual[1]:.2f})")

print(f"Custo inicial: {custos_pa[0]:.2f}")

# Gradiente numérico

def sentir_inclinacao(x, y, h=0.01):

grad_x = (montanha_neblina(x + h, y) - montanha_neblina(x - h, y)) / (2 * h)

grad_y = (montanha_neblina(x, y + h) - montanha_neblina(x, y - h)) / (2 * h)

return np.array([grad_x, grad_y])

# Estratégia Passivo-Agressiva

num_passos = 30

limiar_erro = 0.5 # Limiar para ativar modo agressivo

for passo in range(num_passos):

inclinacao = sentir_inclinacao(posicao_atual[0], posicao_atual[1])

magnitude_erro = np.linalg.norm(inclinacao)

# Decisão: Passivo ou Agressivo?

if magnitude_erro < limiar_erro:

# Modo PASSIVO: fica parado ou dá passo muito pequeno

tamanho_passo = 0.01

tipo_atualizacao = 0

status = "PASSIVO"

else:

# Modo AGRESSIVO: passo proporcional ao erro

tamanho_passo = min(0.3, magnitude_erro * 0.2) # Limitado

tipo_atualizacao = 1

status = "AGRESSIVO"

# Atualizar posição

direcao = -inclinacao / (magnitude_erro + 1e-8) # Normalizar

posicao_atual = posicao_atual + tamanho_passo * direcao

# Armazenar trajetória

caminho_pa.append(posicao_atual.copy())

custos_pa.append(montanha_neblina(posicao_atual[0], posicao_atual[1]))

atualizacoes.append(tipo_atualizacao)

if passo % 5 == 0:

print(f"Passo {passo:2d}: {status:>8} | "

f"Posição=({posicao_atual[0]:6.3f}, {posicao_atual[1]:6.3f}) | "

f"Custo={custos_pa[-1]:7.3f} | "

f"Erro={magnitude_erro:6.3f}")

caminho_pa = np.array(caminho_pa)

print(f"\n🏁 ESTRATÉGIA CONCLUÍDA:")

atualizacoes_agressivas = sum(atualizacoes)

print(f"Total de atualizações agressivas: {atualizacoes_agressivas}/{num_passos}")

print(f"Redução do custo: {custos_pa[0]:.2f} → {custos_pa[-1]:.2f}")

# Visualização comparativa

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

# Gráfico 1: Trajetória do montanhista PA

plt.subplot(2, 3, 1)

contour = plt.contour(X, Y, Z, levels=15, alpha=0.6)

plt.clabel(contour, inline=True, fontsize=8)

# Colorir trajetória por tipo de atualização

for i in range(len(caminho_pa)-1):

cor = 'red' if atualizacoes[i+1] == 1 else 'blue'

estilo = '-' if atualizacoes[i+1] == 1 else '--'

plt.plot([caminho_pa[i,0], caminho_pa[i+1,0]],

[caminho_pa[i,1], caminho_pa[i+1,1]],

color=cor, linestyle=estilo, linewidth=2)

plt.scatter(caminho_pa[0,0], caminho_pa[0,1], color='green', s=100, label='Início')

plt.scatter(caminho_pa[-1,0], caminho_pa[-1,1], color='black', s=100, label='Fim')

plt.xlabel('Parâmetro X')

plt.ylabel('Parâmetro Y')

plt.title('Estratégia Passivo-Agressiva\n🔴 Agressivo | 🔵 Passivo')

plt.legend()

plt.grid(True, alpha=0.3)

# Gráfico 2: Evolução do custo

plt.subplot(2, 3, 2)

plt.plot(custos_pa, 'b-', linewidth=2, label='Custo')

# Destacar atualizações agressivas

for i, (custo, atualizacao) in enumerate(zip(custos_pa, atualizacoes)):

if atualizacao == 1 and i > 0:

plt.scatter(i, custo, color='red', s=50, zorder=5)

plt.xlabel('Passo')

plt.ylabel('Custo')

plt.title('Evolução do Custo\n🔴 Atualizações Agressivas')

plt.grid(True, alpha=0.3)

# Gráfico 3: Tipo de atualização por passo

plt.subplot(2, 3, 3)

plt.step(range(len(atualizacoes)), atualizacoes, where='post', linewidth=2)

plt.xlabel('Passo')

plt.ylabel('Tipo de Atualização')

plt.title('Estratégia: 0=Passivo, 1=Agressivo')

plt.yticks([0, 1], ['Passivo', 'Agressivo'])

plt.grid(True, alpha=0.3)

# Gráfico 4: Comparação com SGD tradicional

plt.subplot(2, 3, 4)

# Simular SGD tradicional para comparação

posicao_sgd = np.array([2.5, 2.0])

caminho_sgd = [posicao_sgd.copy()]

custos_sgd = [montanha_neblina(posicao_sgd[0], posicao_sgd[1])]

for _ in range(num_passos):

inclinacao = sentir_inclinacao(posicao_sgd[0], posicao_sgd[1])

posicao_sgd = posicao_sgd - 0.1 * inclinacao # Passo fixo

caminho_sgd.append(posicao_sgd.copy())

custos_sgd.append(montanha_neblina(posicao_sgd[0], posicao_sgd[1]))

caminho_sgd = np.array(caminho_sgd)

plt.plot(custos_pa, 'r-', linewidth=2, label='Passivo-Agressivo')

plt.plot(custos_sgd, 'b-', linewidth=2, label='SGD Tradicional')

plt.xlabel('Passo')

plt.ylabel('Custo')

plt.title('Comparação: PA vs SGD')

plt.legend()

plt.grid(True, alpha=0.3)

# Gráfico 5: Eficiência computacional

plt.subplot(2, 3, 5)

atualizacoes_eficiencia = np.cumsum(atualizacoes)

plt.plot(atualizacoes_eficiencia, 'r-', linewidth=2, label='PA (Atualizações)')

plt.plot(range(len(atualizacoes)), 'b--', linewidth=1, label='SGD (Todas iterações)')

plt.xlabel('Passo')

plt.ylabel('Atualizações Realizadas')

plt.title('Eficiência Computacional')

plt.legend()

plt.grid(True, alpha=0.3)

# Gráfico 6: Impacto do parâmetro C

plt.subplot(2, 3, 6)

valores_C = [0.1, 0.5, 1.0, 2.0, 5.0]

acuracias_C = []

for C_val in valores_C:

pa_temp = PassiveAggressiveClassifier(C=C_val, random_state=42)

pa_temp.fit(X_class_train_scaled, y_class_train)

y_temp_pred = pa_temp.predict(X_class_test_scaled)

acuracias_C.append(accuracy_score(y_class_test, y_temp_pred))

plt.plot(valores_C, acuracias_C, 'go-', linewidth=2, markersize=6)

plt.xlabel('Parâmetro C (Agressividade)')

plt.ylabel('Acurácia')

plt.title('Impacto do Parâmetro C')

plt.grid(True, alpha=0.3)

plt.tight_layout()

plt.show()

# 💡 ANÁLISE FINAL E RECOMENDAÇÕES

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

print("LIÇÕES DO MONTANHISTA NA NEBLINA")

print("=" * 50)

print(f"\n🎯 VANTAGENS DOS ALGORITMOS PASSIVO-AGRESSIVOS:")

print("• ✅ Eficiência computacional (apenas atualiza quando necessário)")

print("• ✅ Robustez a outliers (passos proporcionais ao erro)")

print("• ✅ Bom para aprendizado online e streaming")

print("• ✅ Performance competitiva com menos recursos")

print(f"\n🌫️ QUANDO USAR ESTA ESTRATÉGIA:")

print("• Datasets muito grandes ou streaming de dados")

print("• Recursos computacionais limitados")

print("• Problemas onde a maioria das amostras é fácil")

print("• Cenários de aprendizado online")

print(f"\n⚙️ CONFIGURAÇÃO PRÁTICA:")

print("• C baixo: Mais conservador, menos atualizações")

print("• C alto: Mais agressivo, mais atualizações")

print("• Normalizar dados para melhor performance")

print("• Monitorar n_iter_ para verificar convergência")

Interpretação da Estratégia do Montanhista

Inegavelmente, a estratégia passivo-agressiva demonstra inteligência computacional ao economizar recursos. Afinal, assim como o montanhista que preserva energia na neblina, o algoritmo evita atualizações desnecessárias enquanto mantém precisão.

Casos de Uso Ideais

Aprendizado online: Quando novos dados chegam continuamente
Big data: Datasets que não cabem na memória
Sistemas em tempo real: Classificação de streaming de dados
Recursos limitados: Dispositivos com restrições computacionais

Comparação com Outras Abordagens

Ocasionalmente, algoritmos como SGD podem ser excessivamente “nervosos”, atualizando pesos a cada iteração independentemente da necessidade. Contudo, a abordagem passivo-agressiva oferece um equilíbrio elegante entre conservadorismo e eficácia.

Similarmente ao montanhista experiente que conhece quando economizar energia e quando agir decisivamente, estes algoritmos demonstram sofisticação na alocação de recursos computacionais.

Conclusão

Portanto, os Algoritmos Passivo-Agressivos representam uma evolução natural na otimização de modelos de machine learning. Analogamente à sabedoria do montanhista que navega na neblina, estes algoritmos nos ensinam que às vezes a melhor estratégia é saber quando não agir.

Enfim, compreender esta abordagem proporciona não apenas uma ferramenta prática eficiente, mas também insights valiosos sobre a economia de recursos em sistemas de inteligência artificial em larga escala.

Modelos Lineares Generalizados: Regressão Robusta com Outliers e Erros de Modelagem

O Desafio dos Outliers

Fundamentos Matemáticos

Abordagens Implementadas no scikit-learn

Huber Regressor

RANSAC Regressor

Theil-Sen Regressor

Quando Utilizar Regressão Robusta?

Exemplo Prático em Python

Considerações Finais

Modelos Lineares Generalizados: Algoritmos Passivo-Agressivos

A Analogia do Montanhista na Neblina

Fundamentação Matemática dos Algoritmos PA

Variações do Algoritmo

Exemplo Prático: O Montanhista na Neblina

Interpretação da Estratégia do Montanhista

Casos de Uso Ideais

Comparação com Outras Abordagens

Conclusão