En producción: el reentrenamiento

"""El mundo (no es lo que practicas): un mes del marketplace con modelo-v1 en producción.

Llegan 11 publicaciones a prod/entrantes/ con lo que eligió quien vende. Negocio agregó la
categoría «bolsa» este mes, así que hay bolsas que el modelo no conoce. Corre una sola vez.
"""
import csv
import gzip
import json
import shutil
from pathlib import Path

import numpy as np
from PIL import Image

CACHE = Path.home() / ".cache" / "fashion-mnist"
imgs = np.frombuffer(gzip.decompress((CACHE / "t10k-images-idx3-ubyte.gz").read_bytes()), np.uint8, offset=16).reshape(-1, 28, 28)
etq = np.frombuffer(gzip.decompress((CACHE / "t10k-labels-idx1-ubyte.gz").read_bytes()), np.uint8, offset=8)

rng = np.random.default_rng(2026)
plan = [(8, "bolsa")] * 6 + [(0, "playera")] * 2 + [(7, "tenis"), (7, "playera")]   # la última: quien vende se equivocó
usadas = set()
SALIDA = Path("prod/entrantes")
SALIDA.mkdir(parents=True, exist_ok=True)
publicaciones = []
for i, (clase, eligio) in enumerate(plan, 1):
    idx = int(rng.choice([j for j in np.where(etq == clase)[0] if j not in usadas and j >= 5000]))
    usadas.add(idx)
    Image.fromarray(255 - imgs[idx]).resize((112, 112), Image.NEAREST).save(SALIDA / f"req_{i:03d}.png")
    publicaciones.append({"request_id": f"req_{i:03d}", "archivo": f"req_{i:03d}.png", "categoria_vendedor": eligio})

# Alguien vuelve a subir una foto que ya está en tu dataset (la primera de test, para que duela).
vieja = next(f["sha256"] for f in csv.DictReader(open("data/splits.csv")) if f["split"] == "test")
archivo = next(f["archivo"] for f in csv.DictReader(open("data/labels.csv")) if f["sha256"] == vieja)
shutil.copy(Path("data/crudo") / archivo, SALIDA / "req_011.png")
publicaciones.append({"request_id": "req_011", "archivo": "req_011.png", "categoria_vendedor": "playera"})
rng.shuffle(publicaciones)
Path("prod/publicaciones.jsonl").write_text("".join(json.dumps(p) + "\n" for p in publicaciones))
print(f"{len(publicaciones)} publicaciones en prod/")

"""Precálculo · ¿Cuántas bolsas necesita el modelo para reconocerlas?

Entrena 200 veces con 4 playeras, 4 tenis y N bolsas al azar, y mide qué parte de 50 bolsas
que nunca vio reconoce. No es parte del pipeline: es la cuenta que decide el cupo del mes.
"""
import gzip
from pathlib import Path

import numpy as np
from sklearn.linear_model import LogisticRegression

C = Path.home() / ".cache" / "fashion-mnist"
X = 1 - np.frombuffer(gzip.decompress((C / "t10k-images-idx3-ubyte.gz").read_bytes()), np.uint8, offset=16).reshape(-1, 784) / 255
y = np.frombuffer(gzip.decompress((C / "t10k-labels-idx1-ubyte.gz").read_bytes()), np.uint8, offset=8)

rng = np.random.default_rng(0)
for n in (2, 3, 4, 6):
    aciertos = []
    for _ in range(200):
        train = np.concatenate([rng.choice(np.where(y == c)[0], k, replace=False) for c, k in ((0, 4), (7, 4), (8, n))])
        modelo = LogisticRegression(max_iter=1000).fit(X[train], y[train])
        prueba = rng.choice(np.where(y == 8)[0], 50, replace=False)
        aciertos.append((modelo.predict(X[prueba]) == 8).mean())
    print(f"{n} bolsas en train → reconoce {np.mean(aciertos):.0%} de las bolsas nuevas")

python mundo/llegan.py && head -3 prod/publicaciones.jsonl

"""Producción · El modelo atiende cada publicación y deja su log de predicción.

En C01 esto lo hace el servicio en línea; aquí es un script. Lo importante es el log:
sin él no hay de dónde sacar qué etiquetar el mes que entra.
Uso: python scripts/predecir.py <modelo>
"""
import hashlib
import json
import sys
from pathlib import Path

import joblib

from comun import vector

nombre = sys.argv[1]
modelo = joblib.load(f"modelos/{nombre}.joblib")
log = []
for linea in Path("prod/publicaciones.jsonl").read_text().splitlines():
    p = json.loads(linea)
    ruta = Path("prod/entrantes") / p["archivo"]
    proba = modelo.predict_proba([vector(ruta.read_bytes())])[0]
    k = int(proba.argmax())
    log.append({"request_id": p["request_id"], "sha256": hashlib.sha256(ruta.read_bytes()).hexdigest(),
                "pred": modelo.classes_[k], "confianza": round(float(proba[k]), 3), "modelo": nombre})
Path("prod/predicciones.jsonl").write_text("".join(json.dumps(r) + "\n" for r in log))
for r in sorted(log, key=lambda r: r["request_id"]):
    print(f"{r['request_id']}  {r['pred']:8} {r['confianza']:.3f}")

python scripts/predecir.py modelo-v1

{"clases": ["playera", "tenis"], "cupo": {"train": 3, "val": 1, "test": 1}, "seleccion": {"presupuesto": 8, "umbral": 0.8, "azar": 1}}

"""Producción · Elegir qué etiquetar con el presupuesto del mes y copiarlo a data/crudo/.

Orden de prioridad: fuera las que ya están en el dataset (mismo sha256), luego las de la
categoría nueva, los desacuerdos con quien vende, las inciertas y una parte al azar.
"""
import csv
import json
import random
import shutil
from pathlib import Path

cfg = json.loads(Path("config.json").read_text())["seleccion"]   # {"presupuesto": 8, "umbral": 0.8, "azar": 1}
pubs = {p["request_id"]: p for p in map(json.loads, Path("prod/publicaciones.jsonl").read_text().splitlines())}
preds = {r["request_id"]: r for r in map(json.loads, Path("prod/predicciones.jsonl").read_text().splitlines())}
en_dataset = {f["sha256"] for f in csv.DictReader(Path("data/labels.csv").open())}
conocidas = set(json.loads(Path("modelos/modelo-v1.json").read_text())["clases"])

cola, resto, vistos = [], [], set()
for rid in sorted(pubs):
    p, r = pubs[rid], preds[rid]
    if r["sha256"] in en_dataset or r["sha256"] in vistos:
        print(f"{rid}  fuera: ya está en el dataset")
        continue
    vistos.add(r["sha256"])
    if p["categoria_vendedor"] not in conocidas:
        motivo = "nueva"
    elif r["pred"] != p["categoria_vendedor"]:
        motivo = "desacuerdo"
    elif r["confianza"] < cfg["umbral"]:
        motivo = "incierta"
    else:
        resto.append(rid)
        continue
    cola.append((rid, motivo))

PRIORIDAD = {"nueva": 0, "desacuerdo": 1, "incierta": 2}
cola.sort(key=lambda x: PRIORIDAD[x[1]])
random.seed(0)
azar = [(rid, "azar") for rid in random.sample(resto, min(cfg["azar"], len(resto)))]
cupo = cfg["presupuesto"] - len(azar)                      # el azar tiene cupo propio: no es lo primero que se recorta
for rid, motivo in cola[cupo:]:
    print(f"{rid}  {motivo}, pero no alcanza el presupuesto")
cola = cola[:cupo] + azar

with Path("prod/cola.csv").open("w", newline="") as f:
    w = csv.writer(f)
    w.writerow(["request_id", "archivo", "sha256", "motivo"])
    for rid, motivo in cola:
        w.writerow([rid, pubs[rid]["archivo"], preds[rid]["sha256"], motivo])
        shutil.copy(Path("prod/entrantes") / pubs[rid]["archivo"], Path("data/crudo") / pubs[rid]["archivo"])
for rid, motivo in cola:
    print(f"{rid}  {motivo}")
print(f"\n{len(cola)} a etiquetar (presupuesto {cfg['presupuesto']}) · copiadas a data/crudo/")

python scripts/seleccionar.py

python scripts/validar.py

# Guía de etiquetado · v2

**Para qué:** decidir la categoría de una foto de producto del marketplace. Una foto, una categoría.

## Categorías

| Categoría | Es | No es |
|---|---|---|
| `playera` | Prenda para el torso, de manga corta, larga o sin manga, con o sin estampado. | Vestidos, abrigos. |
| `tenis` | Calzado deportivo con agujetas o cierre, bajo o de bota. | Sandalias, zapatos de vestir. |
| `bolsa` | Bolsa de mano, de hombro, mochila chica o cartera con asa. | Maletas de viaje, estuches. |

## Casos límite

- **Manga larga:** sigue siendo `playera` si es de tela delgada y sin botones al frente.
- **Tenis de bota (cubre el tobillo):** es `tenis`.
- **Bolsa con forma de playera o de tenis (estampado, llavero):** manda la función: es `bolsa`.
- **Lo que eligió quien vende no cuenta:** etiqueta lo que ves en la foto.
- **No se ve bien o no es ninguna:** no adivines; usa *Skip* y anótalo en la bitácora.

## Cambios

- v2 (2026-11): negocio agrega `bolsa`; regla de función sobre forma; recordatorio de ignorar la categoría de quien vende.
- v1 (inicial): dos categorías.

<View>
  <Image name="foto" value="$image" zoom="true"/>
  <Choices name="clase" toName="foto" choice="single" showInline="true" required="true">
    <Choice value="playera"/>
    <Choice value="tenis"/>
    <Choice value="bolsa"/>
  </Choices>
</View>

diff guia/interfaz-v1.xml guia/interfaz-v2.xml

curl -s "http://localhost:8091/api/projects/2/export?exportType=JSON_MIN" \
  -H "Authorization: Token practica-token-local-0001" -o data/etiquetado/export-v2.json
python -c 'import json; [print(t["image"], t["clase"]) for t in json.load(open("data/etiquetado/export-v2.json"))]'

python scripts/etiquetas.py data/etiquetado/export-v2.json v2 2026-11

python scripts/dividir.py

python scripts/validar.py

# Ficha del dataset · c01-categorias

| | |
|---|---|
| **Versión** | `dataset-v2` |
| **Para qué** | Entrenar y evaluar el clasificador de categorías de las fotos del marketplace. |
| **Fotos** | 18 PNG de 112 × 112 px, en `data/crudo/` (DVC, remoto `s3://datasets/c01`). |
| **Clases** | `playera` 5 · `tenis` 7 · `bolsa` 6 |
| **Splits** | train 12 · val 3 · test 3. El test de v1 sigue igual; `bolsa` estrena 1 de val y 1 de test. |
| **Labels** | `data/labels.csv`: lote `inicial` con la guía v1 y lote `2026-11` con la guía v2. |
| **Fuente** | `inicial`: Fashion-MNIST. `2026-11`: publicaciones del marketplace elegidas por `scripts/seleccionar.py` (nueva, desacuerdo, azar). |
| **Datos personales** | Ninguno: solo entran al dataset las fotos elegidas para etiquetar; el resto se queda en `prod/`. |

## Límites conocidos

- `bolsa` tiene 4 fotos de train: según el precálculo, el modelo reconocería ≈ 3 de cada 4 bolsas nuevas.
- La cola del mes viene de lo que el modelo v1 vio en producción: no es una muestra uniforme. El cupo al azar existe para medir eso.

## Cambios

- `dataset-v2` (2026-11): +8 fotos de producción, clase nueva `bolsa`, guía v2.
- `dataset-v1`: versión inicial.

dvc add data/crudo -q && git add -A && git status --short

git commit -m "dataset v2: +8 fotos de noviembre, clase bolsa, guía v2"
git tag -a dataset-v2 -m "18 fotos · 3 clases"

dvc push

dvc diff dataset-v1 dataset-v2

git diff --stat dataset-v1 dataset-v2 -- data guia config.json DATASET.md

git diff dataset-v1 dataset-v2 -- data/splits.csv | grep -c "^-[0-9a-f]"

"""Comparar modelos con el MISMO test de una versión, clase por clase.

Uso: python scripts/evaluar.py <tag> <modelo> [<modelo> ...]   p. ej. dataset-v2 modelo-v1 modelo-v2
"""
import sys

import joblib

from comun import cargar

tag, modelos = sys.argv[1], sys.argv[2:]
X, y = cargar(tag, "test")
clases = sorted(set(y))
ancho = max(len(m) for m in modelos + [f"test de {tag}"]) + 2
print(f"test de {tag}".ljust(ancho) + "".join(f"{c:>9}" for c in clases))
for nombre in modelos:
    pred = joblib.load(f"modelos/{nombre}.joblib").predict(X)
    print(nombre.ljust(ancho) + "".join(f"{f'{(pred[y == c] == c).sum()}/{(y == c).sum()}':>9}" for c in clases))

git add scripts/evaluar.py && git commit -m "scripts para evaluar"

python scripts/entrenar.py modelo-v2 dataset-v2

python scripts/evaluar.py dataset-v2 modelo-v1 modelo-v2

git add -A && git commit -m "modelo-v2 entrenado con dataset-v2"

python scripts/entrenar.py modelo-v1-repro dataset-v1 | tail -9

python scripts/evaluar.py dataset-v1 modelo-v1 modelo-v1-repro modelo-v2

git checkout -q dataset-v1 && dvc checkout && ls data/crudo | wc -l

git checkout -q main && dvc checkout && ls data/crudo | wc -l