Exercise 2 — Perceptron

"""Exercise 1 — dados linearmente separáveis.

Gera figures/fig1.png, fig2.png, fig3.png e imprime os números do relatório.
Roda de qualquer diretório: python ex1_separable.py
"""
from pathlib import Path

import numpy as np
import matplotlib
matplotlib.use("Agg")
import matplotlib.pyplot as plt

from perceptron import (ETA, train_perceptron, predict, make_dataset, plot_data,
                        plot_boundary_panel, unit)

rng = np.random.default_rng(42)
FIG = Path(__file__).resolve().parent.parent / "figures"
FIG.mkdir(exist_ok=True)

# ---------------------------------------------------------------- A — dados
mean0, mean1 = np.array([1.5, 1.5]), np.array([5.0, 5.0])
cov = np.array([[0.5, 0.0], [0.0, 0.5]])
X, y = make_dataset(rng, mean0, mean1, cov)

fig = plot_data(X, y, [mean0, mean1], "Figure 1 — Exercise 1: dados separáveis (1000 por classe)")
fig.savefig(FIG / "fig1.png", bbox_inches="tight"); plt.close(fig)
print("A) médias amostrais:", X[y == 0].mean(0).round(3), X[y == 1].mean(0).round(3))

# ---------------------------------------------------------------- C — treino (η = 0.01)
w0 = rng.normal(0.0, 0.01, size=2)          # inicialização do enunciado; b = 0
res = train_perceptron(X, y, eta=ETA, w0=w0)

print(f"C) w0 = {w0}")
print(f"   w = [{res['w'][0]:.5f}, {res['w'][1]:.5f}], b = {res['b']:.5f}")
print(f"   épocas = {res['epochs']} (convergiu: {res['converged']}), acurácia = {res['acc']:.4f}")
print(f"   atualizações por época: {res['updates_hist'].tolist()}")

fig, ax = plt.subplots(figsize=(6, 5.5))
plot_boundary_panel(ax, X, y, res["w"], res["b"],
                    "Figure 2 — Exercise 1: fronteira de decisão final (η = 0.01)",
                    "fronteira $w\\cdot x + b = 0$")
ax.set_aspect("equal")
fig.savefig(FIG / "fig2.png", bbox_inches="tight"); plt.close(fig)

epochs = np.arange(1, res["epochs"] + 1)
fig, ax = plt.subplots(figsize=(6.5, 4))
ax.plot(epochs, res["acc_hist"], "o-", label="acurácia no fim da época")
ax.set_xticks(epochs); ax.set_ylim(0.45, 1.02)
ax.set_xlabel("época"); ax.set_ylabel("acurácia (dataset inteiro)")
ax.set_title("Figure 3 — Exercise 1: acurácia por época (η = 0.01)")
ax.legend()
fig.savefig(FIG / "fig3.png", bbox_inches="tight"); plt.close(fig)

# ---------------------------------------------------------------- D — η = 1.0, mesmo w0 e mesma ordem
res1 = train_perceptron(X, y, eta=1.0, w0=w0)
cos_dir = float(unit(res["w"]) @ unit(res1["w"]))
print(f"D) η = 1.0: épocas = {res1['epochs']}, acurácia = {res1['acc']:.4f}, "
      f"w = {res1['w'].round(4)}, b = {res1['b']:.4f}, atualizações {res1['updates_hist'].tolist()}")
print(f"   w/||w||: η=0.01 {unit(res['w']).round(4)} | η=1.0 {unit(res1['w']).round(4)}")
print(f"   cosseno = {cos_dir:.4f}, ângulo = {np.degrees(np.arccos(np.clip(cos_dir, -1, 1))):.2f}°")
print(f"   ||w0|| = {np.linalg.norm(w0):.4f}; ||w|| final: "
      f"{np.linalg.norm(res['w']):.4f} (η=0.01) vs {np.linalg.norm(res1['w']):.4f} (η=1.0)")

# ---------------------------------------------------------------- D — partindo de w = 0, b = 0
z1 = train_perceptron(X, y, eta=0.01, w0=np.zeros(2))
z2 = train_perceptron(X, y, eta=1.0, w0=np.zeros(2))
print(f"D) w0 = 0: η=0.01 -> w = {z1['w']}, b = {z1['b']:.4f}, épocas = {z1['epochs']}")
print(f"           η=1.00 -> w = {z2['w']}, b = {z2['b']:.4f}, épocas = {z2['epochs']}")
print(f"   razão w = {z2['w'] / z1['w']}, razão b = {z2['b'] / z1['b']:.6f}")
print("   previsões idênticas:",
      bool(np.all(predict(X, z1["w"], z1["b"]) == predict(X, z2["w"], z2["b"]))),
      "| atualizações:", z1["updates_hist"].tolist(), z2["updates_hist"].tolist())

"""Perceptron escrito do zero (NumPy) + geração de dados e figuras.

Usado por ex1_separable.py e ex2_overlapping.py. O modelo (degrau, previsão,
regra de atualização e laço de treino com pocket) está todo aqui; nada vem de
bibliotecas de ML.
"""
import numpy as np
import matplotlib.pyplot as plt

N_PER_CLASS = 1000
MAX_EPOCHS = 100
ETA = 0.01

plt.rcParams.update({"figure.dpi": 110, "axes.grid": True, "grid.alpha": 0.3})
COLORS = {0: "tab:blue", 1: "tab:orange"}


# ---------------------------------------------------------------- modelo

def step(z):
    """Função degrau: 1 se z >= 0, senão 0."""
    return np.where(z >= 0, 1, 0)


def predict(X, w, b):
    """Previsão do perceptron: degrau aplicado a w·x + b (X pode ser uma amostra ou uma matriz)."""
    return step(X @ w + b)


def accuracy(X, y, w, b):
    """Fração de acertos no dataset inteiro."""
    return float(np.mean(predict(X, w, b) == y))


def train_perceptron(X, y, eta, w0, b0=0.0, max_epochs=MAX_EPOCHS):
    """Regra de aprendizado do perceptron, amostra a amostra.

    Para cada amostra (x_i, y_i), na ordem fixa do dataset:
        y_hat = step(w·x_i + b)
        w <- w + eta * (y_i - y_hat) * x_i
        b <- b + eta * (y_i - y_hat)
    Só há atualização quando y_hat != y_i. O treino para quando uma época inteira
    passa sem nenhuma atualização (convergiu) ou ao atingir max_epochs.

    Além dos pesos correntes, guarda o "pocket": toda vez que uma atualização
    produz acurácia no dataset inteiro maior do que qualquer outra já vista,
    copia (w, b) para o bolso. O pocket não interfere no treino.
    """
    w = np.asarray(w0, dtype=float).copy()
    b = float(b0)

    pocket_w, pocket_b = w.copy(), b
    pocket_acc = accuracy(X, y, w, b)
    pocket_epoch = 0                       # 0 = pesos iniciais, antes de qualquer época

    acc_hist, pocket_hist, updates_hist = [], [], []
    converged = False

    for epoch in range(1, max_epochs + 1):
        n_updates = 0
        for x_i, y_i in zip(X, y):
            y_hat = 1 if x_i @ w + b >= 0 else 0
            error = y_i - y_hat            # +1, 0 ou -1
            if error != 0:
                w = w + eta * error * x_i
                b = b + eta * error
                n_updates += 1

                # Pocket: avalia no dataset inteiro depois de cada atualização
                acc_now = accuracy(X, y, w, b)
                if acc_now > pocket_acc:
                    pocket_w, pocket_b = w.copy(), b
                    pocket_acc, pocket_epoch = acc_now, epoch

        acc_hist.append(accuracy(X, y, w, b))   # acurácia no fim da época
        pocket_hist.append(pocket_acc)
        updates_hist.append(n_updates)

        if n_updates == 0:
            converged = True
            break

    return {
        "w": w, "b": b, "epochs": epoch, "converged": converged,
        "acc": acc_hist[-1], "acc_hist": np.array(acc_hist),
        "updates_hist": np.array(updates_hist),
        "pocket_w": pocket_w, "pocket_b": pocket_b,
        "pocket_acc": pocket_acc, "pocket_epoch": pocket_epoch,
        "pocket_hist": np.array(pocket_hist),
    }


# ---------------------------------------------------------------- dados

def make_dataset(rng, mean0, mean1, cov, n=N_PER_CLASS):
    """Sorteia as duas classes e embaralha a ordem uma única vez.

    O embaralhamento importa: sem ele o perceptron veria 1000 amostras da
    classe 0 seguidas de 1000 da classe 1. A ordem fica fixa durante o treino.
    """
    X0 = rng.multivariate_normal(mean0, cov, size=n)
    X1 = rng.multivariate_normal(mean1, cov, size=n)
    X = np.vstack([X0, X1])
    y = np.concatenate([np.zeros(n, dtype=int), np.ones(n, dtype=int)])
    order = rng.permutation(len(y))
    return X[order], y[order]


# ---------------------------------------------------------------- figuras

def scatter_classes(ax, X, y, alpha=0.5):
    for c in (0, 1):
        ax.scatter(*X[y == c].T, s=10, alpha=alpha, color=COLORS[c], label=f"classe {c}")


def draw_boundary(ax, w, b, X, **kw):
    """Desenha a reta w1*x1 + w2*x2 + b = 0 dentro dos limites dos dados."""
    x1 = np.linspace(X[:, 0].min() - 0.5, X[:, 0].max() + 0.5, 200)
    if abs(w[1]) > 1e-12:
        ax.plot(x1, -(w[0] * x1 + b) / w[1], **kw)
    else:                                   # reta vertical
        ax.axvline(-b / w[0], **kw)


def plot_boundary_panel(ax, X, y, w, b, title, line_label, line_color="k"):
    """Dados + fronteira + pontos mal classificados (círculo vermelho)."""
    scatter_classes(ax, X, y, alpha=0.35)
    wrong = predict(X, w, b) != y
    ax.scatter(*X[wrong].T, s=28, facecolors="none", edgecolors="red", linewidths=0.9,
               label=f"mal classificados ({wrong.sum()})")
    draw_boundary(ax, w, b, X, color=line_color, lw=2, label=line_label)
    ax.set_xlim(X[:, 0].min() - 0.5, X[:, 0].max() + 0.5)
    ax.set_ylim(X[:, 1].min() - 0.5, X[:, 1].max() + 0.5)
    ax.set_xlabel("$x_1$"); ax.set_ylabel("$x_2$"); ax.set_title(title)
    ax.legend(loc="upper left", fontsize=8)


def plot_data(X, y, means, title):
    fig, ax = plt.subplots(figsize=(6, 5.5))
    scatter_classes(ax, X, y, alpha=0.45)
    ax.scatter(*np.vstack(means).T, marker="X", s=150, color="k", label="médias")
    ax.set_xlabel("$x_1$"); ax.set_ylabel("$x_2$"); ax.set_title(title)
    ax.legend(); ax.set_aspect("equal")
    return fig


def unit(v):
    return v / np.linalg.norm(v)

"""Exercise 2 — dados sobrepostos, perceptron + pocket.

Gera figures/fig4.png, fig5.png, fig6.png e imprime os números do relatório.
Roda de qualquer diretório: python ex2_overlapping.py
"""
from math import erf, sqrt
from pathlib import Path

import numpy as np
import pandas as pd
import matplotlib
matplotlib.use("Agg")
import matplotlib.pyplot as plt

from perceptron import (ETA, train_perceptron, predict, accuracy, make_dataset, plot_data,
                        plot_boundary_panel, draw_boundary)

rng = np.random.default_rng(42)
FIG = Path(__file__).resolve().parent.parent / "figures"
FIG.mkdir(exist_ok=True)

# ---------------------------------------------------------------- A — dados
mean0, mean1 = np.array([3.0, 3.0]), np.array([4.0, 4.0])
cov = np.array([[1.5, 0.0], [0.0, 1.5]])
X, y = make_dataset(rng, mean0, mean1, cov)

fig = plot_data(X, y, [mean0, mean1], "Figure 4 — Exercise 2: dados sobrepostos (1000 por classe)")
fig.savefig(FIG / "fig4.png", bbox_inches="tight"); plt.close(fig)

# ---------------------------------------------------------------- B — treino com pocket (mesma função do Ex. 1)
w0 = rng.normal(0.0, 0.01, size=2)
res = train_perceptron(X, y, eta=ETA, w0=w0)

print(f"B) épocas = {res['epochs']} (convergiu: {res['converged']})")
print(f"   FINAL : w = [{res['w'][0]:.5f}, {res['w'][1]:.5f}], b = {res['b']:.5f}, acurácia = {res['acc']:.4f}")
print(f"   POCKET: w = [{res['pocket_w'][0]:.5f}, {res['pocket_w'][1]:.5f}], b = {res['pocket_b']:.5f}, "
      f"acurácia = {res['pocket_acc']:.4f}, época {res['pocket_epoch']}")
u = res["updates_hist"]
print(f"   atualizações por época: média {u.mean():.0f}, mín {u.min()}, máx {u.max()}")
h = res["acc_hist"]
print(f"   acurácia corrente nas 100 épocas: mín {h.min():.4f}, máx {h.max():.4f}, média {h.mean():.4f}")
print(f"   pocket ao fim da época 1: {res['pocket_hist'][0]:.4f}")

# ---------------------------------------------------------------- C — figuras
fig, axes = plt.subplots(1, 2, figsize=(12, 5.5), sharex=True, sharey=True)
plot_boundary_panel(axes[0], X, y, res["w"], res["b"],
                    f"Final (época {res['epochs']}): acurácia {res['acc']:.1%}",
                    "fronteira final", line_color="k")
draw_boundary(axes[0], res["pocket_w"], res["pocket_b"], X, color="green", lw=1.5, ls="--",
              label="fronteira pocket (ref.)")
axes[0].legend(loc="upper left", fontsize=8)
plot_boundary_panel(axes[1], X, y, res["pocket_w"], res["pocket_b"],
                    f"Pocket (época {res['pocket_epoch']}): acurácia {res['pocket_acc']:.1%}",
                    "fronteira pocket", line_color="green")
draw_boundary(axes[1], res["w"], res["b"], X, color="k", lw=1.5, ls="--",
              label="fronteira final (ref.)")
axes[1].legend(loc="upper left", fontsize=8)
fig.suptitle("Figure 5 — Exercise 2: fronteiras final e pocket "
             "(vermelho = mal classificado pela fronteira do painel)")
fig.tight_layout()
fig.savefig(FIG / "fig5.png", bbox_inches="tight"); plt.close(fig)

epochs = np.arange(1, res["epochs"] + 1)
fig, ax = plt.subplots(figsize=(9, 4.5))
ax.plot(epochs, res["acc_hist"], lw=1.2, label="acurácia corrente (fim da época)")
ax.plot(epochs, res["pocket_hist"], lw=2, color="green", label="acurácia do pocket")
ax.axhline(0.5, color="gray", ls=":", lw=1, label="chute (50%)")
ax.set_ylim(0.4, 0.8)
ax.set_xlabel("época"); ax.set_ylabel("acurácia (dataset inteiro)")
ax.set_title("Figure 6 — Exercise 2: acurácia corrente vs. pocket (η = 0.01)")
ax.legend(loc="lower right")
fig.savefig(FIG / "fig6.png", bbox_inches="tight"); plt.close(fig)

# ---------------------------------------------------------------- D — onde estão as fronteiras
midpoint = (mean0 + mean1) / 2
for name, w, b in [("final", res["w"], res["b"]), ("pocket", res["pocket_w"], res["pocket_b"])]:
    p1 = predict(X, w, b).mean()
    dist = (midpoint @ w + b) / np.linalg.norm(w)
    ang = np.degrees(np.arctan2(w[1], w[0]))
    print(f"D) {name:>6}: prevê classe 1 em {p1:.1%} | ângulo de w = {ang:.1f}° "
          f"| distância com sinal de (3.5, 3.5) à reta = {dist:+.3f}")

# Teto teórico de uma reta: covariâncias iguais e isotrópicas -> mediatriz, erro Φ(−‖Δμ‖/2σ)
z = np.linalg.norm(mean1 - mean0) / (2 * sqrt(cov[0, 0]))
print(f"D) melhor reta teórica: Φ({z:.4f}) = {0.5 * (1 + erf(z / sqrt(2))):.4f}; "
      f"reta de Bayes (w=[1,1], b=-7) nesta amostra: {accuracy(X, y, np.array([1.0, 1.0]), -7.0):.4f}")

# ---------------------------------------------------------------- D — mais épocas ou η menor?
rows = []
for eta in (1.0, 0.01, 0.001):
    r = train_perceptron(X, y, eta=eta, w0=w0, max_epochs=500)
    tail = r["acc_hist"][-100:]
    rows.append({"eta": eta, "épocas": r["epochs"], "convergiu": r["converged"],
                 "acc final": r["acc"], "acc últ.100 mín": tail.min(), "acc últ.100 máx": tail.max(),
                 "pocket": r["pocket_acc"], "época pocket": r["pocket_epoch"],
                 "atualiz./época": r["updates_hist"].mean()})
print("D) 500 épocas, mesmo w0:")
print(pd.DataFrame(rows).round(4).to_string(index=False))