"""Experimento para el artículo «qué es deep learning» (13-11-2026).
Dos espirales entrelazadas: ¿qué consigue un modelo sin capas ocultas frente a redes con 1 y 3 capas?
Control: una sola capa de 560 neuronas, con los mismos parámetros (2.241) que la red de tres capas.
Y dígitos escritos a mano (sklearn load_digits): cuánto importa la cantidad de ejemplos.
"""
import json, time, sys
import numpy as np
from sklearn.linear_model import LogisticRegression
from sklearn.neural_network import MLPClassifier
from sklearn.model_selection import train_test_split
from sklearn.datasets import load_digits
from sklearn.preprocessing import StandardScaler

rng = np.random.default_rng(42)

def espirales(n=500, ruido=0.25):
    t = np.sqrt(rng.random(n)) * 3 * np.pi  # 1,5 vueltas
    a = np.c_[t * np.cos(t), t * np.sin(t)] + rng.normal(0, ruido, (n, 2))
    b = np.c_[-t * np.cos(t), -t * np.sin(t)] + rng.normal(0, ruido, (n, 2))
    X = np.r_[a, b] / 10.0
    y = np.r_[np.zeros(n), np.ones(n)].astype(int)
    return X, y

X, y = espirales()
Xtr, Xte, ytr, yte = train_test_split(X, y, test_size=0.3, random_state=0, stratify=y)

modelos = {
    "sin_capas": LogisticRegression(max_iter=2000),
    "una_capa_8": MLPClassifier(hidden_layer_sizes=(8,), max_iter=5000, random_state=0),
    "tres_capas_32": MLPClassifier(hidden_layer_sizes=(32, 32, 32), max_iter=5000, random_state=0),
    "una_capa_560": MLPClassifier(hidden_layer_sizes=(560,), max_iter=5000, random_state=0),
}
res = {"espirales": {"n_total": len(X), "n_train": len(Xtr), "n_test": len(Xte)}}
for nombre, m in modelos.items():
    t0 = time.perf_counter(); m.fit(Xtr, ytr); dt = time.perf_counter() - t0
    acc = m.score(Xte, yte)
    nparams = (m.coef_.size + m.intercept_.size) if hasattr(m, "coef_") and not hasattr(m, "coefs_") else sum(w.size for w in m.coefs_) + sum(b.size for b in m.intercepts_)
    res["espirales"][nombre] = {"acierto_test": round(acc * 100, 1), "segundos": round(dt, 2), "parametros": int(nparams),
                                "pasadas": int(getattr(m, "n_iter_", 0)) if not hasattr(m, "coef_") or hasattr(m, "coefs_") else None}

# Las redes, repetidas con otras dos semillas (inicio aleatorio distinto) para ver si el resultado aguanta
res["espirales"]["otras_semillas"] = {}
for hl in [(8,), (32, 32, 32), (560,)]:
    for s in (1, 2):
        m = MLPClassifier(hidden_layer_sizes=hl, max_iter=5000, random_state=s)
        t0 = time.perf_counter(); m.fit(Xtr, ytr); dt = time.perf_counter() - t0
        res["espirales"]["otras_semillas"][f"{hl}_semilla{s}"] = {"acierto_test": round(m.score(Xte, yte) * 100, 1),
                                                                  "segundos": round(dt, 2), "pasadas": int(m.n_iter_)}

# Imágenes de la frontera de decisión
from PIL import Image, ImageDraw
def pintar(m, ruta, titulo=None, W=960, H=600):
    img = Image.new("RGB", (W, H), (250, 248, 245))
    d = ImageDraw.Draw(img)
    xs = np.linspace(-1.1, 1.1, 240); ys = np.linspace(-1.1, 1.1, 240)
    gx, gy = np.meshgrid(xs, ys)
    p = m.predict_proba(np.c_[gx.ravel(), gy.ravel()])[:, 1].reshape(gx.shape)
    # panel cuadrado centrado
    S = H - 40; ox = (W - S) // 2; oy = 20
    cA = np.array([204, 120, 92]); cB = np.array([61, 58, 53]); fondo = np.array([250, 248, 245])
    cell = S / 240
    for i in range(240):
        for j in range(240):
            v = p[i, j]
            c = fondo + (cB - fondo) * 0.28 if v >= 0.5 else fondo + (cA - fondo) * 0.28
            x0 = ox + j * cell; y0 = oy + (239 - i) * cell
            d.rectangle([x0, y0, x0 + cell + 1, y0 + cell + 1], fill=tuple(int(k) for k in c))
    def px(pt):
        return ox + (pt[0] + 1.1) / 2.2 * S, oy + (1.1 - pt[1]) / 2.2 * S
    for pt, lab in zip(Xte, yte):
        cx, cy = px(pt); r = 4
        col = tuple(cB) if lab == 1 else tuple(cA)
        d.ellipse([cx - r, cy - r, cx + r, cy + r], fill=tuple(int(k) for k in col), outline=(255, 255, 255))
    img.save(ruta, "WEBP", quality=82)
    img.resize((320, 200)).save(ruta.replace(".webp", "-s.webp"), "WEBP", quality=80)

dest = sys.argv[1] if len(sys.argv) > 1 else "."
for nombre, m in modelos.items():
    pintar(m, f"{dest}/espiral-{nombre.replace('_', '-')}.webp")

# Dígitos: cuántos ejemplos hacen falta
dg = load_digits()
Xd = StandardScaler().fit_transform(dg.data); yd = dg.target
Xdtr, Xdte, ydtr, ydte = train_test_split(Xd, yd, test_size=0.3, random_state=0, stratify=yd)
res["digitos"] = {"n_total": len(Xd), "n_test": len(Xdte), "por_tamano": {}}
for n in [50, 200, len(Xdtr)]:
    fila = {}
    for nombre, m in {"sin_capas": LogisticRegression(max_iter=5000),
                      "tres_capas_64": MLPClassifier(hidden_layer_sizes=(64, 64, 64), max_iter=5000, random_state=0)}.items():
        m.fit(Xdtr[:n], ydtr[:n]); fila[nombre] = round(m.score(Xdte, ydte) * 100, 1)
    res["digitos"]["por_tamano"][n] = fila
print(json.dumps(res, indent=1, ensure_ascii=False))
json.dump(res, open(f"resultados.json", "w"), indent=1, ensure_ascii=False)
