2. Perceptron

"""Roda os dois exercícios em ordem, com um único gerador aleatório, e salva os números.

Uso, a partir da raiz do repositório:

    python docs/exercises/perceptron/code/run_all.py

As figuras vão para docs/exercises/perceptron/figures/ e os números para code/results.json.
"""

import json

import numpy as np

import ex1_separable
import ex2_overlapping
from common import CODE_DIR, SEED


def main():
    rng = np.random.default_rng(SEED)  # o mesmo gerador em todo o relatório
    results = {
        "exercise1": ex1_separable.run(rng),
        "exercise2": ex2_overlapping.run(rng),
    }
    (CODE_DIR / "results.json").write_text(json.dumps(results, indent=2, ensure_ascii=False) + "\n")
    print(f"Números salvos em {CODE_DIR / 'results.json'}")


if __name__ == "__main__":
    main()

"""Configuração compartilhada pelos dois exercícios: semente, pastas, dados e figuras."""

from pathlib import Path

import matplotlib

matplotlib.use("Agg")  # gera os PNG sem abrir janela
import matplotlib.pyplot as plt  # noqa: E402
import numpy as np  # noqa: E402

from perceptron import predict  # noqa: E402

SEED = 42
CODE_DIR = Path(__file__).resolve().parent
FIGURES = CODE_DIR.parent / "figures"

N_PER_CLASS = 1000
CLASS_COLORS = ["tab:blue", "tab:orange"]


def save(fig, name):
    """Salva a figura em figures/ e libera a memória."""
    FIGURES.mkdir(parents=True, exist_ok=True)
    fig.savefig(FIGURES / name, dpi=150, bbox_inches="tight")
    plt.close(fig)


def generate(rng, means, cov):
    """Amostra 1000 pontos por classe de N(means[k], cov).

    A ordem fica a da geração: 1000 pontos da classe 0 e depois 1000 da classe 1. O perceptron
    visita as amostras nessa ordem em toda época (o enunciado não pede embaralhamento).
    """
    # method="cholesky": a decomposição de Cholesky é única, então o resultado não muda de máquina.
    X = np.vstack([rng.multivariate_normal(m, cov, size=N_PER_CLASS, method="cholesky") for m in means])
    y = np.repeat([0, 1], N_PER_CLASS)
    return X, y


def plot_points(ax, X, y):
    """Desenha os pontos das duas classes, uma cor por classe."""
    for c in (0, 1):
        ax.scatter(*X[y == c].T, s=8, alpha=0.5, color=CLASS_COLORS[c], label=f"Classe {c}")
    ax.set_xlabel("$x_1$")
    ax.set_ylabel("$x_2$")


def scatter_figure(X, y, title, name):
    """Figuras 1 e 4: dispersão dos 2000 pontos, uma cor por classe."""
    fig, ax = plt.subplots(figsize=(7, 6), layout="constrained")
    plot_points(ax, X, y)
    ax.set_aspect("equal", adjustable="datalim")
    ax.set_title(title)
    ax.legend(loc="upper left")
    save(fig, name)


def draw_boundary(ax, w, b, **style):
    """Desenha a reta w·x + b = 0 inteira, sem mudar os limites dos eixos.

    p = -b w / ||w||² é o ponto da reta mais perto da origem; (-w2, w1) é a direção da reta.
    """
    p = -b * w / (w @ w)
    return ax.axline(p, p + np.array([-w[1], w[0]]), **style)


def shade_regions(ax, w, b, xlim, ylim):
    """Pinta de leve a região que o modelo prevê como classe 0 e a que prevê como classe 1."""
    xx, yy = np.meshgrid(np.linspace(*xlim, 400), np.linspace(*ylim, 400))
    regions = predict(np.column_stack([xx.ravel(), yy.ravel()]), w, b).reshape(xx.shape)
    ax.contourf(xx, yy, regions, levels=[-0.5, 0.5, 1.5], colors=CLASS_COLORS, alpha=0.08)


def plot_predictions(ax, X, y, w, b):
    """Desenha os pontos com a cor da classe verdadeira: bolinha se (w, b) acerta, x se erra."""
    wrong = predict(X, w, b) != y
    for c in (0, 1):
        ok, bad = (y == c) & ~wrong, (y == c) & wrong
        ax.scatter(*X[ok].T, s=8, alpha=0.5, color=CLASS_COLORS[c], label=f"Classe {c}, acerto")
        ax.scatter(*X[bad].T, marker="x", s=18, lw=0.9, color=CLASS_COLORS[c],
                   label=f"Classe {c}, erro ({bad.sum()})")
    ax.set_xlabel("$x_1$")
    ax.set_ylabel("$x_2$")


def limits(X, pad=0.8):
    """Limites dos eixos que cobrem todos os pontos, com uma margem."""
    return ((X[:, 0].min() - pad, X[:, 0].max() + pad),
            (X[:, 1].min() - pad, X[:, 1].max() + pad))

"""Exercise 1 — Dados separáveis: o caso para o qual o perceptron foi projetado.

Gera as duas classes, treina o perceptron com eta = 0.01 e com eta = 1.0 (mesmo w inicial)
e confere numericamente o argumento do item D sobre a partida de w = 0.
Produz as Figuras 1, 2 e 3 e uma figura auxiliar do item D.
"""

import matplotlib.pyplot as plt
import numpy as np

from common import (draw_boundary, generate, limits, plot_points, plot_predictions, save,
                    scatter_figure, shade_regions)
from perceptron import init_weights, train

# Parâmetros do enunciado.
MEANS = [[1.5, 1.5], [5.0, 5.0]]
COV = [[0.5, 0.0], [0.0, 0.5]]
ETA = 0.01
ETA_BIG = 1.0


def direction(w):
    """Vetor unitário w / ||w||: a direção normal à fronteira, sem a escala."""
    return w / np.linalg.norm(w)


def angle_deg(u, v):
    """Ângulo, em graus, entre as direções de u e v."""
    cos = np.clip(direction(u) @ direction(v), -1.0, 1.0)
    return float(np.degrees(np.arccos(cos)))


def figure2(X, y, run):
    """Figura 2: a fronteira w·x + b = 0 sobre os pontos, com os mal classificados marcados."""
    fig, ax = plt.subplots(figsize=(7, 6), layout="constrained")
    xlim, ylim = limits(X)
    shade_regions(ax, run["w"], run["b"], xlim, ylim)
    plot_predictions(ax, X, y, run["w"], run["b"])
    draw_boundary(ax, run["w"], run["b"], color="black", lw=1.8, label="Fronteira $w \\cdot x + b = 0$")
    ax.set_xlim(xlim)
    ax.set_ylim(ylim)
    ax.set_aspect("equal")
    ax.set_title(f"Figura 2 — Fronteira de decisão ($\\eta$ = {ETA}), acurácia = {100 * run['accuracy']:.2f}%")
    ax.legend(loc="upper left")
    save(fig, "fig2_boundary.png")


def figure3(run):
    """Figura 3: acurácia × época. As barras cinzas mostram as atualizações feitas em cada época."""
    hist = run["history"]
    epochs = np.arange(1, run["epochs"] + 1)
    fig, ax = plt.subplots(figsize=(8.5, 4.8), layout="constrained")

    ax2 = ax.twinx()  # eixo da direita: número de atualizações
    ax2.bar(epochs, hist["updates"], color="gray", alpha=0.35, label="Atualizações na época")
    ax2.set_ylabel("Atualizações na época")
    ax2.set_ylim(0, max(hist["updates"]) * 2.5)  # barras baixas, para não cobrir a curva

    ax.plot(epochs, [100 * a for a in hist["accuracy"]], "o-", color="tab:purple", lw=2,
            label="Acurácia no dataset completo")
    ax.set_zorder(ax2.get_zorder() + 1)  # curva na frente das barras
    ax.patch.set_visible(False)
    ax.set_xlabel("Época")
    ax.set_ylabel("Acurácia (%)")
    ax.set_xticks(epochs[::2] if len(epochs) > 15 else epochs)
    h1, l1 = ax.get_legend_handles_labels()
    h2, l2 = ax2.get_legend_handles_labels()
    ax.legend(h1 + h2, l1 + l2, loc="lower right")
    ax.set_title(f"Figura 3 — Acurácia × época ($\\eta$ = {ETA})")
    save(fig, "fig3_accuracy.png")


def figure_eta(X, y, small, big):
    """Figura auxiliar do item D: as fronteiras de eta = 0.01 e eta = 1.0, com zoom no vão entre as nuvens."""
    fig, ax = plt.subplots(figsize=(7, 6), layout="constrained")
    plot_points(ax, X, y)
    draw_boundary(ax, small["w"], small["b"], color="black", lw=1.8, label=f"$\\eta$ = {ETA}")
    draw_boundary(ax, big["w"], big["b"], color="crimson", lw=1.8, ls="--", label=f"$\\eta$ = {ETA_BIG}")
    ax.set_xlim(1.0, 5.5)
    ax.set_ylim(1.0, 5.5)
    ax.set_aspect("equal")
    ax.set_title("Figura auxiliar (item D) — Fronteiras com $\\eta$ = 0.01 e $\\eta$ = 1.0 (zoom)")
    ax.legend(loc="upper left")
    save(fig, "fig_d_eta.png")


def summary(run):
    """Números de uma execução, prontos para o results.json."""
    return {
        "w": run["w"].tolist(),
        "b": run["b"],
        "direction": direction(run["w"]).tolist(),
        "offset": float(-run["b"] / np.linalg.norm(run["w"])),  # distância da reta até a origem
        "epochs": run["epochs"],
        "converged": run["converged"],
        "total_updates": run["total_updates"],
        "accuracy": run["accuracy"],
        "updates_per_epoch": run["history"]["updates"],
        "accuracy_per_epoch": run["history"]["accuracy"],
    }


def run(rng):
    # A — gera os dados e desenha a Figura 1.
    X, y = generate(rng, MEANS, COV)
    scatter_figure(X, y, "Figura 1 — Dados separáveis: 1000 pontos por classe", "fig1_data.png")

    # B/C — um único sorteio de w inicial, reutilizado pelas duas taxas de aprendizado.
    w0, b0 = init_weights(rng)
    small = train(X, y, w0, b0, ETA)
    figure2(X, y, small)
    figure3(small)

    # D — mesma execução, só com eta = 1.0: mesmos dados, mesma ordem, mesmo w0.
    big = train(X, y, w0, b0, ETA_BIG)
    figure_eta(X, y, small, big)

    # D — partida do zero: o argumento algébrico diz que w e b escalam com eta2 / eta1.
    zero_small = train(X, y, np.zeros(2), 0.0, ETA)
    zero_big = train(X, y, np.zeros(2), 0.0, ETA_BIG)
    ratio = ETA_BIG / ETA

    print("Exercise 1")
    for name, r in [("eta = 0.01", small), ("eta = 1.0", big)]:
        print(f"  {name}: w = {r['w']}, b = {r['b']:.4f}, épocas = {r['epochs']}, "
              f"acurácia = {100 * r['accuracy']:.2f}%")

    return {
        "w0": w0.tolist(),
        "b0": b0,
        "eta_small": summary(small),
        "eta_big": summary(big),
        "angle_between_directions_deg": angle_deg(small["w"], big["w"]),
        "zero_start": {
            "eta_small": summary(zero_small),
            "eta_big": summary(zero_big),
            "expected_ratio": ratio,
            # Quanto os pesos de eta = 1.0 diferem de (eta2/eta1) × pesos de eta = 0.01.
            "max_abs_diff_w": float(np.abs(zero_big["w"] - ratio * zero_small["w"]).max()),
            "abs_diff_b": abs(zero_big["b"] - ratio * zero_small["b"]),
            "same_epochs": zero_small["epochs"] == zero_big["epochs"],
            "angle_deg": angle_deg(zero_small["w"], zero_big["w"]),
        },
    }

"""Exercise 2 — Dados sobrepostos: o caso que o perceptron não resolve.

Treina o mesmo perceptron do Exercise 1 (mesma função train, eta = 0.01, 100 épocas), agora com
o rastreio do pocket ligado. Produz as Figuras 4, 5 e 6. Depois roda as verificações do item D:
onde a fronteira final fica, mais épocas, eta menor e a ordem das amostras.
"""

import matplotlib.pyplot as plt
import numpy as np

from common import (draw_boundary, generate, limits, plot_predictions, save, scatter_figure,
                    shade_regions)
from perceptron import accuracy, init_weights, predict, train

# Parâmetros do enunciado.
MEANS = [[3.0, 3.0], [4.0, 4.0]]
COV = [[1.5, 0.0], [0.0, 1.5]]
ETA = 0.01
MAX_EPOCHS = 100

# Reta de referência: a mediatriz entre as médias, x1 + x2 = 7. Com covariâncias iguais e
# isotrópicas, é a melhor reta para as distribuições do enunciado.
W_REF, B_REF = np.array([1.0, 1.0]), -7.0
CENTER = np.mean(MEANS, axis=0)  # centro da nuvem inteira: (3.5, 3.5)


def position(w, b, X):
    """Onde a reta w·x + b = 0 fica em relação à nuvem de pontos."""
    norm = np.linalg.norm(w)
    return {
        "offset": float(-b / norm),                    # distância da reta até a origem (com sinal)
        "center_distance": float((w @ CENTER + b) / norm),  # > 0: centro da nuvem no lado "classe 1"
        "predicted_1": float(predict(X, w, b).mean()),  # fração de pontos que o modelo chama de 1
        "b_over_norm_w": float(b / norm),
    }


def figure5(X, y, final, pocket):
    """Figura 5: as fronteiras final e pocket, um painel para os erros de cada uma."""
    xlim, ylim = limits(X)
    fig, axes = plt.subplots(1, 2, figsize=(13, 6.2), sharex=True, sharey=True, layout="constrained")
    panels = [(axes[0], final, "Pesos finais"), (axes[1], pocket, "Pesos do pocket")]
    for ax, (w, b, acc), title in panels:
        shade_regions(ax, w, b, xlim, ylim)
        plot_predictions(ax, X, y, w, b)
        draw_boundary(ax, final[0], final[1], color="crimson", lw=2.0, label="Fronteira final")
        draw_boundary(ax, pocket[0], pocket[1], color="black", lw=2.0, ls="--", label="Fronteira do pocket")
        ax.set_xlim(xlim)
        ax.set_ylim(ylim)
        ax.set_aspect("equal")
        ax.set_title(f"{title}: acurácia = {100 * acc:.2f}%")
        ax.legend(loc="upper center", bbox_to_anchor=(0.5, -0.1), ncol=3, fontsize=9)
    fig.suptitle("Figura 5 — Fronteiras de decisão final e do pocket")
    save(fig, "fig5_boundaries.png")


def figure6(run):
    """Figura 6: acurácia dos pesos atuais e melhor acurácia até agora (pocket), por época."""
    hist = run["history"]
    epochs = np.arange(1, run["epochs"] + 1)
    fig, ax = plt.subplots(figsize=(9, 4.8), layout="constrained")
    ax.plot(epochs, [100 * a for a in hist["accuracy"]], color="crimson", lw=1.4,
            label="Pesos atuais (fim de cada época)")
    ax.plot(epochs, [100 * a for a in hist["pocket_accuracy"]], color="black", lw=2, ls="--",
            label="Melhor até agora (pocket)")
    ax.axhline(50, color="gray", lw=0.8, ls=":", label="50% (chute)")
    ax.set_ylim(40, 80)
    ax.set_xlabel("Época")
    ax.set_ylabel("Acurácia (%)")
    ax.legend(loc="center right")
    ax.set_title(f"Figura 6 — Acurácia × época ($\\eta$ = {ETA}, dados sobrepostos)")
    save(fig, "fig6_accuracy.png")


def run(rng):
    # A — gera os dados e desenha a Figura 4.
    X, y = generate(rng, MEANS, COV)
    scatter_figure(X, y, "Figura 4 — Dados sobrepostos: 1000 pontos por classe", "fig4_data.png")

    # B — a mesma função do Exercise 1; pocket=True liga a cópia do melhor (w, b).
    w0, b0 = init_weights(rng)
    main = train(X, y, w0, b0, ETA, max_epochs=MAX_EPOCHS, pocket=True)
    best = main["pocket"]

    # C — figuras.
    figure5(X, y, (main["w"], main["b"], main["accuracy"]), (best["w"], best["b"], best["accuracy"]))
    figure6(main)

    # D — o que acontece dentro da última época: treina 99 épocas e depois só a metade da
    # classe 0 da época 100. A ordem das amostras é a mesma, então as atualizações são as mesmas.
    first_99 = train(X, y, w0, b0, ETA, max_epochs=MAX_EPOCHS - 1)
    half = train(X[y == 0], y[y == 0], first_99["w"], first_99["b"], ETA, max_epochs=1)

    # D — mais épocas e eta menor, sem pocket (só interessa o que o laço deixa na mão).
    long = train(X, y, w0, b0, ETA, max_epochs=5 * MAX_EPOCHS)
    small_eta = train(X, y, w0, b0, ETA / 10, max_epochs=MAX_EPOCHS)

    # D — a mesma execução com a ordem das amostras embaralhada uma vez. É o último sorteio do
    # relatório, para não mudar nenhum número acima.
    order = rng.permutation(len(y))
    shuffled = train(X[order], y[order], w0, b0, ETA, max_epochs=MAX_EPOCHS, pocket=True)

    print("Exercise 2")
    print(f"  final: w = {main['w']}, b = {main['b']:.4f}, acurácia = {100 * main['accuracy']:.2f}%")
    print(f"  pocket: w = {best['w']}, b = {best['b']:.4f}, acurácia = {100 * best['accuracy']:.2f}% "
          f"(época {best['epoch']})")

    tail = np.array(long["history"]["accuracy"][-MAX_EPOCHS:])
    return {
        "w0": w0.tolist(),
        "b0": b0,
        "final": {"w": main["w"].tolist(), "b": main["b"], "accuracy": main["accuracy"],
                  **position(main["w"], main["b"], X)},
        "pocket": {"w": best["w"].tolist(), "b": best["b"], "accuracy": best["accuracy"],
                   "epoch": best["epoch"], "update": best["update"],
                   **position(best["w"], best["b"], X)},
        "reference_line": {"w": W_REF.tolist(), "b": B_REF, "accuracy": accuracy(X, y, W_REF, B_REF),
                           **position(W_REF, B_REF, X)},
        "epochs": main["epochs"],
        "converged": main["converged"],
        "total_updates": main["total_updates"],
        "updates_per_epoch": main["history"]["updates"],
        "min_updates_per_epoch": min(main["history"]["updates"]),
        "accuracy_per_epoch": main["history"]["accuracy"],
        "accuracy_range": [min(main["history"]["accuracy"]), max(main["history"]["accuracy"])],
        "mean_norm_x": float(np.linalg.norm(X, axis=1).mean()),
        "mid_last_epoch": {"accuracy": accuracy(X, y, half["w"], half["b"]),
                           **position(half["w"], half["b"], X)},
        "more_epochs": {"epochs": long["epochs"], "accuracy": long["accuracy"],
                        "last_100_range": [float(tail.min()), float(tail.max())],
                        "updates_last_epoch": long["history"]["updates"][-1],
                        **position(long["w"], long["b"], X)},
        "smaller_eta": {"eta": ETA / 10, "accuracy": small_eta["accuracy"],
                        "accuracy_range": [min(small_eta["history"]["accuracy"]),
                                           max(small_eta["history"]["accuracy"])],
                        **position(small_eta["w"], small_eta["b"], X)},
        "shuffled_order": {"accuracy": shuffled["accuracy"],
                           "pocket_accuracy": shuffled["pocket"]["accuracy"],
                           "accuracy_range": [min(shuffled["history"]["accuracy"]),
                                              max(shuffled["history"]["accuracy"])],
                           **position(shuffled["w"], shuffled["b"], X)},
    }