Um neurônio só, aprendendo a porta AND

Resgatado de dentro do cerebro_textos.py, onde tinha sido colado por engano. É o passo entre o tijolo 2 e a rede inteira: um neurônio, sem camada oculta, aprendendo sozinho a responder "1 só quando as duas entradas forem 1".

import math
import random

def sigmoid(x):
    return 1 / (1 + math.exp(-x))

def derivada_sigmoid(y):
    return y * (1 - y)

# Dados de treino: [entrada_1, entrada_2] -> resultado esperado
treino = [
    ([0, 0], 0),
    ([0, 1], 0),
    ([1, 0], 0),
    ([1, 1], 1),  # Porta lógica E (AND)
]

# Inicializa pesos aleatórios e taxa de aprendizado
w1, w2, b = random.uniform(-1, 1), random.uniform(-1, 1), random.uniform(-1, 1)
taxa_aprendizado = 0.5

# Ciclo de treinamento (10.000 repetições)
for epoca in range(10000):
    for (x1, x2), esperado in treino:
        # 1. Forward
        z = (x1 * w1) + (x2 * w2) + b
        saida = sigmoid(z)

        # 2. Cálculo do erro
        erro = esperado - saida

        # 3. Backpropagation (Gradiente)
        gradiente = erro * derivada_sigmoid(saida)

        # 4. Ajuste dos pesos
        w1 += taxa_aprendizado * gradiente * x1
        w2 += taxa_aprendizado * gradiente * x2
        b += taxa_aprendizado * gradiente

# Teste com entradas novas
print(f"Teste [1, 1]: {sigmoid(1 * w1 + 1 * w2 + b):.4f} (Esperado: 1)")
print(f"Teste [0, 1]: {sigmoid(0 * w1 + 1 * w2 + b):.4f} (Esperado: 0)")

O que deu quando rodou

Teste [1, 1]: 0.9722 (Esperado: 1)
Teste [0, 1]: 0.0235 (Esperado: 0)

Por que este aprende sempre e o XOR não

O AND é separável por uma reta: dá para traçar um risco no plano que deixa [1,1] de um lado e os outros três do outro. Por isso um neurônio sozinho dá conta, e ele nunca empaca.

O XOR não tem essa reta. É exatamente por isso que a rede do XOR precisa de camada oculta — e é por isso que ela às vezes trava em mínimo local, coisa que este aqui não faz.