Agregar guia de peso y estimar_foto

entrenamiento/GUIA_PESO.md

@@ -0,0 +1,299 @@
+# Guía del modelo de peso (Revalora IA)
+
+Última actualización: 2026-11-10
+
+Léela completa antes de entrenar nada. Resume qué se hizo, con qué datos, qué resultados dio y qué falta.
+
+---
+
+## 1. Objetivo
+
+Estimar el **peso en gramos** de un objeto. El modelo de peso (LightGBM) recibe **números**, no fotos:
+material, largo, ancho, espesor y número de piezas. El flujo final que se busca es:
+
+foto → material + piezas + medidas → LightGBM → peso
+
+Hoy solo está terminada la última parte (características → peso). Ver sección 10.
+
+---
+
+## 2. Entorno
+
+- Windows, PowerShell, VS Code, `uv`.
+- Proyecto: `EagleDev-Innovacion\revalora-ia-service`. Todos los comandos se corren desde esa carpeta.
+- Entorno virtual: `.venv` (activar con `.venv\Scripts\Activate.ps1`).
+- Modelos y datos compartidos: repo de Hugging Face `EagleDev-Innovation/Modelos-EagleDev-Innovation`.
+- Para subir necesitas ser miembro de la organización `EagleDev-Innovation` y un token con permiso **Write**:
+
+```powershell
+uv pip install huggingface_hub
+hf auth login
+hf auth whoami
+```
+
+---
+
+## 3. Estado actual
+
+| Pieza | Estado |
+|---|---|
+| LightGBM de peso (`modelos_entrenados/peso/lgbm_peso.joblib`) | Entrenado y subido a Hugging Face |
+| Datos propios de peso | Solo 12 filas, todas barras de acero de 12 mm (`metal`) |
+| Dataset externo EMMa (Stanford) | Descargado (6.7 GB), convertido a `emma_mat.csv` |
+| Búsqueda por similitud con CLIP (foto → productos parecidos) | Scripts listos, índice **sin terminar** (muy lento en CPU) |
+| Foto → medidas en cm | **No existe** |
+| Integración en el backend | Pendiente |
+| Modelos `conteo` y `material_estado` | Ya existen en el repo de Hugging Face (no se documentan en esta guía) |
+
+---
+
+## 4. Archivos (carpeta `entrenamiento\`)
+
+| Archivo | Para qué sirve |
+|---|---|
+| `hf_sync.py` | `bajar` / `subir "mensaje"` de la carpeta `modelos_entrenados` |
+| `hf_sync_datos.py` | `bajar` / `subir "mensaje"` de scripts y CSV (ver sección 11) |
+| `importar_emma_mat.py` | Lee el `.fdd` de EMMa y genera `datos/externos/emma_mat.csv` |
+| `entrenar_peso.py` | Entrena y valida el LightGBM de peso |
+| `probar_peso.py` | Predice peso con valores a mano |
+| `probar_foto.py` | Igual que el anterior, pero recibe la ruta de una foto (solo comprueba que exista, el peso sale de las medidas que se escriben) |
+| `indexar_emma.py` | Crea el índice CLIP de títulos de EMMa |
+| `estimar_foto.py` | Busca en el índice los productos parecidos a una foto y estima el peso |
+| `ver_emma.py`, `splits_emma.py` | Scripts de exploración del `.fdd` (se pueden ignorar) |
+| `importar_emma.py`, `limpiar_emma.py` | Versión anterior (sin material ni espesor). **Reemplazados** por `importar_emma_mat.py` |
+| `importar_externos.py` | Script anterior de datos externos. Ya no lo usa `entrenar_peso.py` |
+
+Otros archivos de la carpeta (`afinar_completo.py`, `buscar_roboflow.py`, `colab_entrenamiento.ipynb`, `entrenar.py`, `evaluar_conteo.py`, etc.) son de los modelos de conteo y material, y no se tocaron en este trabajo.
+
+---
+
+## 5. Datos
+
+### 5.1 Datos propios: `datos/peso/caracteristicas.csv`
+
+Columnas: `foto, sesion, tipo_objeto, material, n_piezas, area_cm2_total, largo_cm_medio, ancho_cm_medio, largo_cm_max, espesor_cm, peso_real_g`.
+
+- 12 filas, todas barras de acero de 12 mm (`material = metal`). Ejemplo: 1 barra = 888 g, 2 barras = 1780 g, 3 barras = 2650 g.
+- `area_cm2_total` es el área **de todas las piezas juntas** (120, 240, 360...). El entrenamiento la divide entre `n_piezas`.
+- `largo_cm_max` es ~1 % mayor que `largo_cm_medio` (101 contra 100).
+- `espesor_cm` se agregó a mano (1.2).
+- Esta es la parte débil del proyecto: con esto no se puede validar nada fuera del acero.
+
+### 5.2 Dataset externo: EMMa v1.1 (Stanford)
+
+- Archivo: `datos/externos/EMMa_v1.1.fdd` (6,692,678,168 bytes ≈ 6.7 GB), con título, descripción, atributos (masa, dimensiones, categoría, materiales como vector).
+- Descarga (reanuda si se corta):
+
+```powershell
+mkdir datos\externos -Force
+curl.exe -L -C - -o datos\externos\EMMa_v1.1.fdd https://downloads.cs.stanford.edu/downloads/emma/EMMa_v1.1.fdd
+```
+
+- **No** se descargó el archivo de imágenes (185 GB), no hace falta.
+- **No** subir el `.fdd` a Hugging Face: cada quien lo descarga de Stanford.
+
+### 5.3 Cómo se lee el `.fdd` (importante)
+
+El paquete `freeze-dried-data` 2.6.4 **no sirve** para este archivo (`RFDD` da `Split not found` y no existe `FDD`). Se lee a mano:
+
+- Los últimos 8 bytes son el tamaño del índice.
+- El índice es un pickle `asin → (inicio, largo)`.
+- Cada registro es un pickle (a veces comprimido con zlib) con: `materials, category, price, mass, ratings, dimensions, quantity, custom, image_hashes, title, features, description`.
+- 2,883,694 registros.
+- Unidades verificadas con medianas razonables: **masa en kg, dimensiones en pulgadas**. Son 3 valores por objeto; se ordenan de mayor a menor (largo, ancho, espesor).
+
+### 5.4 `datos/externos/emma_mat.csv` (lo que se usa para entrenar)
+
+Lo genera `importar_emma_mat.py` con estos filtros:
+
+- Un solo producto (`quantity == 1`) con una sola medida de dimensiones.
+- Masa entre 5 y 30,000 g. Largo 1–150 cm, ancho 0.5–150 cm, espesor ≥ 0.1 cm.
+- **Material** asignado por palabras clave del título y las características (en inglés). Solo se conservan los productos que coinciden con **un único** material: `metal, plastico, madera, vidrio, ceramica, carton, tela`.
+- Columnas: `material, n_piezas, area_cm2_total, largo_cm_medio, ancho_cm_medio, largo_cm_max, espesor_cm, peso_real_g`.
+- Quedan cientos de miles de filas (en el entrenamiento se muestrean 300,000).
+
+Limitación: el material por palabras clave es aproximado, y EMMa tiene muchos productos **huecos** (envases, cajas), por eso el modelo tiende a subestimar objetos macizos.
+
+---
+
+## 6. Modelo de peso
+
+Archivo: `entrenar_peso.py`. Configuración actual:
+
+- **Features:** `area_pieza` (área total ÷ n_piezas), `largo_cm_medio`, `ancho_cm_medio`, `largo_cm_max`, `relacion` (largo ÷ ancho), `espesor_cm`, `volumen_cm3` (area_pieza × espesor) y `material` en uno-caliente.
+- **Objetivo:** peso **por pieza** en escala logarítmica (`TransformedTargetRegressor` con `log1p` / `expm1`). Al predecir sale en gramos por pieza; se multiplica por `n_piezas`.
+- **LightGBM:** 600 árboles, `learning_rate=0.05`, `num_leaves=63`, `min_child_samples=30`, `subsample=0.8`.
+- **Pesos de muestra:** datos propios = 20, EMMa = 1 (`W_PROPIO = 20`).
+- **Muestreo:** `MAX_EXT = 300000` filas de EMMa.
+- Se guarda en `modelos_entrenados/peso/lgbm_peso.joblib` con las claves `modelo`, `columnas` y `cat`.
+
+### Validación
+
+Se hacen dos: (1) 20 % de EMMa reservado, (2) tus datos propios por sesión (GroupKFold), comparando contra un modelo lineal solo con datos propios.
+
+### Resultados (2026-11-10)
+
+| Prueba | Resultado |
+|---|---|
+| EMMa reservado | MAE 1263 g, error mediano **47.9 %** |
+| Propio, lineal | MAE 8.5 g (0.4 %) |
+| Propio, LightGBM | MAE **11.5 g** (0.5 %) |
+
+### Decisiones y por qué
+
+1. **Se agregó el espesor.** Sin él (solo largo y ancho) el error mediano en EMMa era 56 % y en las barras 111.9 g de MAE.
+2. **Se quitó `tipo_objeto`** de las features: los tipos propios no existen en EMMa.
+3. **`min_child_samples=30` y no 5.** Con 5 el modelo memoriza las 12 filas propias y la validación empeora (67.7 g).
+4. **Peso en logaritmo**, porque los pesos van de 5 g a 30 kg.
+5. El error de ~48 % en EMMa es el techo con estas features: dos productos del mismo tamaño y material pueden pesar muy distinto (macizo contra hueco).
+
+---
+
+## 7. Cómo reproducir
+
+Desde `revalora-ia-service` con el venv activo:
+
+```powershell
+# 1. Datos (descarga 1 vez, ~1 hora)
+mkdir datos\externos -Force
+curl.exe -L -C - -o datos\externos\EMMa_v1.1.fdd https://downloads.cs.stanford.edu/downloads/emma/EMMa_v1.1.fdd
+
+# 2. Convertir a CSV (~3 min)
+python entrenamiento\importar_emma_mat.py
+
+# 3. Entrenar y validar
+python entrenamiento\entrenar_peso.py
+
+# 4. Probar
+python entrenamiento\probar_peso.py
+python entrenamiento\probar_peso.py plastico 20 10 5
+python entrenamiento\probar_peso.py madera 25 10 2 4     # 4 piezas
+
+# 5. Subir (solo si los resultados no empeoraron)
+python entrenamiento\hf_sync.py subir "descripción del cambio"
+```
+
+Si ya están `emma_mat.csv` y `caracteristicas.csv` en Hugging Face, se saltan los pasos 1 y 2 con `python entrenamiento\hf_sync_datos.py bajar`.
+
+Orden de `probar_peso.py`: material, largo, ancho, espesor (cm) y, opcional, número de piezas. Materiales válidos: `metal`, `plastico`, `madera`, `vidrio`, `ceramica`, `carton`, `tela`. En PowerShell no escribas los `<...>` de los ejemplos: son marcadores.
+
+---
+
+## 8. Pruebas hechas
+
+| Objeto | Predicho | Real |
+|---|---|---|
+| Barra de acero 100×1.2×1.2 cm | 873 g | 888 g |
+| 3 barras de acero | 2619 g | 2650 g |
+| Madera 30×20×2 cm | ~800 g | sin pesar |
+| Plástico 20×10×5 cm | ~240 g | sin pesar |
+| Cartón 40×30×20 cm | ~3000 g | sin pesar |
+| Vidrio 20×8×8 cm | ~690 g | sin pesar |
+
+Solo el acero está validado con peso real. Pendiente: probar un bidón de agua de ~20 L vacío (usar plástico, ~50 × 27 × 27 cm, y pesarlo vacío; el modelo predice el objeto, no el contenido) y una hoja de papel (A4 ≈ 5 g, probablemente fuera de lo que vio el modelo).
+
+---
+
+## 9. Búsqueda por similitud con CLIP
+
+Idea: dada una foto, buscar los productos de EMMa más parecidos (CLIP compara la foto con los **títulos**) y estimar el peso con los vecinos.
+
+- `indexar_emma.py` toma 150,000 productos válidos de EMMa y guarda `datos/externos/emma_clip.npy` y `emma_clip.csv`.
+- `estimar_foto.py` recibe la ruta de una foto (y opcionalmente una pista en inglés, ej. `plastic water jug`), muestra los 15 vecinos más parecidos y da la mediana ponderada de su peso.
+- **Estado:** el 2026-11-10 se probó en CPU: ~19 s por lote, ~3 horas en total, sin terminar. En una GPU de Colab tarda unos minutos. Hay que correrlo en Colab (ver abajo) o bajar `N` en el script.
+- Todavía no se evaluó si las coincidencias son buenas. Revisar siempre la lista de vecinos impresa: si no son del mismo tipo de objeto, el estimado no sirve.
+
+Uso en Colab (GPU):
+
+```python
+!pip install -q sentence-transformers pillow huggingface_hub pandas lightgbm scikit-learn joblib
+from huggingface_hub import login
+from google.colab import userdata
+login(userdata.get("HF_TOKEN"))
+```
+Luego descargar los scripts (`hf_sync_datos.py bajar`), bajar el `.fdd` con `!curl -L -C - -o datos/externos/EMMa_v1.1.fdd <URL>`, correr `!python entrenamiento/indexar_emma.py` y subir con `hf_sync_datos.py subir`.
+
+---
+
+## 10. Qué falta (por prioridad)
+
+1. **Más datos propios variados.** Es lo que más mejora el modelo. Pesar 5–10 objetos de cada material (plástico, madera, cartón, vidrio, cerámica, tela, metal distinto al acero), medir largo, ancho y espesor, y agregarlos a `datos/peso/caracteristicas.csv` con `espesor_cm` y una `sesion` distinta por lote. Después reentrenar. Con esto la validación `[propio]` empieza a significar algo.
+2. **Foto → medidas en cm.** Una foto no trae escala. Opciones: objeto de referencia en la foto (hoja A4, tarjeta de 8.5×5.4 cm) para calcular cm por píxel, o que el usuario escriba las medidas. Decidir cuál.
+3. **Espesor.** También hay que pedirlo o asignarlo por tipo de objeto (hoja de papel ≈ 0.01 cm).
+4. **Conectar** `material_estado` (material) y `conteo` (piezas) con el LightGBM en un endpoint (`POST /peso` que reciba la imagen).
+5. **Terminar y evaluar el índice CLIP** y decidir si se combina con el LightGBM (el LightGBM con medidas reales debería ser más preciso).
+6. **Papel y objetos muy delgados:** EMMa se filtró con espesor ≥ 1 mm, así que el modelo no vio hojas sueltas. Necesitan datos propios.
+7. **Objetos de obra** (barras, tablones, cemento): EMMa son productos de Amazon, con pocas coincidencias buenas.
+
+---
+
+## 11. Integración con el backend
+
+Para predecir, el backend debe armar exactamente estas columnas (la lista oficial está en la clave `columnas` del `.joblib`):
+
+- `area_pieza` = área total ÷ n_piezas
+- `largo_cm_medio`, `ancho_cm_medio`
+- `largo_cm_max` = longitud máxima medida de la pieza (en las barras es ~1.01 × el largo medio; no copiar el largo medio, las predicciones salen más bajas)
+- `relacion` = largo ÷ ancho
+- `espesor_cm`
+- `volumen_cm3` = area_pieza × espesor
+- `material_carton, material_ceramica, material_madera, material_metal, material_plastico, material_tela, material_vidrio` (uno en 1, el resto en 0)
+
+La predicción sale en **gramos por pieza**; hay que multiplicar por `n_piezas`. Ver `probar_peso.py` como ejemplo exacto.
+
+---
+
+## 12. Compartir trabajo (Hugging Face)
+
+`hf_sync.py` maneja los modelos (`modelos_entrenados/`). `hf_sync_datos.py` maneja scripts y CSV:
+
+```python
+import sys
+from huggingface_hub import snapshot_download, upload_folder
+
+REPO = "EagleDev-Innovation/Modelos-EagleDev-Innovation"
+PATRONES = [
+    "entrenamiento/*.py", "entrenamiento/*.md", "entrenamiento/*.ipynb",
+    "datos/peso/*.csv",
+    "datos/externos/emma_mat.csv",
+    "datos/externos/emma_clip.*",
+]
+
+def bajar():
+    snapshot_download(repo_id=REPO, repo_type="model",
+                      allow_patterns=PATRONES, local_dir=".")
+    print("Código y datos descargados")
+
+def subir(mensaje):
+    upload_folder(repo_id=REPO, repo_type="model", folder_path=".",
+                  allow_patterns=PATRONES,
+                  ignore_patterns=[".venv/**", "**/__pycache__/**"],
+                  commit_message=mensaje)
+    print("Código y datos subidos")
+
+if __name__ == "__main__":
+    if sys.argv[1] == "bajar":
+        bajar()
+    elif sys.argv[1] == "subir":
+        subir(sys.argv[2] if len(sys.argv) > 2 else "Actualizar código y datos")
+```
+
+Reglas de equipo:
+
+- **`bajar` sobrescribe archivos locales.** Antes de bajar, sube o guarda lo tuyo; si no, pierdes cambios.
+- Hugging Face guarda historial: si alguien sube algo peor, se puede volver al commit anterior desde la pestaña *Files and versions*.
+- Suban un modelo solo si `[propio]` y `[EMMA holdout]` no empeoraron. Pongan el resultado en el mensaje del commit.
+- Avísense quién entrena para no pisarse en la misma carpeta.
+- No suban tokens, ni el `.fdd`, ni el `.venv`.
+
+---
+
+## 13. Errores que ya pasaron
+
+- `RFDD` con `Split not found` o `cannot import name 'FDD'`: leer el `.fdd` a mano (sección 5.3).
+- En PowerShell, `<material>` da error: no escribir los `<>`.
+- `.Replace(...)` sobre un script **no avisa si no encontró el texto**: el archivo queda igual. Verificar con `Select-String -Path archivo -Pattern 'texto'`.
+- `largo_cm_max` en la prueba debe ser ~1.01 × el largo (como en los datos propios), o las barras salen ~30 % más bajas.
+- `hf_sync.py subir` puede imprimir "No files have been modified" aunque haya subido: comprobar la fecha del archivo en Hugging Face.
+- Los avisos de symlinks de Hugging Face en Windows son inofensivos.
+- CLIP en CPU es muy lento (ver sección 9).

entrenamiento/estimar_foto.py

@@ -0,0 +1,31 @@
+import sys
+import numpy as np
+import pandas as pd
+from PIL import Image
+from sentence_transformers import SentenceTransformer
+
+K = 15
+emb = np.load("datos/externos/emma_clip.npy").astype("float32")
+df = pd.read_csv("datos/externos/emma_clip.csv")
+model = SentenceTransformer("clip-ViT-B-32")
+
+img = Image.open(sys.argv[1]).convert("RGB")
+q = model.encode(img, normalize_embeddings=True)
+if len(sys.argv) > 2:  # pista opcional en inglés, ej: "plastic water jug"
+    t = model.encode(" ".join(sys.argv[2:]), normalize_embeddings=True)
+    q = q + t
+    q = q / np.linalg.norm(q)
+
+sim = emb @ q
+top = np.argsort(-sim)[:K]
+sel = df.iloc[top].copy()
+sel["sim"] = sim[top]
+
+print("\nCoincidencias más parecidas:")
+for _, r in sel.iterrows():
+    print(f"{r.sim:.3f} | {r.peso_g:7.0f} g | {str(r.dims_cm):22s} | {r.title[:60]}")
+
+o = np.argsort(sel.peso_g.to_numpy())
+p, w = sel.peso_g.to_numpy()[o], sel.sim.to_numpy()[o]
+mediana = p[np.searchsorted(np.cumsum(w) / w.sum(), 0.5)]
+print(f"\nPeso estimado: {mediana:.0f} g  (rango típico {np.percentile(p, 25):.0f} - {np.percentile(p, 75):.0f} g)")