Repository navigation
test(calidad): grabar y reproducir respuestas del motor #31
New issue
Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.
By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.
Already on GitHub? Sign in to your account
Changes from all commits
File filter
Filter by extension
Conversations
Jump to
Diff view
Diff view
There are no files selected for viewing
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,91 @@ | ||
| """Grabar y reproducir las respuestas de un motor, para medir cambios del proceso sin el ruido del modelo. | ||
|
|
||
| Gemini no responde igual dos veces (en el banco de interfaz, dos corridas coinciden en ~67 % de los textos), así que | ||
| al comparar dos versiones del proceso la variación del modelo tapa el efecto del cambio. `MotorGrabado` envuelve a | ||
| un motor y guarda en SQLite la respuesta a cada pedido, con la clave del pedido exacto (instrucciones y textos). Si | ||
| el pedido se repite, la respuesta sale de la grabación, sin costo y siempre igual. Un cambio que solo toca lo que se | ||
| hace después del modelo (controles, arreglos) se mide así contra las mismas respuestas. | ||
|
|
||
| Solo es una herramienta de medición: la app no la usa. | ||
| """ | ||
|
|
||
| from __future__ import annotations | ||
|
|
||
| import hashlib | ||
| import json | ||
| import sqlite3 | ||
| import threading | ||
| from pathlib import Path | ||
| from typing import Any, cast | ||
|
|
||
| from .base import Lote, Motor | ||
| from .instrucciones import sistema, usuario | ||
|
|
||
|
|
||
| def clave_del_pedido(motor: str, lote: Lote, repeticion: int = 0) -> str: | ||
| """Huella del pedido: el mismo motor, las mismas instrucciones y los mismos textos dan la misma clave.""" | ||
| datos = "\x00".join((str(repeticion), motor, sistema(lote), usuario(lote))) | ||
| return hashlib.sha256(datos.encode("utf-8")).hexdigest() | ||
|
|
||
|
|
||
| class MotorGrabado: | ||
| """Un motor cuyas respuestas se graban y se reutilizan. | ||
|
|
||
| `repeticion` separa corridas que deben ser independientes (la 1.ª, la 2.ª…): cada una tiene su propia grabación. | ||
| Con `solo_grabado`, un pedido que no está grabado no va a la API: se devuelve vacío (el texto se rechaza, como si | ||
| el motor no hubiera respondido) y se cuenta en `faltantes`. | ||
| """ | ||
|
|
||
| def __init__(self, motor: Motor, ruta: Path, repeticion: int = 0, solo_grabado: bool = False) -> None: | ||
| self.envuelto = motor | ||
| self.repeticion = repeticion | ||
| self.solo_grabado = solo_grabado | ||
| self.aciertos = 0 #: respuestas que salieron de la grabación | ||
| self.pedidos = 0 #: respuestas que se pidieron al motor (y se grabaron) | ||
| self.faltantes = 0 #: pedidos sin grabación con `solo_grabado` | ||
| ruta.parent.mkdir(parents=True, exist_ok=True) | ||
| self._lock = threading.Lock() | ||
| self._db = sqlite3.connect(ruta, check_same_thread=False) | ||
| self._db.execute("CREATE TABLE IF NOT EXISTS respuestas (clave TEXT PRIMARY KEY, salida TEXT NOT NULL)") | ||
| self._db.commit() | ||
|
|
||
| @property | ||
| def nombre(self) -> str: | ||
| return self.envuelto.nombre | ||
|
|
||
| @property | ||
| def uso(self) -> list[int] | None: | ||
| """Tokens de entrada y salida que el motor real facturó (lo grabado no cuenta).""" | ||
| return cast("list[int] | None", getattr(self.envuelto, "uso", None)) | ||
|
|
||
| def traducir_lote(self, lote: Lote) -> dict[str, str]: | ||
| clave = clave_del_pedido(self.nombre, lote, self.repeticion) | ||
| with self._lock: | ||
| fila = self._db.execute("SELECT salida FROM respuestas WHERE clave=?", (clave,)).fetchone() | ||
| if fila is not None: | ||
| self.aciertos += 1 | ||
| datos: Any = json.loads(str(fila[0])) | ||
| return {str(k): str(v) for k, v in cast("dict[str, Any]", datos).items()} | ||
| if self.solo_grabado: | ||
| self.faltantes += 1 | ||
| return {} | ||
| salida = self.envuelto.traducir_lote(lote) | ||
| if salida: # una respuesta vacía (error de red, cuota) no se graba: la próxima vez se vuelve a pedir | ||
| with self._lock: | ||
| self._db.execute( | ||
| "INSERT OR REPLACE INTO respuestas (clave, salida) VALUES (?, ?)", | ||
| (clave, json.dumps(salida, ensure_ascii=False)), | ||
| ) | ||
| self._db.commit() | ||
| self.pedidos += 1 | ||
| return salida | ||
|
|
||
| def cerrar(self) -> None: | ||
| with self._lock: | ||
| self._db.close() | ||
|
|
||
| def __enter__(self) -> MotorGrabado: | ||
| return self | ||
|
|
||
| def __exit__(self, *_: object) -> None: | ||
| self.cerrar() | ||
| Original file line number | Diff line number | Diff line change |
|---|---|---|
|
|
@@ -18,10 +18,11 @@ | |
| from collections.abc import Iterable, Mapping | ||
| from dataclasses import asdict, dataclass, field | ||
| from pathlib import Path | ||
| from typing import Any | ||
| from typing import Any, cast | ||
|
|
||
| from ..motores import fabrica | ||
| from ..motores.base import Motor | ||
| from ..motores.gemini import PRECIOS | ||
| from ..nucleo import terminos as terminos_repetidos | ||
| from ..nucleo.ejemplos import CANTIDAD_EN_LA_APP, Ejemplos | ||
| from ..nucleo.glosario import Glosario | ||
|
|
@@ -204,6 +205,8 @@ class Medicion: | |
| descanso: float = 0.0 #: segundos de pausa de la carga segura (motores locales) | ||
| traducciones: list[dict[str, str]] = field(default_factory=list[dict[str, str]]) #: todas, para juzgarlas | ||
| terminos_respetados_lema: int = 0 #: como `terminos_respetados`, aceptando plurales y otras formas (WMT25) | ||
| tokens_reales: tuple[int, int] | None = None #: (entrada, salida) que facturó el motor en esta medición | ||
| costo_real: float | None = None #: US$ según `tokens_reales` y la tabla de precios (lo grabado no cuesta) | ||
|
|
||
| @property | ||
| def porcentaje(self) -> float: | ||
|
|
@@ -250,6 +253,16 @@ def tabla(self) -> str: | |
| else [] | ||
| ), | ||
| ("Costo estimado", "desconocido" if self.costo_estimado is None else f"US$ {self.costo_estimado:.3f}"), | ||
| *( | ||
| [ | ||
| ( | ||
| "Costo real", | ||
| f"US$ {self.costo_real:.4f} ({self.tokens_reales[0]} + {self.tokens_reales[1]} tokens)", | ||
| ) | ||
| ] | ||
| if self.costo_real is not None and self.tokens_reales is not None | ||
| else [] | ||
| ), | ||
| ( | ||
| "Tiempo", | ||
| f"{self.segundos:.0f} s" + (f" (de ellos {self.descanso:.0f} s de descanso)" if self.descanso else ""), | ||
|
|
@@ -302,6 +315,25 @@ def _medir( | |
| ) | ||
|
|
||
|
|
||
| def _uso(motor: Motor) -> list[int]: | ||
| """Tokens (entrada, salida) que el motor lleva facturados; [0, 0] si no los informa.""" | ||
| uso: object = getattr(motor, "uso", None) | ||
| if not isinstance(uso, list): | ||
| return [0, 0] | ||
| valores = cast("list[int]", uso) | ||
| return [int(valores[0]), int(valores[1])] if len(valores) == 2 else [0, 0] | ||
|
|
||
|
|
||
| def _gasto(motor: Motor, antes: list[int], modelo: str) -> tuple[tuple[int, int] | None, float | None]: | ||
| """(tokens, US$) gastados desde `antes`, si el motor los informa y se conoce el precio del modelo.""" | ||
| if getattr(motor, "uso", None) is None: | ||
| return None, None | ||
| ahora = _uso(motor) | ||
| tokens = (ahora[0] - antes[0], ahora[1] - antes[1]) | ||
| precio = PRECIOS.get(modelo) | ||
| return tokens, (None if precio is None else (tokens[0] * precio[0] + tokens[1] * precio[1]) / 1e6) | ||
|
|
||
|
|
||
| def medir( | ||
| motor: Motor, | ||
| banco: Banco, | ||
|
|
@@ -339,6 +371,7 @@ def medir( | |
| if caso.pista: | ||
| pistas[caso.original] = caso.pista | ||
| inicio = time.perf_counter() | ||
| uso_antes = list(_uso(motor)) | ||
| resultados = {ambito: traductor.traducir(textos, ambito, pistas) for ambito, textos in por_ambito.items()} | ||
|
Comment on lines
+374
to
375
There was a problem hiding this comment. Choose a reason for hiding this commentThe reason will be displayed to describe this comment to others. Learn more.
When Useful? React with 👍 / 👎. |
||
| segundos = time.perf_counter() - inicio | ||
| informe = Informe( | ||
|
|
@@ -349,6 +382,7 @@ def medir( | |
| ) | ||
| hechas = {(a, o): t for a, r in resultados.items() for o, t in r.traducciones.items()} | ||
| mediciones = [_medir(nombre or motor.nombre, banco, hechas, informe.costo(modelo, False, motor_id), segundos)] | ||
| mediciones[0].tokens_reales, mediciones[0].costo_real = _gasto(motor, uso_antes, modelo) | ||
| mediciones[0].rechazos = dict( | ||
| Counter(m.split(":")[0] for r in resultados.values() for m in r.rechazados.values()) | ||
| ) | ||
|
|
||
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
When
--motor personalizadois run with a different--direccionbut the same model and prompt,self.nombreremainspersonalizado:<modelo>, so this key treats both endpoints as the same engine. Reusing the recording can therefore return the first endpoint’s response instead of querying the newly configured one, or make--solo-grabadoreport a hit for the wrong endpoint.Useful? React with 👍 / 👎.