"""
Tarea T1: entrenar un MLP en MNIST y medir el efecto de cuantizar sus pesos.

Uso (con el entorno activado):
    python t1_mnist_cuantizacion.py

Completa los TODO de quantize_tensor() antes de ejecutar la parte 2.
"""
import copy

import matplotlib.pyplot as plt
import torch
import torch.nn as nn
import torch.nn.functional as F
from torchvision import datasets, transforms

device = "mps" if torch.backends.mps.is_available() else "cpu"
torch.manual_seed(0)
print("Dispositivo:", device)

# ---------------------------------------------------------------- datos
tf = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.1307,), (0.3081,)),
])
train_ds = datasets.MNIST("data", train=True, download=True, transform=tf)
test_ds = datasets.MNIST("data", train=False, download=True, transform=tf)
train_dl = torch.utils.data.DataLoader(train_ds, batch_size=128, shuffle=True)
test_dl = torch.utils.data.DataLoader(test_ds, batch_size=1000)


# --------------------------------------------------------------- modelo
class MLP(nn.Module):
    def __init__(self):
        super().__init__()
        self.net = nn.Sequential(
            nn.Flatten(),
            nn.Linear(784, 64), nn.ReLU(),
            nn.Linear(64, 64), nn.ReLU(),
            nn.Linear(64, 10),
        )

    def forward(self, x):
        return self.net(x)


def evaluate(model):
    model.eval()
    correct = 0
    with torch.no_grad():
        for x, y in test_dl:
            x, y = x.to(device), y.to(device)
            correct += (model(x).argmax(dim=1) == y).sum().item()
    return correct / len(test_ds)


def train_model(model, epochs=5):
    opt = torch.optim.Adam(model.parameters(), lr=1e-3)
    for ep in range(epochs):
        model.train()
        for x, y in train_dl:
            x, y = x.to(device), y.to(device)
            loss = F.cross_entropy(model(x), y)
            opt.zero_grad()
            loss.backward()
            opt.step()
        print(f"época {ep + 1}: precisión en test = {evaluate(model):.4f}")


# ---------------------------------------------------------- cuantización
def quantize_tensor(w, bits):
    """Cuantización uniforme simétrica por tensor.

    Devuelve un tensor float cuyos valores pertenecen a una rejilla de
    2**bits niveles como máximo ("fake quantization"): sirve para medir la
    precisión sin escribir kernels enteros.
    """
    # TODO 1: si bits == 1, binarizar: alpha * sign(w), con alpha = media de |w|
    # TODO 2: si bits >= 2: qmax = 2**(bits - 1) - 1 y escala s = max(|w|) / qmax
    # TODO 3: devolver clamp(round(w / s), -qmax, qmax) * s
    raise NotImplementedError("Completa quantize_tensor()")


def quantize_model(model, bits):
    qm = copy.deepcopy(model)
    with torch.no_grad():
        for m in qm.modules():
            if isinstance(m, nn.Linear):
                m.weight.copy_(quantize_tensor(m.weight, bits))
    return qm


# ----------------------------------------------------------------- main
if __name__ == "__main__":
    # Parte 1: entrenamiento en float32
    model = MLP().to(device)
    train_model(model, epochs=5)
    base = evaluate(model)
    n_params = sum(p.numel() for p in model.parameters())
    print(f"float32: precisión {base:.4f}, {n_params} parámetros, {n_params * 4} bytes")

    # Parte 2: cuantización post-entrenamiento (PTQ) de los pesos
    bits_list = [8, 6, 4, 3, 2, 1]
    accs = []
    for b in bits_list:
        acc = evaluate(quantize_model(model, b))
        accs.append(acc)
        print(f"{b} bits: precisión {acc:.4f}")

    plt.plot(bits_list, accs, "o-", label="PTQ (solo pesos)")
    plt.axhline(base, ls="--", color="gray", label="float32")
    plt.xlabel("bits por peso")
    plt.ylabel("precisión en test")
    plt.title("MNIST, MLP 784-64-64-10")
    plt.gca().invert_xaxis()
    plt.legend()
    plt.grid(alpha=0.3)
    plt.savefig("t1_precision_vs_bits.png", dpi=150)
    print("Gráfica guardada en t1_precision_vs_bits.png")
