Saltar a contenido

T1: MNIST y cuantización

Fase: 1, semana 1 · Tiempo estimado: 3-4 horas · Dónde: Mac con PyTorch (MPS)

Objetivo

Entrenar un perceptrón multicapa (MLP) para reconocer dígitos escritos a mano y medir cuánto se degrada su precisión al representar los pesos con menos bits. Es el primer contacto con el compromiso central de TinyML: precisión frente a recursos.

Lo que vas a aprender

  • El ciclo completo de PyTorch: datos, modelo, pérdida, optimizador, bucle de entrenamiento, evaluación.
  • Qué es la cuantización uniforme y cómo afecta a una red ya entrenada.
  • Por qué por debajo de 4 bits hace falta otra estrategia (QAT), que es la base de LogicNets.

Teoría mínima

La cuantización uniforme simétrica de un tensor de pesos \(w\) a \(b\) bits usa una escala \(s\):

\[ q_{\max} = 2^{b-1} - 1, \qquad s = \frac{\max |w|}{q_{\max}}, \qquad \hat{w} = s \cdot \mathrm{clamp}\left(\mathrm{round}\left(\frac{w}{s}\right), -q_{\max}, q_{\max}\right) \]

Con \(b = 2\) los niveles son \(\{-s, 0, s\}\): una red ternaria. Con \(b = 1\) se usa binarización, \(\hat{w} = \alpha \cdot \mathrm{sign}(w)\) con \(\alpha = \mathrm{media}(|w|)\).

En hardware, \(\mathrm{round}(w/s)\) es el entero que realmente se almacena, y \(s\) se aplica una sola vez por capa (o se pliega en el umbral de la activación, como hace FINN).

Pasos

  1. Descarga el script base: t1_mnist_cuantizacion.py. Ya tiene los datos, el modelo y el entrenamiento.
  2. Con el entorno activado, cópialo a ~/tinyml/ y lee el código completo antes de ejecutarlo. Identifica dónde están el modelo, la pérdida y el optimizador.
  3. Completa los tres TODO de quantize_tensor().
  4. Ejecuta python t1_mnist_cuantizacion.py. El entrenamiento tarda un par de minutos en el M4.
  5. Revisa la gráfica t1_precision_vs_bits.png.
Solución de quantize_tensor() (inténtalo antes de abrir)
def quantize_tensor(w, bits):
    if bits == 1:
        alpha = w.abs().mean()
        return alpha * torch.sign(w)
    qmax = 2 ** (bits - 1) - 1
    s = w.abs().max() / qmax
    return torch.clamp(torch.round(w / s), -qmax, qmax) * s

Entregables

  • Precisión en float32 (debería rondar el 97%).
  • Tabla y gráfica de precisión frente a bits (8, 6, 4, 3, 2, 1).
  • Tamaño del modelo en bytes para cada número de bits.
  • Un párrafo con tu interpretación: ¿a partir de cuántos bits cae la precisión y por qué?

Para ir más allá

  • Escala por canal: usa una escala distinta por cada neurona de salida (fila de la matriz) en lugar de una por capa. ¿Mejora a 2 y 3 bits? Es lo que hacen LiteRT y CMSIS-NN.
  • Activaciones: el script solo cuantiza pesos. Cuantiza también las salidas de cada ReLU a 4 y 2 bits. En FINN y LogicNets ambas cosas van cuantizadas.
  • Relación con la fase 3: con 2 bits por entrada y fan-in 6, una neurona es una tabla de \(2^{12}\) filas. ¿Cuántas entradas tiene cada neurona de este MLP? ¿Qué haría falta para que cupiera en LUT?

Recursos