Spaces:
Paused
Paused
Download modules/deterministic/estado.py from SamilG2/BACKEND-CheckScan: direct link, hf CLI and curl.
- Browser
- Download file 2.9 kB
-
https://huggingface.co/spaces/SamilG2/BACKEND-CheckScan/resolve/main/modules/deterministic/estado.py
- Command line
-
hf download hf://spaces/SamilG2/BACKEND-CheckScan/modules/deterministic/estado.py
-
curl -L -o estado.py https://huggingface.co/spaces/SamilG2/BACKEND-CheckScan/resolve/main/modules/deterministic/estado.py
2.9 kB
| """Estado estratégico recursivo del modelo determinístico (Experimento A — TA-003). | |
| Formaliza la idea de CADENA DE MARKOV: el estado en la jugada N se obtiene | |
| aplicando una función de transición al estado anterior y a la jugada actual, | |
| estado_N = actualizar(estado_{N-1}, jugada_N) | |
| donde el estado resume toda la historia relevante (es un *estadístico | |
| suficiente*: contiene la serie y los features derivados de ella). Como la | |
| transición es determinística y sin azar, el mismo historial produce SIEMPRE el | |
| mismo estado → replicabilidad por construcción (RN-004). | |
| Categoría académica: autómata de estado finito / proceso markoviano determinístico. | |
| """ | |
| from __future__ import annotations | |
| from dataclasses import dataclass, replace | |
| from . import features | |
| class EstadoEstrategico: | |
| """Estadístico suficiente de la partida hasta la jugada actual (un jugador). | |
| `frozen=True` lo vuelve inmutable: cada transición devuelve un estado nuevo, | |
| nunca muta el anterior. Esto refuerza la pureza y la replicabilidad. | |
| """ | |
| n_jugadas: int = 0 | |
| serie_cp: tuple = () # diferencia_cp del jugador, en orden cronológico | |
| errores: int = 0 | |
| imprecisiones: int = 0 | |
| # Features derivados (se recalculan en cada transición). | |
| media_propia: float = 0.0 | |
| pendiente: float = 0.0 | |
| racha: int = 0 | |
| cambio: float = 0.0 | |
| fase: str = "apertura" | |
| ultima_clasificacion: str = "" | |
| def actualizar(estado: EstadoEstrategico, dif_cp: int, | |
| clasificacion: str, numero: int) -> EstadoEstrategico: | |
| """Función de transición de la cadena de Markov: estado_{N-1} → estado_N.""" | |
| serie = estado.serie_cp + (dif_cp,) | |
| serie_lista = list(serie) | |
| media_propia = features.media(serie_lista) | |
| return replace( | |
| estado, | |
| n_jugadas=estado.n_jugadas + 1, | |
| serie_cp=serie, | |
| errores=estado.errores + (1 if clasificacion == "Error" else 0), | |
| imprecisiones=estado.imprecisiones + (1 if clasificacion == "Imprecisión" else 0), | |
| media_propia=media_propia, | |
| pendiente=features.pendiente(serie_lista[-features.VENTANA:]), | |
| racha=features.racha_bajo_media(serie_lista, media_propia), | |
| cambio=features.cambio_regimen(serie_lista), | |
| fase=features.fase(numero), | |
| ultima_clasificacion=clasificacion, | |
| ) | |
| def construir(jugadas: list[tuple]) -> EstadoEstrategico: | |
| """Reduce (fold) la función de transición sobre la secuencia de jugadas. | |
| `jugadas`: lista de tuplas (diferencia_cp, clasificacion, numero) en orden | |
| cronológico, correspondientes a un mismo jugador. Aplicar `actualizar` | |
| repetidamente ES la cadena de Markov desplegada sobre la partida. | |
| """ | |
| estado = EstadoEstrategico() | |
| for dif_cp, clasificacion, numero in jugadas: | |
| estado = actualizar(estado, dif_cp, clasificacion, numero) | |
| return estado | |