Arquivo de outliers - Área de Trampo

Medindo distâncias inteligentes: como a distância de Mahalanobis vê o que outras métricas ignoram

19/12/202531/10/2025 Por antonino

Imagine que você é um treinador de futebol avaliando novos jogadores. Dois atletas estão à mesma distância física de você, mas um está dentro do campo e outro está na arquibancada. A distância euclidiana diria que estão igualmente próximos, mas seu instinto sabe que o jogador no campo está muito mais “perto” do contexto do futebol. A distância de Mahalanobis é como esse instinto treinado – ela considera a distribuição e correlação dos dados para medir distâncias de forma mais inteligente e contextual.

Como isso funciona na prática?

A distância de Mahalanobis vai beyond da simples geometria ao considerar a estrutura de covariância dos dados. Enquanto a distância euclidiana mede distâncias “em linha reta”, a Mahalanobis mede distâncias em termos de desvios padrão da distribuição. Ela automaticamente leva em conta que algumas direções nos dados são mais variáveis que outras, e que características podem estar correlacionadas. Na implementação do Scikit-Learn, essa sofisticação matemática é encapsulada em interfaces simples, permitindo que você use métricas avançadas com a mesma facilidade das básicas.

Mãos na massa: implementando a distância de Mahalanobis no Scikit-Learn

"""
Implementação da distância de Mahalanobis e comparação com outras métricas
Demonstra detecção de outliers e classificação com distâncias inteligentes
"""

import numpy as np
from sklearn.neighbors import NearestNeighbors
from sklearn.covariance import EmpiricalCovariance
from scipy.spatial.distance import mahalanobis
import matplotlib.pyplot as plt

# Gerando dados de jogadores de futebol correlacionados
# [altura_cm, peso_kg, velocidade_kmh] - características naturalmente correlacionadas
np.random.seed(42)
n_jogadores = 100

# Criando dados com correlação entre altura e peso
alturas = np.random.normal(180, 8, n_jogadores)
pesos = alturas * 0.4 + np.random.normal(70, 5, n_jogadores)  # Peso correlacionado com altura
velocidades = np.random.normal(32, 3, n_jogadores)

dados_jogadores = np.column_stack([alturas, pesos, velocidades])

# Calculando a matriz de covariância para a distância de Mahalanobis
covariancia = EmpiricalCovariance().fit(dados_jogadores)
matriz_covariancia = covariancia.covariance_
inversa_covariancia = np.linalg.inv(matriz_covariancia)

print("Matriz de covariância dos dados:")
print(matriz_covariancia)

# Calculando distância de Mahalanobis manualmente
def distancia_mahalanobis_manual(x, y, inv_cov):
    """Implementação manual da fórmula: √((x-y)ᵀ × Σ⁻¹ × (x-y))"""
    diferenca = x - y
    return np.sqrt(diferenca.T @ inv_cov @ diferenca)

# Testando com um jogador médio e um outlier
jogador_medio = np.mean(dados_jogadores, axis=0)
jogador_outlier = np.array([160, 90, 25])  # Baixo, pesado, lento - padrão incomum

# Comparando diferentes distâncias
dist_euclidiana = np.linalg.norm(jogador_medio - jogador_outlier)
dist_mahalanobis_manual = distancia_mahalanobis_manual(jogador_medio, jogador_outlier, inversa_covariancia)
dist_mahalanobis_scipy = mahalanobis(jogador_medio, jogador_outlier, inversa_covariancia)

print(f"\nComparação de distâncias para o jogador outlier:")
print(f"Distância Euclidiana: {dist_euclidiana:.2f}")
print(f"Distância Mahalanobis (manual): {dist_mahalanobis_manual:.2f}")
print(f"Distância Mahalanobis (SciPy): {dist_mahalanobis_scipy:.2f}")

# Usando NearestNeighbors com métrica personalizada (implementação prática)
def mahalanobis_metric(x, y, VI=inversa_covariancia):
    """Métrica personalizada para usar com NearestNeighbors"""
    diferenca = x - y
    return np.sqrt(diferenca @ VI @ diferenca)

vizinhos = NearestNeighbors(n_neighbors=5, metric=mahalanobis_metric)
vizinhos.fit(dados_jogadores)

# Encontrando vizinhos mais próximos usando Mahalanobis
distancias, indices = vizinhos.kneighbors(jogador_medio.reshape(1, -1))
print(f"\nVizinhos mais próximos do jogador médio (Mahalanobis): {indices[0]}")

"""

Implementação da distância de Mahalanobis e comparação com outras métricas

Demonstra detecção de outliers e classificação com distâncias inteligentes

"""

import numpy as np

from sklearn.neighbors import NearestNeighbors

from sklearn.covariance import EmpiricalCovariance

from scipy.spatial.distance import mahalanobis

import matplotlib.pyplot as plt

# Gerando dados de jogadores de futebol correlacionados

# [altura_cm, peso_kg, velocidade_kmh] - características naturalmente correlacionadas

np.random.seed(42)

n_jogadores = 100

# Criando dados com correlação entre altura e peso

alturas = np.random.normal(180, 8, n_jogadores)

pesos = alturas * 0.4 + np.random.normal(70, 5, n_jogadores) # Peso correlacionado com altura

velocidades = np.random.normal(32, 3, n_jogadores)

dados_jogadores = np.column_stack([alturas, pesos, velocidades])

# Calculando a matriz de covariância para a distância de Mahalanobis

covariancia = EmpiricalCovariance().fit(dados_jogadores)

matriz_covariancia = covariancia.covariance_

inversa_covariancia = np.linalg.inv(matriz_covariancia)

print("Matriz de covariância dos dados:")

print(matriz_covariancia)

# Calculando distância de Mahalanobis manualmente

def distancia_mahalanobis_manual(x, y, inv_cov):

"""Implementação manual da fórmula: √((x-y)ᵀ × Σ⁻¹ × (x-y))"""

diferenca = x - y

return np.sqrt(diferenca.T @ inv_cov @ diferenca)

# Testando com um jogador médio e um outlier

jogador_medio = np.mean(dados_jogadores, axis=0)

jogador_outlier = np.array([160, 90, 25]) # Baixo, pesado, lento - padrão incomum

# Comparando diferentes distâncias

dist_euclidiana = np.linalg.norm(jogador_medio - jogador_outlier)

dist_mahalanobis_manual = distancia_mahalanobis_manual(jogador_medio, jogador_outlier, inversa_covariancia)

dist_mahalanobis_scipy = mahalanobis(jogador_medio, jogador_outlier, inversa_covariancia)

print(f"\nComparação de distâncias para o jogador outlier:")

print(f"Distância Euclidiana: {dist_euclidiana:.2f}")

print(f"Distância Mahalanobis (manual): {dist_mahalanobis_manual:.2f}")

print(f"Distância Mahalanobis (SciPy): {dist_mahalanobis_scipy:.2f}")

# Usando NearestNeighbors com métrica personalizada (implementação prática)

def mahalanobis_metric(x, y, VI=inversa_covariancia):

"""Métrica personalizada para usar com NearestNeighbors"""

diferenca = x - y

return np.sqrt(diferenca @ VI @ diferenca)

vizinhos = NearestNeighbors(n_neighbors=5, metric=mahalanobis_metric)

vizinhos.fit(dados_jogadores)

# Encontrando vizinhos mais próximos usando Mahalanobis

distancias, indices = vizinhos.kneighbors(jogador_medio.reshape(1, -1))

print(f"\nVizinhos mais próximos do jogador médio (Mahalanobis): {indices[0]}")

Os detalhes que fazem diferença

A grande vantagem da distância de Mahalanobis é sua capacidade de lidar com dados correlacionados e de diferentes escalas naturalmente. Enquanto com distâncias euclidianas você precisaria normalizar os dados manualmente, a Mahalanobis faz isso automaticamente através da matriz de covariância. Contudo, essa sofisticação vem com um custo computacional maior e a necessidade de estimar reliably a matriz de covariância. Analogamente importante é entender que a Mahalanobis assume uma distribuição aproximadamente normal multivariada; com distribuições muito assimétricas ou multimodais, seu desempenho pode degradar.

Melhor uso: Dados correlacionados com distribuição aproximadamente normal
Vantagem principal: Considera automaticamente escalas e correlações
Limitação: Sensível a estimativas ruins da matriz de covariância
Implementação: Use EmpiricalCovariance para estimativa robusta

Perguntas que os iniciantes fazem

Você deve estar se perguntando: “Quando devo usar Mahalanobis em vez de Euclidiana?” Excelente questão! Use Mahalanobis quando suas características estiverem em escalas diferentes e/ou correlacionadas, especialmente para detecção de outliers. Uma confusão comum é pensar que Mahalanobis sempre performa melhor – na verdade, com dados não correlacionados e bem normalizados, Euclidiana pode ser suficiente e mais rápida. Outra dúvida frequente: “Como a implementação no Scikit-Learn lida com matrizes de covariância singulares?” Ela usa técnicas de regularização para evitar problemas numéricos, mas é sempre bom verificar a qualidade da sua estimativa de covariância.

Para onde ir agora?

Experimente usar a distância de Mahalanobis em seus próprios dados esportivos ou de outras áreas. Comece comparando resultados com Euclidiana e observe as diferenças. Implemente uma métrica personalizada no NearestNeighbors para problemas específicos. O momento “aha!” acontece quando você vê a Mahalanobis identificando padrões e outliers que passariam despercebidos com outras métricas.

Assuntos relacionados

Para dominar a distância de Mahalanobis, estude estes conceitos matemáticos:

Estatística multivariada: covariância, correlação e distribuições normais
Álgebra linear: matrizes, inversas e formas quadráticas
Geometria: elipsoides e transformações de escala
Teoria da probabilidade: distribuições conjuntas e condicionais
Otimização: minimização de distâncias em espaços transformados

Referências que valem a pena

Modelos Lineares Generalizados: Algoritmos Passivo-Agressivos

19/12/202517/10/2025 Por antonino

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.