File size: 3,057 Bytes
443e097
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
"""Capa matemática del modelo determinístico (Experimento A — TA-003).

Funciones puras sobre la serie temporal de `diferencia_cp` de UN jugador. Cada
`diferencia_cp` es, desde el punto de vista del jugador que movió, cuántos
centipeones ganó (positivo) o cedió (negativo) en esa jugada. Analizar la
SECUENCIA de estos valores —y no el valor puntual— es lo que distingue al
modelo de una traducción directa cp→texto.

Categoría académica: estadística descriptiva + análisis de series temporales.
"""
from __future__ import annotations

# Nº de jugadas propias que forman la "ventana reciente" para tendencia/régimen.
VENTANA = 4


def media(serie: list[float]) -> float:
    """Media aritmética de la serie (0.0 si está vacía)."""
    return sum(serie) / len(serie) if serie else 0.0


def pendiente(serie: list[float]) -> float:
    """Pendiente de la regresión lineal por mínimos cuadrados sobre la serie.

    Mide la tendencia: negativa y de magnitud apreciable ⇒ el jugador viene
    perdiendo terreno de forma progresiva (deterioro sostenido); positiva ⇒
    viene recuperándose. Es la derivada promedio de la trayectoria, no una
    comparación puntual de dos valores.
    """
    n = len(serie)
    if n < 2:
        return 0.0
    mx = (n - 1) / 2          # media de los índices 0..n-1
    my = media(serie)
    num = sum((x - mx) * (y - my) for x, y in enumerate(serie))
    den = sum((x - mx) ** 2 for x in range(n))
    return num / den if den else 0.0


def racha_bajo_media(serie: list[float], referencia: float) -> int:
    """Jugadas consecutivas (contando desde la última) por debajo de la referencia.

    La referencia es la media del PROPIO jugador, no un umbral externo fijo: el
    modelo detecta cuando alguien empeora respecto a su propio nivel en esta
    partida, sea cual sea ese nivel.
    """
    cont = 0
    for v in reversed(serie):
        if v < referencia:
            cont += 1
        else:
            break
    return cont


def cambio_regimen(serie: list[float], ventana: int = VENTANA) -> float:
    """Diferencia entre el promedio de la ventana reciente y la inmediatamente previa.

    << 0 ⇒ caída brusca (venía mejor y cayó de golpe). >> 0 ⇒ salto de mejora.
    Es una detección de cambio de régimen comparando dos ventanas contiguas; se
    necesita historial suficiente (2·ventana), si no devuelve 0.0.
    """
    if len(serie) < ventana * 2:
        return 0.0
    reciente = serie[-ventana:]
    previa = serie[-2 * ventana:-ventana]
    return media(reciente) - media(previa)


def fase(numero_jugada: int) -> str:
    """Fase de la partida derivada del número de jugada.

    Se deriva del número porque en este punto del pipeline no tenemos el material
    del tablero. Heurística estándar: apertura ≤10, medio juego 11–30, final >30.
    La fase MODULA la interpretación: el mismo error pesa más en un final.
    """
    if numero_jugada <= 10:
        return "apertura"
    if numero_jugada <= 30:
        return "medio juego"
    return "final"