Arquivo de otimizacao - Página 2 de 2

Descida do Gradiente Estocástico: seu aliado para dados que não cabem na memória

19/12/202528/10/2025 Por antonino

Quando o Dataset é Grande Demais e o Computador Pede Socorro

Já tentou abrir aquele arquivo com milhões de linhas no Excel e viu o programa simplesmente travar? Agora imagine essa situação com dados de machine learning, onde você precisa treinar um modelo com informações que não cabem na memória do seu computador. É exatamente nesse momento que a Stochastic Gradient Descent (SGD) se torna sua melhor amiga. Pense nela como a estratégia perfeita para organizar um evento enorme: em vez de tentar conversar com todas as pessoas ao mesmo tempo, você vai de grupo em grupo, e no final todo mundo fica alinhado.

Como é Possível Aprender sem Ver Tudo de Uma Vez?

Você deve estar se perguntando: “Mas como um modelo pode aprender corretamente se só vê pequenos pedaços dos dados por vez?” É uma dúvida completamente válida! Pense em como você aprendeu a cozinhar seu prato favorito. Você não precisou preparar todas as receitas do mundo de uma vez – foi praticando aos poucos, um prato de cada vez. A SGD funciona de maneira similar.

Enquanto os métodos tradicionais exigem que todos os dados estejam disponíveis para cada ajuste:

\(\theta_{t+1} = \theta_t – \eta \nabla J(\theta_t)\)

a SGD faz atualizações mais inteligentes, usando apenas amostras individuais:

\(\theta_{t+1} = \theta_t – \eta \nabla J_i(\theta_t)\)

O mais interessante é que essa abordagem não apenas economiza recursos de memória, mas frequentemente alcança bons resultados mais rapidamente nos estágios iniciais – similar a estudar em sessões curtas e regulares em vez de fazer uma maratona de estudo cansativa.

Mãos na Massa: Construindo Seu Primeiro Modelo com SGD

Vamos imaginar que você está desenvolvendo um sistema para classificar transações financeiras como legítimas ou fraudulentas. São milhares de operações por hora – um cenário ideal para a SGD!

from sklearn.linear_model import SGDClassifier
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler

# Simulando transações financeiras - legítimas (0) e fraudulentas (1)
# Na prática, seriam características como valor, localização, horário, etc.
X, y = make_classification(n_samples=100000, n_features=30, n_classes=2, 
                          random_state=42, n_informative=20)

# Separando entre dados de treino e teste
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, 
                                                   random_state=42)

# ALERTA IMPORTANTE: A SGD é sensível à escala dos dados
# É como tentar medir ingredientes com unidades diferentes - precisa padronizar!
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

# Criando nosso detector de fraudes
fraud_detector = SGDClassifier(
    loss='log',           # Regressão logística - ótima para estimar probabilidades
    penalty='l2',         # Previne que o modelo memorize os dados
    alpha=0.0001,         # Intensidade da regularização
    max_iter=1000,        # Número máximo de épocas
    learning_rate='optimal', # Ajusta automaticamente o ritmo de aprendizado
    random_state=42       # Para resultados reproduzíveis
)

# Treinamento - rápido mesmo com 100.000 exemplos!
fraud_detector.fit(X_train_scaled, y_train)

# Avaliando o desempenho
accuracy = fraud_detector.score(X_test_scaled, y_test)
print(f"Nosso detector identificou {accuracy:.1%} das transações corretamente!")
print(f"O treinamento exigiu {fraud_detector.n_iter_} passadas pelos dados.")

from sklearn.linear_model import SGDClassifier

from sklearn.datasets import make_classification

from sklearn.model_selection import train_test_split

from sklearn.preprocessing import StandardScaler

# Simulando transações financeiras - legítimas (0) e fraudulentas (1)

# Na prática, seriam características como valor, localização, horário, etc.

X, y = make_classification(n_samples=100000, n_features=30, n_classes=2,

random_state=42, n_informative=20)

# Separando entre dados de treino e teste

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2,

random_state=42)

# ALERTA IMPORTANTE: A SGD é sensível à escala dos dados

# É como tentar medir ingredientes com unidades diferentes - precisa padronizar!

scaler = StandardScaler()

X_train_scaled = scaler.fit_transform(X_train)

X_test_scaled = scaler.transform(X_test)

# Criando nosso detector de fraudes

fraud_detector = SGDClassifier(

loss='log', # Regressão logística - ótima para estimar probabilidades

penalty='l2', # Previne que o modelo memorize os dados

alpha=0.0001, # Intensidade da regularização

max_iter=1000, # Número máximo de épocas

learning_rate='optimal', # Ajusta automaticamente o ritmo de aprendizado

random_state=42 # Para resultados reproduzíveis

)

# Treinamento - rápido mesmo com 100.000 exemplos!

fraud_detector.fit(X_train_scaled, y_train)

# Avaliando o desempenho

accuracy = fraud_detector.score(X_test_scaled, y_test)

print(f"Nosso detector identificou {accuracy:.1%} das transações corretamente!")

print(f"O treinamento exigiu {fraud_detector.n_iter_} passadas pelos dados.")

Os Segredos que Eu Descobri na Prática

Quando comecei a trabalhar com SGD, aprendi várias lições importantes através da experiência. Aqui estão as que mais fariam diferença se eu soubesse desde o início:

A normalização dos dados é obrigatória: Se algumas características têm magnitudes muito diferentes, a SGD fica confusa. Use sempre StandardScaler ou MinMaxScaler.
A taxa de aprendizado faz toda a diferença: Inicie com ‘optimal’ ou ‘invscaling’. ‘constant’ pode ser complicado se você não acertar o valor.
Respeite o critério de parada: O parâmetro tol impede que o modelo continue treinando por melhorias insignificantes.
Teste diferentes funções de custo: ‘hinge’ para SVM, ‘log’ para probabilidades, ‘perceptron’ para abordagens mais simples.

Quando a SGD Brilha (e Quando Outras Abordagens São Melhores)

Vamos ser realistas: a SGD não é solução universal. Ela é excepcional quando:

# Cenário 1: Dados em streaming
# Você pode atualizar o modelo conforme novas informações chegam
real_time_detector = SGDClassifier(loss='log', random_state=42)

# Simulando transações chegando em tempo real
batch_size = 500
for i in range(0, len(X_train_scaled), batch_size):
    X_batch = X_train_scaled[i:i + batch_size]
    y_batch = y_train[i:i + batch_size]
    
    real_time_detector.partial_fit(X_batch, y_batch, classes=[0, 1])
    
    # A cada 10 lotes, verifique o progresso
    if (i // batch_size) % 10 == 0:
        current_accuracy = real_time_detector.score(X_test_scaled, y_test)
        print(f"Após {i + batch_size} transações: {current_accuracy:.1%} de acurácia")

# Cenário 1: Dados em streaming

# Você pode atualizar o modelo conforme novas informações chegam

real_time_detector = SGDClassifier(loss='log', random_state=42)

# Simulando transações chegando em tempo real

batch_size = 500

for i in range(0, len(X_train_scaled), batch_size):

X_batch = X_train_scaled[i:i + batch_size]

y_batch = y_train[i:i + batch_size]

real_time_detector.partial_fit(X_batch, y_batch, classes=[0, 1])

# A cada 10 lotes, verifique o progresso

if (i // batch_size) % 10 == 0:

current_accuracy = real_time_detector.score(X_test_scaled, y_test)

print(f"Após {i + batch_size} transações: {current_accuracy:.1%} de acurácia")

Contudo, considere outras abordagens quando:

Seu conjunto de dados é pequeno (menos de 10.000 exemplos) – métodos em lote podem ser mais adequados
Você busca a máxima precisão possível – a SGD pode convergir para soluções subótimas
Os dados são muito ruidosos – a natureza estocástica pode amplificar inconsistências

Perguntas Frequentes (Com Respostas que Eu Gostaria de Ter Tido)

“Por que meu modelo continua treinando indefinidamente?”
Provavelmente o tol está muito baixo ou o learning_rate muito alto. Experimente learning_rate='invscaling' com tol=1e-3.

“Devo usar SGD ou LogisticRegression?”
Para conjuntos acima de 50.000 exemplos, escolha SGD. Abaixo disso, a LogisticRegression oferece mais estabilidade.

“O que significa ‘early_stopping’?”
É como saber quando parar de ajustar o tempero de uma comida – se já está bom, é melhor parar antes de estragar!

“Por que obtenho resultados diferentes a cada execução?”
A SGD possui um componente aleatório inerente. Use random_state=42 (ou qualquer número fixo) para garantir consistência.

A Beleza do Aprendizado Contínuo

Uma das características mais poderosas da SGD é a capacidade de aprendizado incremental:

# Novas transações foram registradas - talvez de um feriado ou promoção especial
novas_transacoes, novos_labels = make_classification(n_samples=1000, n_features=30, 
                                                    random_state=123)

# Aplicando a mesma transformação dos dados originais
novas_transacoes_scaled = scaler.transform(novas_transacoes)

# Atualizando nosso modelo com as novas informações
fraud_detector.partial_fit(novas_transacoes_scaled, novos_labels)

print("Modelo atualizado com sucesso! Agora ele conhece os novos padrões de transação.")
# O melhor: não precisamos retreinar com todos os dados históricos!

# Novas transações foram registradas - talvez de um feriado ou promoção especial

novas_transacoes, novos_labels = make_classification(n_samples=1000, n_features=30,

random_state=123)

# Aplicando a mesma transformação dos dados originais

novas_transacoes_scaled = scaler.transform(novas_transacoes)

# Atualizando nosso modelo com as novas informações

fraud_detector.partial_fit(novas_transacoes_scaled, novos_labels)

print("Modelo atualizado com sucesso! Agora ele conhece os novos padrões de transação.")

# O melhor: não precisamos retreinar com todos os dados históricos!

Próximos Passos na Sua Jornada com SGD

Agora que você compreendeu os fundamentos, aqui estão algumas direções para explorar:

Experimente o SGDRegressor para problemas de regressão – funciona de forma similar, mas prevê valores contínuos
Teste a regularização L1 (penalty='l1') para criar modelos mais esparsos e interpretáveis
Explore o ElasticNet (penalty='elasticnet') que combina as vantagens de L1 e L2
Conheça o warm_start=True para continuar o treinamento de onde parou

A prática é fundamental. Comece com conjuntos de dados de exemplo, depois avance para problemas reais. Quando você encontrar aquele dataset massivo no trabalho, a SGD estará lá para ajudar!

Referências que Realmente Valem a Pena

Documentação Oficial do SGD no Scikit-Learn – A fonte mais confiável para consultas
SGDClassifier – Explicação Detalhada dos Parâmetros
Visualização do Gradient Descent em Ação – Excelente para desenvolver intuição
Artigo “Optimizing Gradient Descent” – Para quem deseja se aprofundar na teoria

E lembre-se: a comunidade de machine learning é incrivelmente colaborativa. Quando encontrar desafios, procure no Stack Overflow – é muito provável que alguém já tenha enfrentado situação similar!

Modelos Lineares Generalizados: Descida do Gradiente Estocástico

19/12/202517/10/2025 Por antonino

Analogamente a um alpinista que escala uma montanha nevada com visibilidade limitada, a Descida do Gradiente Estocástico (SGD) navega pelo terreno complexo da função de custo passo a passo. Ademais, cada passo é baseado na inclinação local imediata, não no panorama completo da montanha.

A Analogia do Alpinista

Primordialmente, imagine um alpinista tentando encontrar o ponto mais baixo de um vale em uma montanha coberta de neve. Certamente, ele não pode ver todo o terreno de uma vez. Similarmente ao SGD, ele deve:

Sentir a inclinação: Usar seus pés para detectar a direção de maior declive
Dar passos pequenos: Mover-se cuidadosamente na direção descendente
Ajustar a rota: Corrigir o caminho baseado no terreno imediato
Evitar quedas: Não dar passos grandes demais que possam levá-lo para cima

A Matemática da Escalada

Cada passo do alpinista (atualização dos parâmetros) segue a fórmula:

\(w_{t+1} = w_t – \eta \nabla Q_i(w_t)\)

Onde o alpinista (parâmetro w) se move contra o gradiente \(\nabla Q_i\) com um tamanho de passo \(\eta\).

Exemplo Prático: O Alpinista na Montanha da Função Custo

import numpy as np
import matplotlib.pyplot as plt
from sklearn.linear_model import SGDRegressor
from sklearn.preprocessing import StandardScaler

print("=" * 60)
print("O ALPINISTA SGD: UMA JORNADA NA MONTANHA")
print("=" * 60)

# Criar uma "montanha" - função custo bidimensional para visualização
def montanha_custo(x, y):
    """Função custo com múltiplos 'vales' e 'montanhas'"""
    return (x**2 + y**2) + 2*np.sin(2*x) + 2*np.cos(2*y) + 0.5*x*y

# Gerar coordenadas para a montanha
x = np.linspace(-3, 3, 100)
y = np.linspace(-3, 3, 100)
X, Y = np.meshgrid(x, y)
Z = montanha_custo(X, Y)

print("🌄 A MONTANHA DA FUNÇÃO CUSTO")
print("Cada ponto (x,y) representa uma combinação de parâmetros")
print("A altura Z representa o custo/erro do modelo")

# Simular a jornada do alpinista SGD
np.random.seed(42)

# Posição inicial do alpinista (parâmetros iniciais)
posicao_atual = np.array([2.5, 2.5])  # Começa no alto da montanha
caminho = [posicao_atual.copy()]
custo_atual = montanha_custo(posicao_atual[0], posicao_atual[1])
custos = [custo_atual]

print(f"\n🎯 O ALPINISTA COMEÇA SUA JORNADA")
print(f"Posição inicial: ({posicao_atual[0]:.2f}, {posicao_atual[1]:.2f})")
print(f"Custo inicial: {custo_atual:.2f}")

# Parâmetros da escalada
taxa_aprendizado = 0.1  # Tamanho do passo
num_passos = 50         # Número máximo de passos
tol = 0.01              # Tolerância para convergência

print(f"\n⚙️  CONFIGURAÇÃO DA ESCALADA:")
print(f"Taxa de aprendizado (tamanho do passo): {taxa_aprendizado}")
print(f"Número máximo de passos: {num_passos}")
print(f"Tolerância de convergência: {tol}")

# Gradiente numérico (o alpinista sentindo a inclinação)
def sentir_inclinacao(x, y, h=0.01):
    """O alpinista sente a inclinação do terreno"""
    grad_x = (montanha_custo(x + h, y) - montanha_custo(x - h, y)) / (2 * h)
    grad_y = (montanha_custo(x, y + h) - montanha_custo(x, y - h)) / (2 * h)
    return np.array([grad_x, grad_y])

# A jornada do alpinista
print(f"\n🚶 O ALPINISTA COMEÇA A DESCER:")
for passo in range(num_passos):
    # O alpinista sente a inclinação (calcula gradiente)
    inclinacao = sentir_inclinacao(posicao_atual[0], posicao_atual[1])
    
    # Verifica se encontrou um vale (gradiente próximo de zero)
    if np.linalg.norm(inclinacao) < tol:
        print(f"🎉 CONVERGÊNCIA! Alpinista encontrou um vale no passo {passo}")
        break
    
    # O alpinista dá um passo (atualiza posição)
    # SGD: usa apenas a inclinação local, não o mapa completo
    posicao_atual = posicao_atual - taxa_aprendizado * inclinacao
    
    # Atualiza custo
    custo_atual = montanha_custo(posicao_atual[0], posicao_atual[1])
    
    caminho.append(posicao_atual.copy())
    custos.append(custo_atual)
    
    # Relatório periódico
    if passo % 10 == 0:
        print(f"Passo {passo:2d}: posição=({posicao_atual[0]:6.3f}, {posicao_atual[1]:6.3f}), "
              f"custo={custo_atual:7.3f}, inclinação={np.linalg.norm(inclinacao):6.3f}")

caminho = np.array(caminho)

print(f"\n🏁 JORNADA CONCLUÍDA:")
print(f"Posição final: ({posicao_atual[0]:.4f}, {posicao_atual[1]:.4f})")
print(f"Custo final: {custo_atual:.4f}")
print(f"Total de passos: {len(caminho)}")
print(f"Redução do custo: {custos[0]:.2f} → {custos[-1]:.2f} "
      f"({100*(custos[0]-custos[-1])/custos[0]:.1f}% de redução)")

# Visualização da jornada
plt.figure(figsize=(15, 10))

# Gráfico 1: Vista superior da montanha com trajetória
plt.subplot(2, 2, 1)
contour = plt.contour(X, Y, Z, levels=20, alpha=0.6)
plt.clabel(contour, inline=True, fontsize=8)
plt.plot(caminho[:, 0], caminho[:, 1], 'ro-', linewidth=2, markersize=4, label='Caminho do Alpinista')
plt.plot(caminho[0, 0], caminho[0, 1], 'go', markersize=8, label='Início')
plt.plot(caminho[-1, 0], caminho[-1, 1], 'bo', markersize=8, label='Fim')

# Adicionar setas mostrando a direção do gradiente em alguns pontos
for i in range(0, len(caminho)-1, 5):
    dx = caminho[i+1, 0] - caminho[i, 0]
    dy = caminho[i+1, 1] - caminho[i, 1]
    plt.arrow(caminho[i, 0], caminho[i, 1], dx, dy, 
              head_width=0.1, head_length=0.1, fc='red', ec='red', alpha=0.6)

plt.xlabel('Parâmetro X')
plt.ylabel('Parâmetro Y')
plt.title('Vista Superior: Caminho do Alpinista na Montanha')
plt.legend()
plt.grid(True, alpha=0.3)
plt.axis('equal')

# Gráfico 2: Vista 3D da jornada (corrigido)
plt.subplot(2, 2, 2, projection='3d')
ax = plt.gca()
ax.plot_surface(X, Y, Z, cmap='terrain', alpha=0.7, edgecolor='none')
ax.plot(caminho[:, 0], caminho[:, 1], custos, 'ro-', linewidth=3, markersize=4, label='Caminho')
ax.scatter(caminho[0, 0], caminho[0, 1], custos[0], color='green', s=100, label='Início')
ax.scatter(caminho[-1, 0], caminho[-1, 1], custos[-1], color='blue', s=100, label='Fim')
ax.set_xlabel('Parâmetro X')
ax.set_ylabel('Parâmetro Y')
ax.set_zlabel('Custo')
ax.set_title('Vista 3D: Jornada na Montanha do Custo')
ax.legend()

# Gráfico 3: Evolução do custo durante a jornada
plt.subplot(2, 2, 3)
plt.plot(custos, 'b-o', linewidth=2, markersize=4)
plt.xlabel('Número do Passo')
plt.ylabel('Custo')
plt.title('Evolução do Custo: Descendo a Montanha')
plt.grid(True, alpha=0.3)

# Anotar pontos importantes
plt.annotate(f'Início: {custos[0]:.2f}', xy=(0, custos[0]), xytext=(5, custos[0]+1),
             arrowprops=dict(arrowstyle='->', color='green'))
plt.annotate(f'Fim: {custos[-1]:.2f}', xy=(len(custos)-1, custos[-1]), 
             xytext=(len(custos)-10, custos[-1]+1),
             arrowprops=dict(arrowstyle='->', color='blue'))

# Gráfico 4: Tamanho dos passos (magnitude do gradiente)
plt.subplot(2, 2, 4)
tamanhos_passos = [np.linalg.norm(caminho[i+1] - caminho[i]) for i in range(len(caminho)-1)]
plt.plot(tamanhos_passos, 'g-o', linewidth=2, markersize=4)
plt.xlabel('Número do Passo')
plt.ylabel('Tamanho do Passo')
plt.title('Evolução do Tamanho dos Passos')
plt.grid(True, alpha=0.3)

plt.tight_layout()
plt.show()

# 💡 COMPARAÇÃO: ALPINISTA SGD vs ALPINISTA TRADICIONAL
print("\n" + "=" * 50)
print("COMPARAÇÃO: ALPINISTA SGD vs TRADICIONAL")
print("=" * 50)

print(f"\n🎯 ALPINISTA SGD (NOSSO HERÓI):")
print("• Sente apenas o terreno imediato sob seus pés")
print("• Cada passo baseado na inclinação local")
print("• Pode oscilar, mas encontra caminhos eficientes")
print("• Funciona bem mesmo sem ver a montanha toda")

print(f"\n🏔️  ALPINISTA TRADICIONAL (GRADIENTE BATCH):")
print("• Precisa ver toda a montanha antes de cada passo")
print("• Passos mais precisos mas computacionalmente caros")
print("• Pode ficar preso em vales locais")
print("• Não escala bem para montanhas muito grandes")

# Simulação de diferentes taxas de aprendizado
print(f"\n🔧 EXPERIMENTO: DIFERENTES TAMANHOS DE PASSO")
taxas_testes = [0.01, 0.1, 0.5, 1.0]
resultados = []

for taxa in taxas_testes:
    pos_test = np.array([2.5, 2.5])
    custo_test = montanha_custo(pos_test[0], pos_test[1])
    
    for _ in range(30):  # Número fixo de passos
        inclinacao = sentir_inclinacao(pos_test[0], pos_test[1])
        pos_test = pos_test - taxa * inclinacao
        custo_test = montanha_custo(pos_test[0], pos_test[1])
    
    resultados.append((taxa, custo_test, pos_test))
    status = "✅ BOM" if custo_test < 2.0 else "⚠️  ALTO"
    print(f"Taxa {taxa:.2f}: custo final = {custo_test:.3f} {status}")

print(f"\n🎓 LIÇÕES DO ALPINISTA:")
print("1. Passos muito pequenos (taxa baixa): demora para chegar")
print("2. Passos muito grandes (taxa alta): pode passar do vale")
print("3. O 'sentir' do terreno (gradiente) é crucial")
print("4. Persistência leva ao fundo do vale (mínimo global)")

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

import numpy as np

import matplotlib.pyplot as plt

from sklearn.linear_model import SGDRegressor

from sklearn.preprocessing import StandardScaler

print("=" * 60)

print("O ALPINISTA SGD: UMA JORNADA NA MONTANHA")

print("=" * 60)

# Criar uma "montanha" - função custo bidimensional para visualização

def montanha_custo(x, y):

"""Função custo com múltiplos 'vales' e 'montanhas'"""

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

# Gerar coordenadas para a montanha

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

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

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

Z = montanha_custo(X, Y)

print("🌄 A MONTANHA DA FUNÇÃO CUSTO")

print("Cada ponto (x,y) representa uma combinação de parâmetros")

print("A altura Z representa o custo/erro do modelo")

# Simular a jornada do alpinista SGD

np.random.seed(42)

# Posição inicial do alpinista (parâmetros iniciais)

posicao_atual = np.array([2.5, 2.5]) # Começa no alto da montanha

caminho = [posicao_atual.copy()]

custo_atual = montanha_custo(posicao_atual[0], posicao_atual[1])

custos = [custo_atual]

print(f"\n🎯 O ALPINISTA COMEÇA SUA JORNADA")

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

print(f"Custo inicial: {custo_atual:.2f}")

# Parâmetros da escalada

taxa_aprendizado = 0.1 # Tamanho do passo

num_passos = 50 # Número máximo de passos

tol = 0.01 # Tolerância para convergência

print(f"\n⚙️ CONFIGURAÇÃO DA ESCALADA:")

print(f"Taxa de aprendizado (tamanho do passo): {taxa_aprendizado}")

print(f"Número máximo de passos: {num_passos}")

print(f"Tolerância de convergência: {tol}")

# Gradiente numérico (o alpinista sentindo a inclinação)

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

"""O alpinista sente a inclinação do terreno"""

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

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

return np.array([grad_x, grad_y])

# A jornada do alpinista

print(f"\n🚶 O ALPINISTA COMEÇA A DESCER:")

for passo in range(num_passos):

# O alpinista sente a inclinação (calcula gradiente)

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

# Verifica se encontrou um vale (gradiente próximo de zero)

if np.linalg.norm(inclinacao) < tol:

print(f"🎉 CONVERGÊNCIA! Alpinista encontrou um vale no passo {passo}")

break

# O alpinista dá um passo (atualiza posição)

# SGD: usa apenas a inclinação local, não o mapa completo

posicao_atual = posicao_atual - taxa_aprendizado * inclinacao

# Atualiza custo

custo_atual = montanha_custo(posicao_atual[0], posicao_atual[1])

caminho.append(posicao_atual.copy())

custos.append(custo_atual)

# Relatório periódico

if passo % 10 == 0:

print(f"Passo {passo:2d}: posição=({posicao_atual[0]:6.3f}, {posicao_atual[1]:6.3f}), "

f"custo={custo_atual:7.3f}, inclinação={np.linalg.norm(inclinacao):6.3f}")

caminho = np.array(caminho)

print(f"\n🏁 JORNADA CONCLUÍDA:")

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

print(f"Custo final: {custo_atual:.4f}")

print(f"Total de passos: {len(caminho)}")

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

f"({100*(custos[0]-custos[-1])/custos[0]:.1f}% de redução)")

# Visualização da jornada

plt.figure(figsize=(15, 10))

# Gráfico 1: Vista superior da montanha com trajetória

plt.subplot(2, 2, 1)

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

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

plt.plot(caminho[:, 0], caminho[:, 1], 'ro-', linewidth=2, markersize=4, label='Caminho do Alpinista')

plt.plot(caminho[0, 0], caminho[0, 1], 'go', markersize=8, label='Início')

plt.plot(caminho[-1, 0], caminho[-1, 1], 'bo', markersize=8, label='Fim')

# Adicionar setas mostrando a direção do gradiente em alguns pontos

for i in range(0, len(caminho)-1, 5):

dx = caminho[i+1, 0] - caminho[i, 0]

dy = caminho[i+1, 1] - caminho[i, 1]

plt.arrow(caminho[i, 0], caminho[i, 1], dx, dy,

head_width=0.1, head_length=0.1, fc='red', ec='red', alpha=0.6)

plt.xlabel('Parâmetro X')

plt.ylabel('Parâmetro Y')

plt.title('Vista Superior: Caminho do Alpinista na Montanha')

plt.legend()

plt.grid(True, alpha=0.3)

plt.axis('equal')

# Gráfico 2: Vista 3D da jornada (corrigido)

plt.subplot(2, 2, 2, projection='3d')

ax = plt.gca()

ax.plot_surface(X, Y, Z, cmap='terrain', alpha=0.7, edgecolor='none')

ax.plot(caminho[:, 0], caminho[:, 1], custos, 'ro-', linewidth=3, markersize=4, label='Caminho')

ax.scatter(caminho[0, 0], caminho[0, 1], custos[0], color='green', s=100, label='Início')

ax.scatter(caminho[-1, 0], caminho[-1, 1], custos[-1], color='blue', s=100, label='Fim')

ax.set_xlabel('Parâmetro X')

ax.set_ylabel('Parâmetro Y')

ax.set_zlabel('Custo')

ax.set_title('Vista 3D: Jornada na Montanha do Custo')

ax.legend()

# Gráfico 3: Evolução do custo durante a jornada

plt.subplot(2, 2, 3)

plt.plot(custos, 'b-o', linewidth=2, markersize=4)

plt.xlabel('Número do Passo')

plt.ylabel('Custo')

plt.title('Evolução do Custo: Descendo a Montanha')

plt.grid(True, alpha=0.3)

# Anotar pontos importantes

plt.annotate(f'Início: {custos[0]:.2f}', xy=(0, custos[0]), xytext=(5, custos[0]+1),

arrowprops=dict(arrowstyle='->', color='green'))

plt.annotate(f'Fim: {custos[-1]:.2f}', xy=(len(custos)-1, custos[-1]),

xytext=(len(custos)-10, custos[-1]+1),

arrowprops=dict(arrowstyle='->', color='blue'))

# Gráfico 4: Tamanho dos passos (magnitude do gradiente)

plt.subplot(2, 2, 4)

tamanhos_passos = [np.linalg.norm(caminho[i+1] - caminho[i]) for i in range(len(caminho)-1)]

plt.plot(tamanhos_passos, 'g-o', linewidth=2, markersize=4)

plt.xlabel('Número do Passo')

plt.ylabel('Tamanho do Passo')

plt.title('Evolução do Tamanho dos Passos')

plt.grid(True, alpha=0.3)

plt.tight_layout()

plt.show()

# 💡 COMPARAÇÃO: ALPINISTA SGD vs ALPINISTA TRADICIONAL

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

print("COMPARAÇÃO: ALPINISTA SGD vs TRADICIONAL")

print("=" * 50)

print(f"\n🎯 ALPINISTA SGD (NOSSO HERÓI):")

print("• Sente apenas o terreno imediato sob seus pés")

print("• Cada passo baseado na inclinação local")

print("• Pode oscilar, mas encontra caminhos eficientes")

print("• Funciona bem mesmo sem ver a montanha toda")

print(f"\n🏔️ ALPINISTA TRADICIONAL (GRADIENTE BATCH):")

print("• Precisa ver toda a montanha antes de cada passo")

print("• Passos mais precisos mas computacionalmente caros")

print("• Pode ficar preso em vales locais")

print("• Não escala bem para montanhas muito grandes")

# Simulação de diferentes taxas de aprendizado

print(f"\n🔧 EXPERIMENTO: DIFERENTES TAMANHOS DE PASSO")

taxas_testes = [0.01, 0.1, 0.5, 1.0]

resultados = []

for taxa in taxas_testes:

pos_test = np.array([2.5, 2.5])

custo_test = montanha_custo(pos_test[0], pos_test[1])

for _ in range(30): # Número fixo de passos

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

pos_test = pos_test - taxa * inclinacao

custo_test = montanha_custo(pos_test[0], pos_test[1])

resultados.append((taxa, custo_test, pos_test))

status = "✅ BOM" if custo_test < 2.0 else "⚠️ ALTO"

print(f"Taxa {taxa:.2f}: custo final = {custo_test:.3f} {status}")

print(f"\n🎓 LIÇÕES DO ALPINISTA:")

print("1. Passos muito pequenos (taxa baixa): demora para chegar")

print("2. Passos muito grandes (taxa alta): pode passar do vale")

print("3. O 'sentir' do terreno (gradiente) é crucial")

print("4. Persistência leva ao fundo do vale (mínimo global)")

Interpretação da Jornada do Alpinista

Inegavelmente, a jornada do alpinista ilustra perfeitamente o funcionamento do SGD. Afinal, cada passo representa uma atualização dos parâmetros baseada no gradiente local, exatamente como o algoritmo funciona na prática.

Lições da Montanha

Taxa de aprendizado como tamanho do passo: Muito pequena = lenta convergência; muito grande = instabilidade
Gradiente como inclinação: Indica a direção de maior descida imediata
Convergência como encontrar o vale: Quando o gradiente se aproxima de zero
Mínimos locais como vales secundários: O alpinista pode ficar preso se não “sentir” o terreno global

Aplicação em Machine Learning Real

Ocasionalmente, em problemas reais, nossa “montanha” tem milhares de dimensões (parâmetros) e é impossível visualizar. Contudo, o princípio permanece o mesmo: seguimos a direção de maior descida do custo, um pequeno passo de cada vez.

Similarmente ao alpinista que confia em seus sentidos imediatos, o SGD confia nos gradientes calculados a partir de pequenos minibatches dos dados.

Conclusão

Portanto, a Descida do Gradiente Estocástico é muito mais que um algoritmo matemático – é uma filosofia de aprendizado passo a passo. Analogamente ao alpinista perseverante, o SGD avança com humildade, reconhecendo que não precisa ver toda a montanha para encontrar o caminho descendente.

Enfim, compreender esta analogia transforma o SGD de uma equação abstrata em uma jornada intuitiva e memorável, facilitando a aplicação prática em projetos de machine learning do mundo real.