Classificação e o perceptron

Traçar a linha que separa

Em vez de prever um número, agora queremos decidir uma categoria: spam ou não, gato ou cachorro, aprovado ou reprovado. O perceptron faz isso traçando uma reta (em 2D) que separa as duas classes — pontos de um lado são uma classe, do outro lado a outra.

Ele começa com uma reta qualquer, geralmente errada. Então olha um ponto mal classificado e empurra a reta na direção dele — gira e desloca um pouquinho para acertá-lo. Repete com o próximo erro. Como num cabo de guerra, a fronteira se ajusta até todos os pontos ficarem do lado certo.

O perceptron aprende a fronteira

Cada passo seleciona um ponto mal classificado (anel amarelo) e ajusta os pesos para corrigi-lo — a fronteira preta gira e desliza. As regiões de fundo mostram o que o perceptron prevê em cada lado. Clique em "treinar" e veja-o convergir.

O modelo: soma ponderada + limiar

// O perceptron: o neurônio artificial mais simples (1958)

// Soma ponderada das entradas + viés, depois uma função degrau:
//   z = w₁·x₁ + w₂·x₂ + ... + b
//   saída = +1 se z ≥ 0, senão −1

def prever(w, b, x):
    z = sum(w[i]*x[i] for i in range(len(x))) + b
    return 1 if z >= 0 else -1

// A fronteira de decisão é onde z = 0:
//   w₁·x₁ + w₂·x₂ + b = 0   →  uma RETA (em 2D)
// De um lado a saída é +1, do outro −1.

A regra de aprendizado e seu limite

// Regra de aprendizado do perceptron

def treinar(dados, alpha=0.1):
    w = [0.0, 0.0]; b = 0.0
    while True:
        erros = 0
        for x, alvo in dados:
            if prever(w, b, x) != alvo:
                // empurra a fronteira na direção do ponto errado
                for i in range(len(w)):
                    w[i] += alpha * alvo * x[i]
                b += alpha * alvo
                erros += 1
        if erros == 0: break   // todos corretos → parou
    return w, b

// Teorema da convergência (Rosenblatt): se os dados forem
// linearmente separáveis, este laço SEMPRE termina.
// Se NÃO forem (ex: XOR), ele nunca para → limitação histórica.

Construindo um classificador linear

Mini projeto: implemente o perceptron em Python para classificar duas classes 2D linearmente separáveis que você gerar. Plote a fronteira de decisão a cada época e conte quantas atualizações foram necessárias até convergir. Teste com classes mais próximas — a convergência fica mais lenta?

Projeto principal: rode seu perceptron no XOR e mostre que ele nunca converge (o número de erros nunca chega a zero). Depois troque o degrau pela função sigmoide e o critério de parada pela minimização do erro via gradiente — você terá uma regressão logística, que dá uma fronteira linear "suave" com probabilidades em vez de ±1.

Desafio extra: implemente um perceptron de margem máxima aproximando a ideia de SVM: em vez de qualquer reta separadora, busque a que fica mais distante dos pontos de ambas as classes. Compare visualmente as fronteiras: a do perceptron simples (qualquer uma que separe) vs. a de margem máxima (a mais "centrada"). Por que a segunda generaliza melhor?

Teste sua intuição

Onde você encontra isso