Sección 'Recursos bloque bajo': scatter interactivo + tablas por equipo

Scatter con liga (opción todas), ejes configurables (lado of/def × recurso ×
métrica: pv/jugada, tiros/jugada, xG acum/por jugada/por exitosa, goles, %goles,
%éxito, intentos), hover con equipo, click fija etiqueta. Abajo: tablas ofensiva
y defensiva por equipo con media de liga. Artefacto vendor/data/lowblock/
(mín 10 intentos por celda en scatter).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

scripts/build_model_dataset.py

@@ -0,0 +1,250 @@
+"""Construye el dataset por equipo-partido (features RICAS) para los modelos de
+bloque defensivo y pasillos, procesando los preprocessed liga por liga EN STREAMING
+(baja → extrae 1 fila por (matchId,teamId) → borra el CSV). Resumable.
+
+Por equipo-partido extrae (todo desde los eventos; NO carga la columna qualifiers —
+centros/largos se derivan por geometría/distancia):
+  - Resultado: goles a favor/en contra (para ELO y splits local/visita).
+  - Estilo: % fast break / build up / juego directo / set piece / recovery /
+    progressive; % ataques que terminan en centro; % pases cortos/largos/exitosos;
+    pases progresivos; nº de ataques (llegan a último tercio); xT y xG por partido.
+  - Formación más usada (id_formation) → one-hot en el entrenamiento.
+  - Posición/presión: avg x/y, % campo rival, altura media de recuperación.
+  - Distribución de BLOQUE DEFENSIVO enfrentado (alto/medio/bajo).
+  - Distribución de PASILLOS de ataque (Izq/Centro/Der).
+  - Peligro (xT) por (bloque × pasillo) en ATAQUE y en DEFENSA (concedido).
+El ELO, el rolling "hasta la fecha" y los splits local/visita se arman en el
+entrenamiento (necesitan orden cronológico entre partidos).
+
+Uso: python scripts/build_model_dataset.py --leagues "Spanish La Liga" ...
+     python scripts/build_model_dataset.py --all
+"""
+
+from __future__ import annotations
+
+import argparse
+import sys
+import tempfile
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "src"))
+
+import numpy as np
+import pandas as pd
+
+from racing_reports.datastore import DataStore
+
+OUT = Path(__file__).resolve().parents[1] / "vendor" / "data" / "modeling" / "matchteam_dataset.parquet"
+BLOCKS = {"Build Up against High Block": "H", "Build Up against Medium Block": "M",
+          "Build Up against Low Block": "L"}
+SHOTS = {"Goal", "SavedShot", "MissedShots", "ShotOnPost"}
+LANES = ["Der", "Centro", "Izq"]  # y<33.3 Der, <66.7 Centro, resto Izq (convención multitag)
+USECOLS = ["matchId", "teamId", "TeamName", "Competencia", "Temporada", "fecha", "home_team_id",
+           "period_id", "sequenceId", "phaseLabel", "x", "y", "endX", "endY", "event_name",
+           "xT", "xThreat", "xG_corr", "xG", "id_formation", "distanceTravelledByBall",
+           "lastLineBroken", "isGoal", "outcome_type"]
+
+
+def _lane(y):
+    return pd.cut(y, [-1, 33.333, 66.667, 1e9], labels=LANES)
+
+
+def _extract(df: pd.DataFrame, league: str, season: str) -> pd.DataFrame:
+    df = df[[c for c in USECOLS if c in df.columns]].copy()
+    if not {"matchId", "teamId", "x", "y", "event_name", "sequenceId", "phaseLabel"} <= set(df.columns):
+        return pd.DataFrame()
+    for c in ("x", "y", "endX", "endY", "period_id", "sequenceId", "distanceTravelledByBall"):
+        if c in df.columns:
+            df[c] = pd.to_numeric(df[c], errors="coerce")
+    for c in ("TeamName", "fecha", "home_team_id", "id_formation", "lastLineBroken"):
+        if c not in df.columns:
+            df[c] = pd.NA
+    df["matchId"] = df["matchId"].astype(str)
+    df["teamId"] = df["teamId"].astype(str)
+    df["xt"] = pd.to_numeric(df.get("xT"), errors="coerce")
+    if df["xt"].isna().all() and "xThreat" in df.columns:
+        df["xt"] = pd.to_numeric(df["xThreat"], errors="coerce")
+    df["xt"] = df["xt"].fillna(0.0).clip(lower=0)
+    df["xg"] = pd.to_numeric(df.get("xG_corr", df.get("xG")), errors="coerce").fillna(0.0)
+    df["is_pass"] = df["event_name"].eq("Pass")
+    df["is_shot"] = df["event_name"].isin(SHOTS)
+    df["is_goal"] = df["event_name"].eq("Goal")
+    df["blk"] = df["phaseLabel"].map(BLOCKS)
+    df["lane"] = _lane(df["y"])
+    # centro (geom): pase desde zona ancha terminando en área central
+    ex, ey = df.get("endX"), df.get("endY")
+    df["is_cross"] = (df["is_pass"] & ex.notna() & ey.notna() & (ex >= 83)
+                      & ey.between(21, 79) & ((df["y"] < 21) | (df["y"] > 79) | (df["x"] >= 83)))
+    # pase largo / corto por distancia recorrida del balón (fallback a |Δ|)
+    dist = pd.to_numeric(df.get("distanceTravelledByBall"), errors="coerce")
+    if dist.isna().all():
+        dist = ((ex - df["x"]) ** 2 + (ey - df["y"]) ** 2) ** 0.5 if ex is not None else pd.Series(np.nan, index=df.index)
+    df["pass_long"] = df["is_pass"] & (dist >= 30)
+    df["pass_short"] = df["is_pass"] & (dist < 15)
+    df["pass_ok"] = df["is_pass"] & df.get("outcome_type", pd.Series("", index=df.index)).astype(str).str.contains("uccess", na=False)
+    df["progressive"] = df["is_pass"] & df.get("lastLineBroken", pd.Series("", index=df.index)).astype(str).str.strip().isin(["last", "True", "true"])
+    df["opp_half"] = df["x"] > 50
+
+    # equipos / rival / local
+    teams = df.dropna(subset=["teamId"]).groupby("matchId")["teamId"].agg(lambda s: list(dict.fromkeys(s)))
+    opp = {}
+    for mid, ts in teams.items():
+        if len(ts) == 2:
+            opp[(mid, ts[0])] = ts[1]; opp[(mid, ts[1])] = ts[0]
+    name = df.dropna(subset=["teamId"]).drop_duplicates("teamId").set_index("teamId")["TeamName"].to_dict()
+
+    # ── secuencias (1 fila por matchId,period,sequenceId) ──
+    seq = df.groupby(["matchId", "period_id", "sequenceId"], sort=False).agg(
+        poss=("teamId", "first"), phase=("phaseLabel", "first"), blk=("blk", "first"),
+        npass=("is_pass", "sum"), maxx=("x", "max"), has_cross=("is_cross", "any"),
+        has_long=("pass_long", "any"), xt=("xt", "sum"), xg=("xg", "sum")).reset_index()
+    seq["is_buildup"] = seq["phase"].astype(str).str.startswith("Build Up against")
+    seq["is_counter"] = seq["phase"].eq("Counter Attack")
+    seq["is_setpiece"] = seq["phase"].eq("Set Piece")
+    seq["is_recovery"] = seq["phase"].eq("Recovery")
+    seq["is_progr"] = seq["phase"].eq("Progressive Play")
+    seq["is_direct"] = (seq["npass"] <= 4) & seq["has_long"] & ~seq["is_setpiece"]
+    seq["reached_ft"] = seq["maxx"] >= 66
+
+    def _team_seq_feats(poss_team_col):
+        g = seq.groupby(["matchId", poss_team_col])
+        f = g.agg(n_seq=("phase", "size"),
+                  sh_counter=("is_counter", "mean"), sh_buildup=("is_buildup", "mean"),
+                  sh_direct=("is_direct", "mean"), sh_setpiece=("is_setpiece", "mean"),
+                  sh_recovery=("is_recovery", "mean"), sh_progr=("is_progr", "mean"),
+                  cross_pct=("has_cross", "mean"), n_attacks=("reached_ft", "sum"),
+                  xt_total=("xt", "sum"), xg_total=("xg", "sum")).reset_index()
+        f["xt_per_attack"] = f["xt_total"] / f["n_attacks"].clip(lower=1)
+        return f.rename(columns={poss_team_col: "teamId"})
+
+    atk_feats = _team_seq_feats("poss")
+
+    # ── bloque defensivo enfrentado (el rival construye → este equipo defiende) ──
+    faced = (seq[seq["blk"].notna()].groupby(["matchId", "poss", "blk"]).size()
+             .unstack("blk", fill_value=0).reset_index())
+    for b in ("H", "M", "L"):
+        if b not in faced.columns:
+            faced[b] = 0
+    faced["def_team"] = [opp.get((m, t)) for m, t in zip(faced["matchId"], faced["poss"])]
+    defb = faced.dropna(subset=["def_team"]).rename(columns={"H": "def_H", "M": "def_M", "L": "def_L",
+                                                             "def_team": "teamId"})[["matchId", "teamId", "def_H", "def_M", "def_L"]]
+
+    # ── pasillos de ataque (pases del equipo en campo rival) ──
+    atk = df[df["is_pass"] & (df["x"] > 50) & df["y"].notna()]
+    lanes = atk.groupby(["matchId", "teamId", "lane"], observed=True).size().unstack("lane", fill_value=0).reset_index()
+    for ln in LANES:
+        if ln not in lanes.columns:
+            lanes[ln] = 0
+    lanes = lanes.rename(columns={ln: f"atk_{ln}" for ln in LANES})
+
+    # ── xT por (bloque × pasillo): ataque y defensa concedida ──
+    # Mergeamos seq SOLO sobre los eventos con xT>0 (una fracción) para no inflar memoria.
+    ev = df.loc[(df["xt"] > 0) & df["lane"].notna(),
+                ["matchId", "period_id", "sequenceId", "lane", "xt"]].merge(
+        seq[["matchId", "period_id", "sequenceId", "poss", "blk"]].rename(columns={"blk": "seq_blk"}),
+        on=["matchId", "period_id", "sequenceId"], how="left")
+    ev = ev[ev["seq_blk"].notna()].copy()
+    # ataque: eventos del equipo en posesión, por (bloque, pasillo)
+    off = (ev.groupby(["matchId", "poss", "seq_blk", "lane"], observed=True)["xt"].sum()
+           .unstack(["seq_blk", "lane"], fill_value=0.0))
+    off.columns = [f"offxt_{b}_{l}" for b, l in off.columns]
+    off = off.reset_index().rename(columns={"poss": "teamId"})
+    # defensa: el rival ataca → este equipo (def) concede; blk = el que impuso el defensor
+    ev["def_team"] = [opp.get((m, t)) for m, t in zip(ev["matchId"], ev["poss"])]
+    deff = (ev.dropna(subset=["def_team"]).groupby(["matchId", "def_team", "seq_blk", "lane"], observed=True)["xt"].sum()
+            .unstack(["seq_blk", "lane"], fill_value=0.0))
+    deff.columns = [f"defxt_{b}_{l}" for b, l in deff.columns]
+    deff = deff.reset_index().rename(columns={"def_team": "teamId"})
+
+    # ── resultado, formación, posición/presión ──
+    df["formk"] = df["id_formation"].astype(str)
+    base = df.groupby(["matchId", "teamId"]).agg(
+        TeamName=("TeamName", "first"), fecha=("fecha", "first"), home_team_id=("home_team_id", "first"),
+        n_events=("event_name", "size"), n_pass=("is_pass", "sum"), n_shots=("is_shot", "sum"),
+        goals_for=("is_goal", "sum"), avg_x=("x", "mean"), avg_y=("y", "mean"),
+        share_opp_half=("opp_half", "mean"), n_long=("pass_long", "sum"), n_short=("pass_short", "sum"),
+        n_passok=("pass_ok", "sum"), n_progr=("progressive", "sum"),
+        formation=("formk", lambda s: s.mode().iloc[0] if len(s.mode()) else "0")).reset_index()
+    base["pct_long"] = base["n_long"] / base["n_pass"].clip(lower=1)
+    base["pct_short"] = base["n_short"] / base["n_pass"].clip(lower=1)
+    base["pct_pass_ok"] = base["n_passok"] / base["n_pass"].clip(lower=1)
+    # altura media de recuperación (eventos defensivos)
+    rec = df[df["event_name"].isin(["BallRecovery", "Interception", "Tackle"])].groupby(["matchId", "teamId"])["x"].mean().rename("recovery_height").reset_index()
+
+    base["Competencia"] = league; base["Temporada"] = season
+    out = base
+    for t in (atk_feats, defb, lanes, off, deff, rec):
+        out = out.merge(t, on=["matchId", "teamId"], how="left")
+    out["rival_teamId"] = [opp.get((m, t)) for m, t in zip(out["matchId"], out["teamId"])]
+    out["rival_name"] = out["rival_teamId"].map(name)
+    out["is_home"] = out["teamId"].astype(str) == out["home_team_id"].astype(str)
+    # goles en contra = goles del rival
+    gf = out.set_index(["matchId", "teamId"])["goals_for"]
+    out["goals_against"] = [gf.get((m, r), np.nan) if r is not None else np.nan
+                            for m, r in zip(out["matchId"], out["rival_teamId"])]
+    fill0 = [c for c in out.columns if c.startswith(("def_", "atk_", "offxt_", "defxt_"))]
+    out[fill0] = out[fill0].fillna(0)
+    return out
+
+
+def _processed_keys() -> set:
+    if not OUT.exists():
+        return set()
+    d = pd.read_parquet(OUT, columns=["Competencia", "Temporada"])
+    return set(zip(d["Competencia"].astype(str), d["Temporada"].astype(str)))
+
+
+def _league_season_files(ds: DataStore):
+    fs = ds._filesystem_client()
+    root = ds.settings.azure_preprocessed_root.strip("/")
+    out = []
+    for p in fs.get_paths(path=root, recursive=True):
+        if getattr(p, "is_directory", False):
+            continue
+        name = getattr(p, "name", "") or ""
+        fn = name.split("/")[-1]
+        if fn.startswith("preprocessed_") and fn.endswith(".csv") and "etiquetado" not in fn:
+            parts = name[len(root):].strip("/").split("/")
+            if len(parts) >= 3:
+                out.append((parts[0], parts[1], fn, getattr(p, "content_length", 0) or 0))
+    return out
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--leagues", nargs="*", default=None)
+    ap.add_argument("--smallest", type=int, default=0)
+    ap.add_argument("--all", action="store_true")
+    ap.add_argument("--force", action="store_true")
+    args = ap.parse_args()
+    ds = DataStore()
+    files = _league_season_files(ds)
+    if args.leagues:
+        files = [f for f in files if f[0] in set(args.leagues)]
+    elif args.smallest:
+        files = sorted(files, key=lambda f: f[3])[:args.smallest]
+    elif not args.all:
+        ap.error("Pasá --leagues, --smallest N o --all")
+    done = set() if args.force else _processed_keys()
+    OUT.parent.mkdir(parents=True, exist_ok=True)
+    for lg, se, fn, sz in files:
+        if (lg, se) in done:
+            print(f"skip {lg}/{se}", flush=True); continue
+        print(f">>> {lg}/{se} ({sz/1e6:.0f} MB) — bajando…", flush=True)
+        fc = ds._filesystem_client().get_file_client(f"{ds.settings.azure_preprocessed_root}/{lg}/{se}/{fn}")
+        with tempfile.TemporaryDirectory() as td:
+            csv = Path(td) / fn
+            with open(csv, "wb") as fh:
+                fc.download_file(max_concurrency=8).readinto(fh)  # descarga en paralelo
+            df = pd.read_csv(csv, usecols=lambda c: c in USECOLS, low_memory=False)
+            rows = _extract(df, lg, se)
+        if rows.empty:
+            print(f"    {lg}/{se}: schema insuficiente, salteada", flush=True); continue
+        existing = [pd.read_parquet(OUT)] if OUT.exists() else []
+        pd.concat(existing + [rows], ignore_index=True).to_parquet(OUT, index=False)
+        print(f"    {len(rows)} filas | {rows.shape[1]} cols | total {len(pd.read_parquet(OUT))}", flush=True)
+    print("OK")
+
+
+if __name__ == "__main__":
+    main()

scripts/cmp_nn.py

@@ -0,0 +1,95 @@
+"""Etapa 2 de la comparación: lee /tmp/cmp.npz (arrays + preds LightGBM + baseline),
+entrena la red neuronal multi-tarea (embeddings + softmax/KL para bloques y pasillos,
+MSE para xT absoluto) e imprime la tabla final baseline / LightGBM / NN.
+
+Corre en proceso APARTE de lightgbm (solo importa torch) para evitar el choque de
+OpenMP. Uso: python scripts/cmp_nn.py
+"""
+
+from __future__ import annotations
+
+import numpy as np
+import torch
+import torch.nn as nn
+
+torch.manual_seed(7)
+NPZ = "/tmp/cmp.npz"
+
+
+def _kl(a, b):
+    a = np.clip(a, 1e-9, None); b = np.clip(b, 1e-9, None)
+    return float(np.mean(np.sum(a * (np.log(a) - np.log(b)), 1)))
+
+
+def _metrics(y, p, dist=True):
+    mae = float(np.mean(np.abs(y - p)))
+    if dist:
+        return {"MAE": round(mae, 4), "KL": round(_kl(y, p), 4)}
+    return {"MAE": round(mae, 4), "RMSE": round(float(np.sqrt(np.mean((y - p) ** 2))), 4)}
+
+
+class MTNet(nn.Module):
+    def __init__(self, n_num, n_team, n_lg, n_form):
+        super().__init__()
+        self.te = nn.Embedding(n_team, 16); self.le = nn.Embedding(n_lg, 4); self.fe = nn.Embedding(n_form, 4)
+        d = n_num + 16 + 16 + 4 + 4
+        self.trunk = nn.Sequential(nn.Linear(d, 128), nn.ReLU(), nn.Dropout(0.3),
+                                   nn.Linear(128, 64), nn.ReLU(), nn.Dropout(0.2))
+        self.h_blo = nn.Linear(64, 3); self.h_pas = nn.Linear(64, 3); self.h_xt = nn.Linear(64, 3)
+
+    def forward(self, x, ts, to, lg, fm):
+        z = torch.cat([x, self.te(ts), self.te(to), self.le(lg), self.fe(fm)], 1)
+        z = self.trunk(z)
+        return self.h_blo(z), self.h_pas(z), self.h_xt(z)
+
+
+def main():
+    d = np.load(NPZ)
+    Xn = d["Xn"]; Yb, Yp, Yx = d["Yb"], d["Yp"], d["Yx"]
+    Bb, Bp, Bx = d["Bb"], d["Bp"], d["Bx"]
+    tr, va, te = d["tr"], d["va"], d["te"]
+    pb, pp, px = d["pb"], d["pp"], d["px"]
+    ts, to, lg, fm = d["ts"], d["to"], d["lg"], d["fm"]
+    nfeat = int(d["nfeat"])
+
+    print("--- Red neuronal (embeddings + multi-tarea) ---", flush=True)
+    T = lambda a: torch.tensor(a)
+    net = MTNet(nfeat, int(d["n_team"]), int(d["n_lg"]), int(d["n_form"]))
+    opt = torch.optim.Adam(net.parameters(), lr=2e-3, weight_decay=1e-4)
+    klf = nn.KLDivLoss(reduction="batchmean"); msef = nn.MSELoss()
+    Xt = T(Xn); tsT, toT, lgT, fmT = T(ts), T(to), T(lg), T(fm)
+    Yb_t, Yp_t, Yx_t = T(Yb), T(Yp), T(Yx)
+    tr_t, va_t, te_t = T(np.where(tr)[0]), T(np.where(va)[0]), T(np.where(te)[0])
+    best = (1e9, None)
+    for ep in range(300):
+        net.train(); opt.zero_grad()
+        b, p, x = net(Xt[tr_t], tsT[tr_t], toT[tr_t], lgT[tr_t], fmT[tr_t])
+        loss = (klf(torch.log_softmax(b, 1), Yb_t[tr_t]) + klf(torch.log_softmax(p, 1), Yp_t[tr_t])
+                + 0.5 * msef(x, Yx_t[tr_t]))
+        loss.backward(); opt.step()
+        if ep % 10 == 0:
+            net.eval()
+            with torch.no_grad():
+                b, p, x = net(Xt[va_t], tsT[va_t], toT[va_t], lgT[va_t], fmT[va_t])
+                v = (klf(torch.log_softmax(b, 1), Yb_t[va_t]) + klf(torch.log_softmax(p, 1), Yp_t[va_t])).item()
+            if v < best[0]:
+                best = (v, {k: val.clone() for k, val in net.state_dict().items()})
+    net.load_state_dict(best[1]); net.eval()
+    with torch.no_grad():
+        b, p, x = net(Xt[te_t], tsT[te_t], toT[te_t], lgT[te_t], fmT[te_t])
+        nb = torch.softmax(b, 1).numpy(); npp = torch.softmax(p, 1).numpy(); nx = np.clip(x.numpy(), 0, None)
+
+    base = {"bloques": _metrics(Yb[te], Bb[te]), "pasillos": _metrics(Yp[te], Bp[te]), "xt": _metrics(Yx[te], Bx[te], dist=False)}
+    lgb_res = {"bloques": _metrics(Yb[te], pb), "pasillos": _metrics(Yp[te], pp), "xt": _metrics(Yx[te], px, dist=False)}
+    nn_res = {"bloques": _metrics(Yb[te], nb), "pasillos": _metrics(Yp[te], npp), "xt": _metrics(Yx[te], nx, dist=False)}
+
+    print("\n================ COMPARACIÓN (test temporal) ================", flush=True)
+    for k in ("bloques", "pasillos", "xt"):
+        print(f"\n{k}:")
+        print(f"  baseline : {base[k]}")
+        print(f"  LightGBM : {lgb_res[k]}")
+        print(f"  NN       : {nn_res[k]}")
+
+
+if __name__ == "__main__":
+    main()

scripts/cmp_prep.py

@@ -0,0 +1,88 @@
+"""Etapa 1 de la comparación: arma el split TEMPORAL, entrena LightGBM y guarda
+TODO lo necesario (arrays + predicciones LGB + baseline) en /tmp/cmp.npz para que
+la red neuronal corra en un proceso APARTE (evita el deadlock/segfault de OpenMP
+entre lightgbm y torch en el mismo proceso).
+
+Uso: python scripts/cmp_prep.py
+"""
+
+from __future__ import annotations
+
+import importlib.util
+from pathlib import Path
+
+import lightgbm as lgb
+import numpy as np
+import pandas as pd
+
+ROOT = Path(__file__).resolve().parents[1]
+spec = importlib.util.spec_from_file_location("tm", ROOT / "scripts" / "train_models.py")
+tm = importlib.util.module_from_spec(spec); spec.loader.exec_module(tm)
+RNG = np.random.default_rng(7)
+NPZ = Path("/tmp/cmp.npz")
+
+
+def _lgb_dist(Xtr, Ytr, Xva, Yva, Xte):
+    preds = []
+    for j in range(Ytr.shape[1]):
+        m = lgb.LGBMRegressor(n_estimators=700, learning_rate=0.025, num_leaves=31,
+                              subsample=0.8, colsample_bytree=0.5, min_child_samples=40, verbose=-1)
+        m.fit(Xtr, Ytr[:, j], eval_set=[(Xva, Yva[:, j])], callbacks=[lgb.early_stopping(50, verbose=False)])
+        preds.append(np.clip(m.predict(Xte), 0, None))
+    return np.vstack(preds).T
+
+
+def main():
+    df = pd.read_parquet(tm.DATA)
+    blk = df.assign(_b=df[tm.DEF].sum(axis=1) > 0).groupby("Competencia")["_b"].mean()
+    df = df[df["Competencia"].isin(blk[blk > 0.5].index)].copy()
+    m, feat = tm._assemble(df)
+    m = m.merge(df[["matchId", "teamId", "fecha"]].drop_duplicates(), on=["matchId", "teamId"], how="left")
+    m["fecha"] = pd.to_datetime(m["fecha"].astype(str).str[:10], errors="coerce")  # quita sufijo 'Z'
+    thr = m.groupby(["Competencia", "Temporada"])["fecha"].transform(lambda s: s.quantile(0.8))
+    m["is_test"] = (m["fecha"] > thr).fillna(False)
+
+    m = m.dropna(subset=["self_" + c for c in tm.DEF]).copy()
+    valid = (m[tm.DEF].sum(1) > 0) & (m[tm.ATK].sum(1) > 0)
+    m = m[valid].copy()
+
+    Yb, _ = tm._norm_df(m, tm.DEF); Yb = Yb.to_numpy(np.float32)
+    Yp, _ = tm._norm_df(m, tm.ATK); Yp = Yp.to_numpy(np.float32)
+    Yx = m[tm.XTLANE].to_numpy(np.float32)
+    Bb = m[["self_" + c for c in tm.DEF]].to_numpy(np.float32); Bb = Bb / np.clip(Bb.sum(1, keepdims=True), 1e-9, None)
+    Bp = m[["self_" + c for c in tm.ATK]].to_numpy(np.float32); Bp = Bp / np.clip(Bp.sum(1, keepdims=True), 1e-9, None)
+    Bx = m[["self_" + c for c in tm.XTLANE]].to_numpy(np.float32)
+
+    X = m[feat].to_numpy(np.float32); X = np.nan_to_num(X)
+    te = m["is_test"].to_numpy()
+    tr_all = ~te
+    mu, sd = X[tr_all].mean(0), X[tr_all].std(0) + 1e-6
+    Xn = ((X - mu) / sd).astype(np.float32)
+    tr_idx = np.where(tr_all)[0]
+    va = np.zeros(len(m), bool); va[RNG.choice(tr_idx, int(len(tr_idx) * 0.12), replace=False)] = True
+    tr = tr_all & ~va
+    print(f"filas: {len(m)} | train {tr.sum()} val {va.sum()} test {te.sum()} | features {len(feat)}", flush=True)
+
+    print("--- LightGBM (split temporal) ---", flush=True)
+    pb = _lgb_dist(Xn[tr], Yb[tr], Xn[va], Yb[va], Xn[te]); pb = pb / np.clip(pb.sum(1, keepdims=True), 1e-9, None)
+    pp = _lgb_dist(Xn[tr], Yp[tr], Xn[va], Yp[va], Xn[te]); pp = pp / np.clip(pp.sum(1, keepdims=True), 1e-9, None)
+    px = _lgb_dist(Xn[tr], Yx[tr], Xn[va], Yx[va], Xn[te])
+    print("LightGBM listo, guardando arrays...", flush=True)
+
+    # embeddings para la red
+    tcodes = pd.factorize(pd.concat([m["teamId"], m["rival_teamId"]]).astype(str))[1]
+    tmap = {v: i + 1 for i, v in enumerate(tcodes)}
+    ts = m["teamId"].astype(str).map(tmap).fillna(0).astype(int).to_numpy()
+    to = m["rival_teamId"].astype(str).map(tmap).fillna(0).astype(int).to_numpy()
+    lg = pd.factorize(m["Competencia"])[0] + 1
+    fm = pd.factorize(m["formation"].astype(str))[0] + 1
+
+    np.savez(NPZ, Xn=Xn, Yb=Yb, Yp=Yp, Yx=Yx, Bb=Bb, Bp=Bp, Bx=Bx,
+             tr=tr, va=va, te=te, pb=pb, pp=pp, px=px,
+             ts=ts, to=to, lg=lg, fm=fm, nfeat=len(feat),
+             n_team=len(tmap) + 1, n_lg=int(lg.max()) + 1, n_form=int(fm.max()) + 1)
+    print("guardado →", NPZ, flush=True)
+
+
+if __name__ == "__main__":
+    main()

scripts/gen_sl_def_profile.py

@@ -0,0 +1,75 @@
+"""Genera el lollipop de PERFIL DEFENSIVO de San Lorenzo (idéntico al de la sección
+'Equipos y variables' del Space) y lo guarda como PNG para la presentación.
+Verde = z del equipo; diamante amarillo = mejor de la liga; columnas z y ranking."""
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "src"))
+import matplotlib
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+from matplotlib.lines import Line2D
+from matplotlib.markers import MarkerStyle
+
+from racing_reports import team_vars as tv
+
+LEAGUE, SEASON, TEAM = "Liga Profesional Argentina", "26", "San Lorenzo"
+VARS = [
+    "goles_transicion_rival", "situacion_fast_break_rival", "acciones_defensivas_en_ofensiva",
+    "agresividad_offside", "altura_media_recuperacion", "avg_altura_offside", "ballrecovery",
+    "big_chances_generadas_rival", "clearance_totales", "duelos_aereos_ganados",
+    "goles_regular_play_rival", "goles_tempranos_rival", "goles_totales_rival", "intercepciones",
+    "pases_peligrosos_exitosos_con_centros_rival", "pases_progresivos_exitosos_rival",
+    "pct_centros_pases_totales_ultimo_tercio_rival", "pct_duelos_aereos_ganados",
+    "pct_pases_exitosos_t3_rival", "velocidad_progresion_m_por_s_rival", "xg_suma_tiros_rival",
+]
+
+BG = "#1b3a32"; GREEN = "#3ddc84"; RED = "#e8584e"; YEL = "#f2c14e"; TXT = "#e8eeea"; MUT = "#9fb4ab"
+
+prof = tv.team_profile(LEAGUE, SEASON, TEAM, VARS, scope="liga")
+items = prof["items"]
+n = prof["pool_size"]
+items = items[::-1]  # primera variable arriba
+
+fig, ax = plt.subplots(figsize=(13, 9), facecolor=BG)
+ax.set_facecolor(BG)
+y = range(len(items))
+for i, it in enumerate(items):
+    z = it["z"] or 0.0
+    c = GREEN if z >= 0 else RED
+    ax.plot([0, z], [i, i], color=c, lw=2.5, zorder=2, solid_capstyle="round")
+    ax.scatter([z], [i], s=130, color=c, zorder=3, edgecolors=BG, linewidths=1.5)
+    mz = it.get("mejor_liga_z")
+    if mz is not None:
+        ax.scatter([mz], [i], marker=MarkerStyle("D"), s=95, color=YEL, zorder=4,
+                   edgecolors=BG, linewidths=1.2)
+    # etiqueta izquierda (con flecha ↓ si negativa)
+    lab = ("↓" if it["negativa"] else "") + it["label"]
+    if len(lab) > 32:
+        lab = lab[:31] + "…"
+    ax.text(-3.25, i, lab, ha="right", va="center", color=(YEL if it["negativa"] else TXT), fontsize=11)
+    # z y ranking a la derecha
+    ax.text(3.55, i, f"{z:+.2f}", ha="right", va="center", color=c, fontsize=11, fontweight="bold")
+    ax.text(4.35, i, f"{it['rank']}/{n}", ha="right", va="center", color=MUT, fontsize=10)
+
+ax.axvline(0, color=MUT, lw=1, ls=(0, (4, 3)), alpha=0.6, zorder=1)
+for xg in (-3, 3):
+    ax.axvline(xg, color="#33514a", lw=0.8, alpha=0.5, zorder=0)
+ax.set_xlim(-3.2, 3.2); ax.set_ylim(-0.7, len(items) - 0.3)
+ax.set_yticks([]); ax.set_xticks([-3, 0, 3]); ax.set_xticklabels(["-3", "0", "+3"], color=MUT, fontsize=10)
+for s in ax.spines.values():
+    s.set_visible(False)
+ax.text(3.55, len(items) - 0.1, "z", ha="right", va="center", color=MUT, fontsize=10)
+ax.text(4.35, len(items) - 0.1, "ranking", ha="right", va="center", color=MUT, fontsize=10)
+ax.set_title(f"San Lorenzo  (Liga Profesional Argentina · 26)  ·  vs su liga-temporada · {n} equipos",
+             color=TXT, fontsize=14, fontweight="bold", loc="left", pad=16)
+leg = [Line2D([0], [0], marker="o", color=BG, markerfacecolor=GREEN, markersize=11, label="Equipo"),
+       Line2D([0], [0], marker="D", color=BG, markerfacecolor=YEL, markersize=10, label="Mejor de la liga")]
+ax.legend(handles=leg, loc="lower left", fontsize=10, facecolor="#16251e",
+          edgecolor="#33514a", labelcolor=TXT, ncol=2, bbox_to_anchor=(0.0, -0.06))
+
+out = Path(__file__).resolve().parents[1].parent / "Downloads" / "presentation-sanlorenzo" / "san_lorenzo" / "perfil_defensivo.png"
+out = Path("/Users/pagrois/Downloads/presentation-sanlorenzo/san_lorenzo/perfil_defensivo.png")
+fig.subplots_adjust(left=0.30, right=0.96, top=0.92, bottom=0.06)
+fig.savefig(out, dpi=130, facecolor=BG)
+print("guardado:", out, "| pool:", n, "| vars:", len(items))

scripts/train_compare.py

@@ -0,0 +1,149 @@
+"""Compara LightGBM vs una red neuronal multi-tarea (embeddings + softmax/KL) en el
+MISMO split TEMPORAL (test = último ~20% de fechas de cada liga-temporada), sobre los
+3 objetivos: bloque defensivo, pasillos (share) y xT absoluto por pasillo.
+
+Uso: python scripts/train_compare.py
+"""
+
+from __future__ import annotations
+
+import importlib.util
+from pathlib import Path
+
+import lightgbm as lgb
+import numpy as np
+import pandas as pd
+import torch
+import torch.nn as nn
+
+ROOT = Path(__file__).resolve().parents[1]
+spec = importlib.util.spec_from_file_location("tm", ROOT / "scripts" / "train_models.py")
+tm = importlib.util.module_from_spec(spec); spec.loader.exec_module(tm)
+RNG = np.random.default_rng(7)
+torch.manual_seed(7)
+
+
+def _kl(a, b):
+    a = np.clip(a, 1e-9, None); b = np.clip(b, 1e-9, None)
+    return float(np.mean(np.sum(a * (np.log(a) - np.log(b)), 1)))
+
+
+def _metrics(y, p, dist=True):
+    mae = float(np.mean(np.abs(y - p)))
+    if dist:
+        return {"MAE": round(mae, 4), "KL": round(_kl(y, p), 4)}
+    return {"MAE": round(mae, 4), "RMSE": round(float(np.sqrt(np.mean((y - p) ** 2))), 4)}
+
+
+def _lgb_dist(Xtr, Ytr, Xva, Yva, Xte):
+    preds = []
+    for j in range(Ytr.shape[1]):
+        m = lgb.LGBMRegressor(n_estimators=700, learning_rate=0.025, num_leaves=31,
+                              subsample=0.8, colsample_bytree=0.5, min_child_samples=40, verbose=-1)
+        m.fit(Xtr, Ytr[:, j], eval_set=[(Xva, Yva[:, j])], callbacks=[lgb.early_stopping(50, verbose=False)])
+        preds.append(np.clip(m.predict(Xte), 0, None))
+    return np.vstack(preds).T
+
+
+class MTNet(nn.Module):
+    def __init__(self, n_num, n_team, n_lg, n_form):
+        super().__init__()
+        self.te = nn.Embedding(n_team, 16); self.le = nn.Embedding(n_lg, 4); self.fe = nn.Embedding(n_form, 4)
+        d = n_num + 16 + 16 + 4 + 4
+        self.trunk = nn.Sequential(nn.Linear(d, 128), nn.ReLU(), nn.Dropout(0.3),
+                                   nn.Linear(128, 64), nn.ReLU(), nn.Dropout(0.2))
+        self.h_blo = nn.Linear(64, 3); self.h_pas = nn.Linear(64, 3); self.h_xt = nn.Linear(64, 3)
+
+    def forward(self, x, ts, to, lg, fm):
+        z = torch.cat([x, self.te(ts), self.te(to), self.le(lg), self.fe(fm)], 1)
+        z = self.trunk(z)
+        return self.h_blo(z), self.h_pas(z), self.h_xt(z)
+
+
+def main():
+    df = pd.read_parquet(tm.DATA)
+    blk = df.assign(_b=df[tm.DEF].sum(axis=1) > 0).groupby("Competencia")["_b"].mean()
+    df = df[df["Competencia"].isin(blk[blk > 0.5].index)].copy()
+    m, feat = tm._assemble(df)
+    m = m.merge(df[["matchId", "teamId", "fecha"]].drop_duplicates(), on=["matchId", "teamId"], how="left")
+    m["fecha"] = pd.to_datetime(m["fecha"].astype(str).str[:10], errors="coerce")  # quita sufijo 'Z'
+    thr = m.groupby(["Competencia", "Temporada"])["fecha"].transform(lambda s: s.quantile(0.8))
+    m["is_test"] = (m["fecha"] > thr).fillna(False)
+
+    # filas con historial rolling + bloque válido
+    m = m.dropna(subset=["self_" + c for c in tm.DEF]).copy()
+    valid = (m[tm.DEF].sum(1) > 0) & (m[tm.ATK].sum(1) > 0)
+    m = m[valid].copy()
+
+    # targets
+    Yb, _ = tm._norm_df(m, tm.DEF); Yb = Yb.to_numpy(np.float32)
+    Yp, _ = tm._norm_df(m, tm.ATK); Yp = Yp.to_numpy(np.float32)
+    Yx = m[tm.XTLANE].to_numpy(np.float32)
+    # baseline = promedio propio rolling
+    Bb = m[["self_" + c for c in tm.DEF]].to_numpy(np.float32); Bb = Bb / np.clip(Bb.sum(1, keepdims=True), 1e-9, None)
+    Bp = m[["self_" + c for c in tm.ATK]].to_numpy(np.float32); Bp = Bp / np.clip(Bp.sum(1, keepdims=True), 1e-9, None)
+    Bx = m[["self_" + c for c in tm.XTLANE]].to_numpy(np.float32)
+
+    X = m[feat].to_numpy(np.float32); X = np.nan_to_num(X)
+    te = m["is_test"].to_numpy()
+    tr_all = ~te
+    mu, sd = X[tr_all].mean(0), X[tr_all].std(0) + 1e-6
+    Xn = (X - mu) / sd
+    # val carve del train para early stopping
+    tr_idx = np.where(tr_all)[0]; va = np.zeros(len(m), bool); va[RNG.choice(tr_idx, int(len(tr_idx) * 0.12), replace=False)] = True
+    tr = tr_all & ~va
+    print(f"filas: {len(m)} | train {tr.sum()} val {va.sum()} test {te.sum()} | features {len(feat)}")
+
+    # ===== LightGBM =====
+    print("\n--- LightGBM (split temporal) ---")
+    pb = _lgb_dist(Xn[tr], Yb[tr], Xn[va], Yb[va], Xn[te]); pb = pb / np.clip(pb.sum(1, keepdims=True), 1e-9, None)
+    pp = _lgb_dist(Xn[tr], Yp[tr], Xn[va], Yp[va], Xn[te]); pp = pp / np.clip(pp.sum(1, keepdims=True), 1e-9, None)
+    px = _lgb_dist(Xn[tr], Yx[tr], Xn[va], Yx[va], Xn[te])
+    lgb_res = {"bloques": _metrics(Yb[te], pb), "pasillos": _metrics(Yp[te], pp), "xt": _metrics(Yx[te], px, dist=False)}
+
+    # ===== NN multi-tarea =====
+    print("--- Red neuronal (embeddings + multi-tarea) ---")
+    tcodes = pd.factorize(pd.concat([m["teamId"], m["rival_teamId"]]).astype(str))[1]
+    tmap = {v: i + 1 for i, v in enumerate(tcodes)}
+    ts = m["teamId"].astype(str).map(tmap).fillna(0).astype(int).to_numpy()
+    to = m["rival_teamId"].astype(str).map(tmap).fillna(0).astype(int).to_numpy()
+    lg = pd.factorize(m["Competencia"])[0] + 1
+    fm = pd.factorize(m["formation"].astype(str))[0] + 1
+    T = lambda a: torch.tensor(a)
+    net = MTNet(len(feat), len(tmap) + 1, lg.max() + 1, fm.max() + 1)
+    opt = torch.optim.Adam(net.parameters(), lr=2e-3, weight_decay=1e-4)
+    klf = nn.KLDivLoss(reduction="batchmean"); msef = nn.MSELoss()
+    Xt = T(Xn); tsT, toT, lgT, fmT = T(ts), T(to), T(lg), T(fm)
+    Yb_t, Yp_t, Yx_t = T(Yb), T(Yp), T(Yx)
+    tr_t, va_t, te_t = T(np.where(tr)[0]), T(np.where(va)[0]), T(np.where(te)[0])
+    best = (1e9, None)
+    for ep in range(300):
+        net.train(); opt.zero_grad()
+        b, p, x = net(Xt[tr_t], tsT[tr_t], toT[tr_t], lgT[tr_t], fmT[tr_t])
+        loss = (klf(torch.log_softmax(b, 1), Yb_t[tr_t]) + klf(torch.log_softmax(p, 1), Yp_t[tr_t])
+                + 0.5 * msef(x, Yx_t[tr_t]))
+        loss.backward(); opt.step()
+        if ep % 10 == 0:
+            net.eval()
+            with torch.no_grad():
+                b, p, x = net(Xt[va_t], tsT[va_t], toT[va_t], lgT[va_t], fmT[va_t])
+                v = (klf(torch.log_softmax(b, 1), Yb_t[va_t]) + klf(torch.log_softmax(p, 1), Yp_t[va_t])).item()
+            if v < best[0]:
+                best = (v, {k: val.clone() for k, val in net.state_dict().items()})
+    net.load_state_dict(best[1]); net.eval()
+    with torch.no_grad():
+        b, p, x = net(Xt[te_t], tsT[te_t], toT[te_t], lgT[te_t], fmT[te_t])
+        nb = torch.softmax(b, 1).numpy(); npp = torch.softmax(p, 1).numpy(); nx = np.clip(x.numpy(), 0, None)
+    nn_res = {"bloques": _metrics(Yb[te], nb), "pasillos": _metrics(Yp[te], npp), "xt": _metrics(Yx[te], nx, dist=False)}
+
+    base = {"bloques": _metrics(Yb[te], Bb[te]), "pasillos": _metrics(Yp[te], Bp[te]), "xt": _metrics(Yx[te], Bx[te], dist=False)}
+    print("\n================ COMPARACIÓN (test temporal) ================")
+    for k in ("bloques", "pasillos", "xt"):
+        print(f"\n{k}:")
+        print(f"  baseline : {base[k]}")
+        print(f"  LightGBM : {lgb_res[k]}")
+        print(f"  NN       : {nn_res[k]}")
+
+
+if __name__ == "__main__":
+    main()

src/racing_reports/api/routes_lowblock.py

@@ -0,0 +1,31 @@
+"""Endpoints de la sección "Recursos bloque bajo"."""
+
+from __future__ import annotations
+
+from fastapi import APIRouter, Depends, HTTPException
+
+from racing_reports import lowblock_data
+from racing_reports.api.deps import require_auth
+
+router = APIRouter(prefix="/api/lowblock")
+
+
+@router.get("/options", dependencies=[Depends(require_auth)])
+def options() -> dict:
+    try:
+        return lowblock_data.options()
+    except FileNotFoundError:
+        raise HTTPException(status_code=404, detail="Sin artefacto de recursos bloque bajo.")
+
+
+@router.get("/data", dependencies=[Depends(require_auth)])
+def data(league: str = "__all__") -> dict:
+    return {"rows": lowblock_data.scatter_rows(league)}
+
+
+@router.get("/team", dependencies=[Depends(require_auth)])
+def team(league: str, equipo: str) -> dict:
+    try:
+        return lowblock_data.team_tables(league, equipo)
+    except ValueError as exc:
+        raise HTTPException(status_code=404, detail=str(exc))

src/racing_reports/lowblock_data.py

@@ -0,0 +1,90 @@
+"""Datos de la sección "Recursos bloque bajo" (scatter + tablas por equipo).
+
+Lee el artefacto bundleado ``vendor/data/lowblock/team_resources.parquet``:
+una fila por (liga, equipo, lado of/def, recurso) con las métricas de intento
+(n, % éxito, pv por jugada) y de resultado por secuencia (tiros/jugada, xG, goles).
+"""
+
+from __future__ import annotations
+
+from functools import lru_cache
+
+import pandas as pd
+
+from racing_reports import vendor_env
+
+PATH = vendor_env.DATA_DIR / "lowblock" / "team_resources.parquet"
+
+RECURSO_LABELS = {
+    "pase_entre_lineas": "Pase entre líneas",
+    "cutback": "Cutback",
+    "centro_colgado": "Centro colgado",
+    "centro_inswinger": "Centro inswinger",
+    "centro_outswinger": "Centro outswinger",
+    "centro_raso": "Centro raso",
+    "rompe_lineas_ok": "Rompe-líneas (completado)",
+    "gambeta": "Gambeta (1v1)",
+    "tiro_lejano": "Tiro larga distancia",
+}
+METRICA_LABELS = {
+    "pv_jugada": "Peligro por jugada (pv ‰)",
+    "tiros_jugada": "Tiros por jugada",
+    "xg_acum": "xG acumulado",
+    "xg_jugada": "xG por jugada",
+    "xg_jugada_exitosa": "xG por jugada exitosa",
+    "goles": "Goles",
+    "pct_goles": "% de goles",
+    "pct_exito": "% de éxito",
+    "n_intentos": "Cantidad de intentos",
+}
+
+
+@lru_cache(maxsize=1)
+def _df() -> pd.DataFrame:
+    return pd.read_parquet(PATH)
+
+
+def options() -> dict:
+    df = _df()
+    return {
+        "leagues": sorted(df["liga"].unique().tolist()),
+        "recursos": RECURSO_LABELS,
+        "metricas": METRICA_LABELS,
+        "lados": {"of": "Ofensivo", "def": "Defensivo"},
+    }
+
+
+def scatter_rows(league: str) -> list[dict]:
+    df = _df()
+    if league and league != "__all__":
+        df = df[df["liga"] == league]
+    cols = ["liga", "equipo", "lado", "recurso", "n_intentos", "pct_exito", "pv_jugada",
+            "tiros_jugada", "xg_acum", "xg_jugada", "xg_jugada_exitosa", "goles", "pct_goles"]
+    out = df[cols].where(pd.notna(df[cols]), None)
+    return out.to_dict("records")
+
+
+def team_tables(league: str, equipo: str) -> dict:
+    df = _df()
+    liga_df = df[df["liga"] == league]
+    if liga_df.empty:
+        raise ValueError(f"Liga sin datos: {league}")
+    # medias de la liga ponderadas por intentos (para la referencia "vs liga")
+    out = {}
+    for lado in ("of", "def"):
+        sub = liga_df[liga_df["lado"] == lado]
+        medias = {}
+        for rec, g in sub.groupby("recurso"):
+            w = g["n_intentos"].clip(lower=1)
+            medias[rec] = {
+                "pv_jugada": round(float((g["pv_jugada"] * w).sum() / w.sum()), 2),
+                "pct_exito": round(float((g["pct_exito"] * w).sum() / w.sum()), 1),
+                "xg_jugada": round(float((g["xg_jugada"].fillna(0) * w).sum() / w.sum()), 4),
+            }
+        rows = sub[sub["equipo"] == equipo].sort_values("pv_jugada", ascending=False)
+        out[lado] = {
+            "rows": rows.where(pd.notna(rows), None).to_dict("records"),
+            "liga_media": medias,
+        }
+    return {"league": league, "equipo": equipo,
+            "recursos": RECURSO_LABELS, **out}

src/racing_reports/web/app.py

@@ -22,6 +22,7 @@ from racing_reports.api.routes_meta import router as api_meta_router
 from racing_reports.api.routes_reports import router as api_reports_router
 from racing_reports.api.routes_team_vars import router as api_team_vars_router
 from racing_reports.api.routes_ejes import router as api_ejes_router
+from racing_reports.api.routes_lowblock import router as api_lowblock_router
 from racing_reports.config import DEFAULT_SETTINGS
 from racing_reports.datastore import DataStore
 from racing_reports.match_index import MatchIndex
@@ -49,6 +50,7 @@ app.include_router(api_reports_router)
 app.include_router(api_jobs_router)
 app.include_router(api_team_vars_router)
 app.include_router(api_ejes_router)
+app.include_router(api_lowblock_router)
 
 # Estado en memoria (single container en HF Space). Re-export para retrocompat.
 Job = jobs_mod.Job

src/racing_reports/web/templates/home.html

@@ -504,6 +504,104 @@
           <div id="ejtip" style="position:absolute;display:none;pointer-events:none;background:#1f2937;border:1px solid #4b5563;border-radius:8px;padding:6px 10px;font-size:12px;max-width:230px;z-index:10"></div>
         </div>
       </section>
+
+      <!-- ---- Recursos bloque bajo ---- -->
+      <section class="bg-ink-700 border border-ink-600 rounded-2xl p-5 mt-2">
+        <h2 class="text-lg font-semibold text-racing-500 mb-1">6. Recursos bloque bajo</h2>
+        <p class="text-xs text-gray-400 mb-3">Recursos ofensivos contra bloque bajo (y su cara defensiva) por equipo. Elegí liga, y para cada eje: lado, recurso y métrica. Hover = equipo; click = fijar etiqueta. Se muestran equipos con ≥10 intentos en ambos ejes.</p>
+        <div class="flex flex-wrap items-end gap-3 mb-2">
+          <div>
+            <label class="block text-xs text-gray-400 mb-1">Liga</label>
+            <select x-model="lbLeague" @change="lbLoad()" class="bg-ink-800 border border-ink-600 rounded-lg px-3 py-2 text-sm">
+              <option value="__all__">Todas las ligas</option>
+              <template x-for="l in lbLeagues" :key="l"><option :value="l" x-text="l"></option></template>
+            </select>
+          </div>
+        </div>
+        <div class="grid sm:grid-cols-2 gap-4 mb-2">
+          <div class="bg-ink-800/60 border border-ink-600 rounded-xl p-3">
+            <div class="text-xs uppercase tracking-wide text-gray-400 mb-2">Eje X</div>
+            <div class="flex flex-wrap gap-2">
+              <select x-model="lbX.lado" @change="lbDraw()" class="bg-ink-800 border border-ink-600 rounded-lg px-2 py-1.5 text-sm">
+                <option value="of">Ofensivo</option><option value="def">Defensivo</option>
+              </select>
+              <select x-model="lbX.recurso" @change="lbDraw()" class="bg-ink-800 border border-ink-600 rounded-lg px-2 py-1.5 text-sm">
+                <template x-for="(lbl,k) in lbRecursos" :key="k"><option :value="k" x-text="lbl"></option></template>
+              </select>
+              <select x-model="lbX.metrica" @change="lbDraw()" class="bg-ink-800 border border-ink-600 rounded-lg px-2 py-1.5 text-sm">
+                <template x-for="(lbl,k) in lbMetricas" :key="k"><option :value="k" x-text="lbl"></option></template>
+              </select>
+            </div>
+          </div>
+          <div class="bg-ink-800/60 border border-ink-600 rounded-xl p-3">
+            <div class="text-xs uppercase tracking-wide text-gray-400 mb-2">Eje Y</div>
+            <div class="flex flex-wrap gap-2">
+              <select x-model="lbY.lado" @change="lbDraw()" class="bg-ink-800 border border-ink-600 rounded-lg px-2 py-1.5 text-sm">
+                <option value="of">Ofensivo</option><option value="def">Defensivo</option>
+              </select>
+              <select x-model="lbY.recurso" @change="lbDraw()" class="bg-ink-800 border border-ink-600 rounded-lg px-2 py-1.5 text-sm">
+                <template x-for="(lbl,k) in lbRecursos" :key="k"><option :value="k" x-text="lbl"></option></template>
+              </select>
+              <select x-model="lbY.metrica" @change="lbDraw()" class="bg-ink-800 border border-ink-600 rounded-lg px-2 py-1.5 text-sm">
+                <template x-for="(lbl,k) in lbMetricas" :key="k"><option :value="k" x-text="lbl"></option></template>
+              </select>
+            </div>
+          </div>
+        </div>
+        <p class="text-xs text-red-300 mb-2" x-show="lbError" x-text="lbError"></p>
+        <div id="lbwrap" style="position:relative">
+          <svg id="lbsvg" width="100%" height="460" viewBox="0 0 980 460"></svg>
+          <div id="lbtip" style="position:absolute;display:none;pointer-events:none;background:#1f2937;border:1px solid #4b5563;border-radius:8px;padding:6px 10px;font-size:12px;max-width:260px;z-index:10"></div>
+        </div>
+
+        <div class="border-t border-ink-600 mt-4 pt-4">
+          <h3 class="font-semibold text-sm mb-2">Tablas por equipo</h3>
+          <div class="flex flex-wrap items-end gap-3 mb-3">
+            <div>
+              <label class="block text-xs text-gray-400 mb-1">Liga</label>
+              <select x-model="lbtLeague" @change="lbtLoadTeams()" class="bg-ink-800 border border-ink-600 rounded-lg px-3 py-2 text-sm">
+                <template x-for="l in lbLeagues" :key="l"><option :value="l" x-text="l"></option></template>
+              </select>
+            </div>
+            <div>
+              <label class="block text-xs text-gray-400 mb-1">Equipo</label>
+              <select x-model="lbtEquipo" class="bg-ink-800 border border-ink-600 rounded-lg px-3 py-2 text-sm">
+                <template x-for="e in lbtEquipos" :key="e"><option :value="e" x-text="e"></option></template>
+              </select>
+            </div>
+            <button @click="lbtRun()" class="bg-racing-500 hover:bg-racing-600 text-racing-900 font-semibold px-4 py-2 rounded-lg text-sm">Generar tablas</button>
+          </div>
+          <p class="text-xs text-red-300" x-show="lbtError" x-text="lbtError"></p>
+          <template x-for="lado in ['of','def']" :key="lado">
+            <div x-show="lbtResult" class="mb-4">
+              <div class="text-xs uppercase tracking-wide mb-1" :class="lado==='of' ? 'text-racing-200' : 'text-yellow-200'"
+                   x-text="(lado==='of' ? 'Ofensiva — atacando bloques bajos' : 'Defensiva — su bloque bajo (lo que concede)')"></div>
+              <table class="w-full text-xs">
+                <thead><tr class="text-gray-400 text-left">
+                  <th class="py-1">Recurso</th><th class="text-right">Intentos</th><th class="text-right">% éxito</th>
+                  <th class="text-right">Peligro/jugada (‰)</th><th class="text-right">media liga</th>
+                  <th class="text-right">Tiros/jugada</th><th class="text-right">xG/jugada</th><th class="text-right">Goles</th><th class="text-right">% goles</th>
+                </tr></thead>
+                <tbody>
+                  <template x-for="r in ((lbtResult && lbtResult[lado] && lbtResult[lado].rows) || [])" :key="lado+r.recurso">
+                    <tr class="border-t border-ink-600">
+                      <td class="py-1" x-text="lbRecursos[r.recurso]||r.recurso"></td>
+                      <td class="text-right" x-text="r.n_intentos"></td>
+                      <td class="text-right" x-text="r.pct_exito!=null ? r.pct_exito+'%' : '—'"></td>
+                      <td class="text-right font-semibold" x-text="r.pv_jugada!=null ? r.pv_jugada : '—'"></td>
+                      <td class="text-right text-gray-400" x-text="((lbtResult[lado].liga_media[r.recurso]||{}).pv_jugada != null) ? lbtResult[lado].liga_media[r.recurso].pv_jugada : '—'"></td>
+                      <td class="text-right" x-text="r.tiros_jugada ?? '—'"></td>
+                      <td class="text-right" x-text="r.xg_jugada ?? '—'"></td>
+                      <td class="text-right" x-text="r.goles ?? '—'"></td>
+                      <td class="text-right" x-text="r.pct_goles!=null ? r.pct_goles+'%' : '—'"></td>
+                    </tr>
+                  </template>
+                </tbody>
+              </table>
+            </div>
+          </template>
+        </div>
+      </section>
     </div>
   </template>
 
@@ -619,6 +717,12 @@
       ejX:'elaboracion', ejY:'verticalidad', ejLado:'gen', ejMet:'z', ejData:null, ejError:'', ejLoaded:false,
       ejPostMsg:'', ejPostMsgError:false,
       mlLeagues: [], ejPartidos: {},
+      // Recursos bloque bajo
+      lbLeagues: [], lbRecursos: {}, lbMetricas: {}, lbLeague: '__all__', lbRows: [], lbError: '', lbLoaded: false,
+      lbX: {lado:'of', recurso:'rompe_lineas_ok', metrica:'pv_jugada'},
+      lbY: {lado:'of', recurso:'centro_outswinger', metrica:'pv_jugada'},
+      lbPinned: {},
+      lbtLeague: '', lbtEquipo: '', lbtEquipos: [], lbtResult: null, lbtError: '',
 
       async init() { await this.loadLeagues(); await this.loadSeasons(false); await this.loadTeams(); this._refreshHealth(); },
       async _getJSON(u){ const r=await fetch(u); if(!r.ok) throw new Error((await r.json().catch(()=>({detail:r.statusText}))).detail); return r.json(); },
@@ -649,6 +753,7 @@
           this.tvLoaded = true;
         } catch(e){ this.tvError = 'No se pudieron cargar las opciones: '+e; }
         this.ejInit();
+        this.lbInit();
       },
       tvpPct(z){ const m=this.tvpZmax||3; const c=Math.max(-m,Math.min(m,z)); return 50 + c/m*50; },
       tvpAddVar(){ this.tvpVars.push(''); },
@@ -841,6 +946,105 @@
       },
       _pmErr(m){ this.postMatchMsg=m; this.postMatchMsgError=true; },
 
+      async lbInit(){
+        if (this.lbLoaded) return;
+        try {
+          const o = await this._getJSON('/api/lowblock/options');
+          this.lbLeagues = o.leagues||[]; this.lbRecursos = o.recursos||{}; this.lbMetricas = o.metricas||{};
+          this.lbLoaded = true;
+          await this.$nextTick();
+          this.lbX = {...this.lbX}; this.lbY = {...this.lbY};
+          this.lbtLeague = this.lbLeagues.find(l=>l.toLowerCase().includes('segunda')) || this.lbLeagues[0] || '';
+          await this.lbtLoadTeams();
+          await this.lbLoad();
+        } catch(e){ this.lbError = 'Sin datos de bloque bajo: '+e; }
+      },
+      async lbLoad(){
+        this.lbError='';
+        try {
+          const d = await this._getJSON(`/api/lowblock/data?league=${encodeURIComponent(this.lbLeague)}`);
+          this.lbRows = d.rows||[];
+          await this.$nextTick(); this.lbDraw();
+        } catch(e){ this.lbError = 'Error: '+e; }
+      },
+      lbVal(rowsByKey, eq, ax){
+        const r = rowsByKey[eq+'|'+ax.lado+'|'+ax.recurso];
+        if (!r || r.n_intentos < 10) return null;
+        const v = r[ax.metrica];
+        return (v==null || isNaN(v)) ? null : {v:+v, n:r.n_intentos};
+      },
+      lbDraw(){
+        const svg=document.getElementById('lbsvg'), tip=document.getElementById('lbtip'), wrap=document.getElementById('lbwrap');
+        if (!svg || !this.lbRows.length) return;
+        svg.innerHTML='';
+        const byKey={};
+        for (const r of this.lbRows) byKey[r.equipo+'|'+r.lado+'|'+r.recurso]=r;
+        const equipos=[...new Set(this.lbRows.map(r=>r.equipo))];
+        const pts=[];
+        for (const eq of equipos){
+          const vx=this.lbVal(byKey, eq, this.lbX), vy=this.lbVal(byKey, eq, this.lbY);
+          if (vx && vy) pts.push({eq, x:vx.v, y:vy.v, nx:vx.n, ny:vy.n});
+        }
+        if (!pts.length){ this.lbError='Sin equipos con ≥10 intentos en ambos ejes.'; return; }
+        this.lbError='';
+        const NS='http://www.w3.org/2000/svg', W=980, H=460, M={l:64,r:20,t:16,b:48};
+        const xs=pts.map(p=>p.x), ys=pts.map(p=>p.y);
+        const pad=(a,b)=>{const d=(b-a)||1; return [a-d*0.08, b+d*0.08];};
+        const [x0,x1]=pad(Math.min(...xs),Math.max(...xs)), [y0,y1]=pad(Math.min(...ys),Math.max(...ys));
+        const X=v=>M.l+(v-x0)/(x1-x0)*(W-M.l-M.r), Y=v=>H-M.b-(v-y0)/(y1-y0)*(H-M.t-M.b);
+        const el=(tag,attrs)=>{const e=document.createElementNS(NS,tag);for(const k in attrs)e.setAttribute(k,attrs[k]);svg.appendChild(e);return e;};
+        const fmt=v=>Math.abs(v)>=100?v.toFixed(0):(Math.abs(v)>=1?v.toFixed(1):v.toFixed(2));
+        for (let i=0;i<=4;i++){
+          const vx=x0+(x1-x0)*i/4, vy=y0+(y1-y0)*i/4;
+          el('line',{x1:X(vx),y1:M.t,x2:X(vx),y2:H-M.b,stroke:'#1f2937'});
+          el('line',{x1:M.l,y1:Y(vy),x2:W-M.r,y2:Y(vy),stroke:'#1f2937'});
+          const tx=el('text',{x:X(vx),y:H-M.b+16,'font-size':'11','text-anchor':'middle',fill:'#6b7280'}); tx.textContent=fmt(vx);
+          const ty=el('text',{x:M.l-8,y:Y(vy)+4,'font-size':'11','text-anchor':'end',fill:'#6b7280'}); ty.textContent=fmt(vy);
+        }
+        const lx=el('text',{x:W-M.r,y:H-M.b+34,'font-size':'12','text-anchor':'end',fill:'#9ca3af'});
+        lx.textContent=(this.lbX.lado==='of'?'OF · ':'DEF · ')+(this.lbRecursos[this.lbX.recurso]||'')+' — '+(this.lbMetricas[this.lbX.metrica]||'');
+        const ly=el('text',{x:M.l,y:M.t-4,'font-size':'12',fill:'#9ca3af'});
+        ly.textContent='↑ '+(this.lbY.lado==='of'?'OF · ':'DEF · ')+(this.lbRecursos[this.lbY.recurso]||'')+' — '+(this.lbMetricas[this.lbY.metrica]||'');
+        const self=this;
+        pts.forEach(pt=>{
+          const racing = pt.eq==='Racing de Santander';
+          const pinned = !!self.lbPinned[pt.eq];
+          const c=el('circle',{cx:X(pt.x),cy:Y(pt.y),r:racing?8:6,
+            fill:racing?'#f59e0b':(pinned?'#4ade80':'#9ca3af'),'fill-opacity':racing||pinned?1:0.65,
+            stroke:'#111827','stroke-width':1});
+          c.style.cursor='pointer';
+          if (racing || pinned){
+            const l=el('text',{x:X(pt.x)+10,y:Y(pt.y)+4,'font-size':'11','font-weight':'600',fill:'#e5e7eb'});
+            l.textContent=pt.eq;
+          }
+          c.addEventListener('mousemove',ev=>{
+            const rct=wrap.getBoundingClientRect();
+            tip.style.display='block';
+            tip.style.left=Math.min(ev.clientX-rct.left+14,rct.width-270)+'px';
+            tip.style.top=(ev.clientY-rct.top+10)+'px';
+            tip.innerHTML='<b>'+pt.eq+'</b><br>X: '+fmt(pt.x)+' ('+pt.nx+' int.)<br>Y: '+fmt(pt.y)+' ('+pt.ny+' int.)';
+            c.setAttribute('r',racing?10:8);
+          });
+          c.addEventListener('mouseleave',()=>{ tip.style.display='none'; c.setAttribute('r',racing?8:6); });
+          c.addEventListener('click',()=>{ self.lbPinned[pt.eq]=!self.lbPinned[pt.eq]; self.lbDraw(); });
+        });
+      },
+      async lbtLoadTeams(){
+        if (!this.lbtLeague){ this.lbtEquipos=[]; return; }
+        try {
+          const d = await this._getJSON(`/api/lowblock/data?league=${encodeURIComponent(this.lbtLeague)}`);
+          this.lbtEquipos = [...new Set((d.rows||[]).map(r=>r.equipo))].sort();
+          if (!this.lbtEquipos.includes(this.lbtEquipo))
+            this.lbtEquipo = this.lbtEquipos.includes('Racing de Santander') ? 'Racing de Santander' : (this.lbtEquipos[0]||'');
+        } catch(e){ this.lbtEquipos=[]; }
+      },
+      async lbtRun(){
+        this.lbtError=''; this.lbtResult=null;
+        if (!this.lbtLeague || !this.lbtEquipo){ this.lbtError='Elegí liga y equipo.'; return; }
+        try {
+          this.lbtResult = await this._getJSON(`/api/lowblock/team?league=${encodeURIComponent(this.lbtLeague)}&equipo=${encodeURIComponent(this.lbtEquipo)}`);
+        } catch(e){ this.lbtError = 'Error: '+e; }
+      },
       async ejRunPost(){
         this.ejPostMsg=''; this.ejPostMsgError=false;
         if (Object.keys(this.ejPartidos).length && !this.ejPartidos[this.league]){ this.ejPostMsg='Esta liga no tiene artefactos de ejes.'; this.ejPostMsgError=true; return; }