Deploy: modelo de ataque matchup GNN + artifacts bundleados (LFS)

Sobre la historia del Space (preserva login/proxy fixes). Agrega:
- train_attack_matchup_gnn.py (modelo de producción nuevo) + integración en la app.
- Artifacts bundleados en vendor/data/modeling vía git-LFS (subset 10MB + bundles),
para servir sin Azure.
- vendor_env apunta al bundle nuevo; .gitignore actualizado; tests del modelo.

Activar en el Space con el secret RR_ENABLE_NN_PREDICTIONS=1.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

.gitignore

@@ -21,10 +21,14 @@ cache/
 # Vendor: versionar scripts y datasets chicos, ignorar artifacts pesados/symlinks
 vendor/reports/
 vendor/data/*.parquet
-vendor/data/modeling/
+vendor/data/modeling/*
 vendor/data/processed/
 !vendor/data/team_ids_ssd.json
 !vendor/data/matches.csv
 # CORE artifacts bundled en el repo para no requerir upload a Azure
 !vendor/data/match_features.parquet
 !vendor/data/team_match_zone_features.parquet
+# Modelo de ataque bundleado (subset recortado ~10 MB + bundles): sin Azure
+!vendor/data/modeling/attack_prediction_dataset.parquet
+!vendor/data/modeling/attack_matchup_gnn_bundle.pt
+!vendor/data/modeling/pv_distribution_gnn_bundle.pt

README.md

@@ -77,6 +77,58 @@ python ../scripts/upload_preprocessed_labeled.py \
     --remote-name preprocessed_SSD_25-26_etiquetado_modelo.csv
 ```
 
+## Modelo de predicción de ataque (matchup GNN)
+
+El reporte previo / head-to-head puede mostrar la **distribución de ataque
+esperada por zona** (local y visitante) según un modelo de red neuronal. El
+modelo de producción es el **matchup GNN** (`train_attack_matchup_gnn.py`), que
+reemplaza al viejo `attack_distribution_gnn`: selecciona ~200 features de alta
+señal (en vez de ~950, atacando el sobreajuste), agrega una interacción bilineal
+explícita atacante × defensor por zona, y aprende un *delta* sobre el promedio
+del equipo. En test le gana al baseline "promedio de temporada" de forma
+estadísticamente robusta (IC bootstrap del 95% que excluye el cero).
+
+Las predicciones están **apagadas por defecto** (MVP). Hay dos formas de servir
+los artifacts del modelo; en ambas se activa con el secret
+`RR_ENABLE_NN_PREDICTIONS=1` en el Space.
+
+**Opción A — bundlear en el repo (sin Azure, recomendada).** El datastore usa los
+artifacts reales de `vendor/data/modeling/` antes de ir a Azure. Como la app
+recalcula los rolling al vuelo desde las columnas crudas, el dataset se recorta de
+**71 MB → ~10 MB** sin cambiar ninguna predicción:
+
+```bash
+python ../scripts/build_app_modeling_subset.py --copy-bundles
+git add racing-reports/vendor/data/modeling/{attack_prediction_dataset.parquet,attack_matchup_gnn_bundle.pt,pv_distribution_gnn_bundle.pt}
+git commit -m "bundle modelo de ataque"   # parquet ~10 MB: usar git-lfs si tu remoto lo pide
+```
+
+En el próximo arranque la app usa esos archivos directamente, sin tocar Azure.
+
+**Opción B — subir a Azure.** Si preferís no commitear artifacts:
+
+```bash
+RR_ENABLE_NN_PREDICTIONS=1 python scripts/upload_report_artifacts.py --source /ruta/Racing/data --overwrite
+```
+
+En el cold start la app descarga `modeling/attack_matchup_gnn_bundle.pt` (y el de
+PV + el dataset) desde Azure.
+
+## Actualizar la data y el modelo (pipeline)
+
+Un solo orquestador idempotente encadena todo el ciclo, desde los eventos crudos
+hasta el bundle publicado que consume la app:
+
+```bash
+python ../scripts/run_attack_model_pipeline.py            # todo (saltea lo que ya está al día)
+python ../scripts/run_attack_model_pipeline.py --list     # ver los stages
+python ../scripts/run_attack_model_pipeline.py --only train --train-args "--top-k 200 --seeds 3"
+python ../scripts/run_attack_model_pipeline.py --from dataset --force
+```
+
+Stages: `events` → `zone_features` → `dataset` → `rolling` → `train` → `publish`.
+Los stages `events` y `publish` requieren credenciales de Azure.
+
 ## Salida
 
 ```text

src/racing_reports/vendor_env.py

@@ -41,7 +41,9 @@ ARTIFACT_RELATIVE_PATHS_CORE = [
 ]
 ARTIFACT_RELATIVE_PATHS_NN = [
     "modeling/attack_prediction_dataset.parquet",
-    "modeling/attack_distribution_gnn_bundle.pt",
+    # Modelo de ataque rediseñado (matchup GNN): reemplaza al viejo
+    # attack_distribution_gnn_bundle.pt como modelo de producción de la app.
+    "modeling/attack_matchup_gnn_bundle.pt",
     "modeling/pv_distribution_gnn_bundle.pt",
 ]
 

tests/conftest.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+import pandas as pd
+import pytest
+
+from racing_reports.config import Settings
+from racing_reports.datastore import DataStore
+from racing_reports.utils import slugify
+
+
+@pytest.fixture()
+def sample_store(tmp_path: Path) -> DataStore:
+    settings = Settings(cache_dir=tmp_path / "cache", output_dir=tmp_path / "outputs")
+    store = DataStore(settings=settings)
+    league = "Spanish Segunda Division"
+    season = "25-26"
+    path = store.preprocessed_path(league, season)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    rows = []
+    for match_id, home, away, home_id, away_id, date in [
+        ("m1", "Racing de Santander", "Almería", "racing", "almeria", "2026-04-12"),
+        ("m2", "Huesca", "Racing de Santander", "huesca", "racing", "2026-04-19"),
+    ]:
+        for sequence_id, phase in [
+            ("s1", "Build Up against Low Block"),
+            ("s2", "Build Up against Medium Block"),
+            ("s3", "Build Up against High Block"),
+        ]:
+            for team, rival, team_id in [(home, away, home_id), (away, home, away_id)]:
+                rows.append(
+                    {
+                        "matchId": match_id,
+                        "fecha": date,
+                        "home_team_id": home_id,
+                        "away_team_id": away_id,
+                        "teamId": team_id,
+                        "TeamName": team,
+                        "TeamRival": rival,
+                        "Competencia": league,
+                        "Temporada": season,
+                        "sequenceId": sequence_id,
+                        "phaseLabel": phase,
+                        "event_name": "Goal" if sequence_id == "s1" and team == home else "Pass",
+                        "x": 88,
+                        "y": 50,
+                        "xG": 0.08 if sequence_id == "s1" else 0,
+                        "pvAdded": 0.03,
+                        "goal_int": 1 if sequence_id == "s1" and team == home else 0,
+                    }
+                )
+    pd.DataFrame(rows).to_csv(path, index=False)
+    return store

tests/test_api.py

@@ -0,0 +1,142 @@
+from __future__ import annotations
+
+import time
+from pathlib import Path
+
+from fastapi.testclient import TestClient
+
+from racing_reports.api import routes_meta, routes_reports
+from racing_reports.reports.catalogs import (
+    BLOCK_ZSCORE_FIGURES,
+    PRE_MATCH_FIGURES,
+    PRE_MATCH_TABLES,
+)
+from racing_reports.web import app as web_app
+
+
+def test_health_endpoint():
+    client = TestClient(web_app.app)
+    resp = client.get("/api/health")
+    assert resp.status_code == 200
+    data = resp.json()
+    assert data["ok"] is True
+    assert data["nn_enabled"] is False  # MVP default
+
+
+def test_leagues_and_seasons():
+    client = TestClient(web_app.app)
+    leagues = client.get("/api/leagues").json()
+    assert "Spanish Segunda Division" in leagues
+
+    seasons = client.get("/api/seasons", params={"league": "Spanish Segunda Division"}).json()
+    assert "25-26" in seasons
+
+    teams = client.get(
+        "/api/teams", params={"league": "Spanish Segunda Division", "season": "25-26"}
+    ).json()
+    assert "Racing de Santander" in teams
+
+
+def test_catalog_pre_match():
+    client = TestClient(web_app.app)
+    resp = client.get("/api/reports/pre_match/catalog")
+    assert resp.status_code == 200
+    data = resp.json()
+    assert data["report_type"] == "pre_match"
+    assert [f["name"] for f in data["figures"]] == [s.name for s in PRE_MATCH_FIGURES]
+    assert [t["name"] for t in data["tables"]] == [s.name for s in PRE_MATCH_TABLES]
+    # las 2 figuras NN están marcadas
+    nn_figs = [f for f in data["figures"] if f["requires_nn"]]
+    assert len(nn_figs) == 2
+
+
+def test_catalog_block_zscore():
+    client = TestClient(web_app.app)
+    resp = client.get("/api/reports/block_zscore/catalog")
+    assert resp.status_code == 200
+    data = resp.json()
+    assert [f["name"] for f in data["figures"]] == [s.name for s in BLOCK_ZSCORE_FIGURES]
+    assert data["tables"] == []
+
+
+def test_catalog_unknown_returns_404():
+    client = TestClient(web_app.app)
+    resp = client.get("/api/reports/unknown/catalog")
+    assert resp.status_code == 404
+
+
+def test_post_match_run_returns_503_in_mvp():
+    client = TestClient(web_app.app)
+    resp = client.post(
+        "/api/reports/post_match/run",
+        json={"league": "X", "season": "Y", "team_a": "A", "team_b": "B"},
+    )
+    assert resp.status_code == 503
+
+
+def test_run_requires_teams():
+    client = TestClient(web_app.app)
+    resp = client.post(
+        "/api/reports/pre_match/run",
+        json={"league": "X", "season": "Y"},
+    )
+    assert resp.status_code == 400
+
+
+def test_block_zscore_e2e(monkeypatch, sample_store, tmp_path: Path):
+    """End-to-end: lanza job de bloques contra el sample_store, hace polling,
+    descarga una figura PNG individual y el ZIP completo."""
+    # Reemplazamos el ReportRunner() que instancia routes_reports por uno
+    # apuntado al sample_store (sin Azure).
+    from racing_reports.runner import ReportRunner
+
+    monkeypatch.setattr(
+        routes_reports,
+        "ReportRunner",
+        lambda: ReportRunner(sample_store, settings=sample_store.settings),
+    )
+    # Las settings del sample_store apuntan a un output_dir bajo tmp_path; la
+    # whitelist de _safe_output_path usa DEFAULT_SETTINGS.output_dir, que es
+    # distinto. Para el test parchamos el guard.
+    from racing_reports.api import routes_jobs
+
+    monkeypatch.setattr(
+        routes_jobs, "_safe_output_path", lambda p: Path(p)
+    )
+
+    client = TestClient(web_app.app)
+    resp = client.post(
+        "/api/reports/block_zscore/run",
+        json={
+            "league": "Spanish Segunda Division",
+            "season": "25-26",
+            "team_a": "Racing de Santander",
+            "team_b": "Huesca",
+        },
+    )
+    assert resp.status_code == 202
+    job_id = resp.json()["job_id"]
+
+    # Polling
+    for _ in range(100):
+        st = client.get(f"/api/jobs/{job_id}").json()
+        if st["status"] in ("done", "error"):
+            break
+        time.sleep(0.1)
+    assert st["status"] == "done", st.get("error")
+
+    bundle = st["bundles"]["block_zscore"]
+    assert len(bundle["figures"]) == len(BLOCK_ZSCORE_FIGURES)
+    first_fig = bundle["figures"][0]
+    assert first_fig["name"] == "block_team_a_attack"
+
+    # Descargar PNG individual
+    png_resp = client.get(first_fig["png_url"])
+    assert png_resp.status_code == 200
+    assert png_resp.headers["content-type"] == "image/png"
+    assert len(png_resp.content) > 1000  # algo razonable
+
+    # ZIP completo
+    zip_resp = client.get(f"/api/jobs/{job_id}/zip", params={"report": "block_zscore"})
+    assert zip_resp.status_code == 200
+    assert zip_resp.headers["content-type"] == "application/zip"

tests/test_attack_matchup_model.py

@@ -0,0 +1,68 @@
+"""Verifica el contrato del modelo de ataque rediseñado (matchup GNN) tal como lo
+consume la app: importa el módulo vendorizado, carga el bundle y predice una
+distribución válida de ataque sobre las 10 zonas (suma ~1).
+
+Se saltea si los artifacts NN no están disponibles localmente (cold CI sin Azure).
+"""
+
+from __future__ import annotations
+
+import numpy as np
+import pytest
+
+matplotlib = pytest.importorskip("matplotlib")
+matplotlib.use("Agg")
+torch = pytest.importorskip("torch")
+
+from racing_reports import vendor_env  # noqa: E402
+
+ATTACK_BUNDLE = vendor_env.DATA_DIR / "modeling" / "attack_matchup_gnn_bundle.pt"
+MODELING_DATASET = vendor_env.DATA_DIR / "modeling" / "attack_prediction_dataset.parquet"
+
+pytestmark = pytest.mark.skipif(
+    not (ATTACK_BUNDLE.exists() and MODELING_DATASET.exists()),
+    reason="Artifacts NN (bundle/dataset) no disponibles localmente.",
+)
+
+
+def test_app_imports_matchup_model() -> None:
+    pro = vendor_env.import_script("build_head_to_head_report_pro")
+    assert pro.attack_model_mod.__name__ == "train_attack_matchup_gnn"
+    assert pro.ATTACK_MODEL_PATH.name == "attack_matchup_gnn_bundle.pt"
+
+
+def test_bundle_loads_without_key_mismatch() -> None:
+    attack_mod = vendor_env.import_script("train_attack_matchup_gnn")
+    bundle = torch.load(ATTACK_BUNDLE, map_location="cpu", weights_only=False)
+    global_dim = len(bundle["global_bundle"]["global_feature_columns"])
+    node_dim = len(bundle["node_bundle"]["means"][0])
+    model = attack_mod.ResidualAttackGNN(node_dim=node_dim, global_dim=global_dim)
+    missing, unexpected = model.load_state_dict(bundle["model_state_dict"], strict=False)
+    assert not missing, f"faltan claves: {missing}"
+    assert not unexpected, f"claves inesperadas: {unexpected}"
+    assert bundle["zone_order"] == attack_mod.ZONE_ORDER
+
+
+def test_prediction_is_a_valid_distribution() -> None:
+    pro = vendor_env.import_script("build_head_to_head_report_pro")
+    df_model = pro._load_modeling_dataset()
+    racing = "bzkwzatvwahmbzok1ymm5vqa1"
+    sub = df_model[df_model["teamId"] == racing]
+    if sub.empty:
+        pytest.skip("Racing no presente en el dataset local.")
+    row = sub.iloc[-1]
+    opp_id = (
+        row["opponent_team_id"]
+        if "opponent_team_id" in sub.columns and row.get("opponent_team_id")
+        else df_model[df_model["team_name"] == row["opponent_name"]]["teamId"].iloc[-1]
+    )
+    pred = pro._predict_single_team_future(
+        df_model, racing, opp_id, "Racing de Santander", str(row["opponent_name"]),
+        row["league"], row["season"], is_home=True,
+    )
+    zones = list(pred.attack.keys())
+    assert len(zones) == 10
+    total = sum(pred.attack.values())
+    assert total == pytest.approx(1.0, abs=1e-4), f"la distribución no suma 1: {total}"
+    assert all(0.0 <= v <= 1.0 for v in pred.attack.values())
+    assert len(pred.pv) == 10

tests/test_block_zscore.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from racing_reports.reports import block_zscore
+from racing_reports.reports.bundle import ReportBundle
+from racing_reports.reports.catalogs import BLOCK_ZSCORE_FIGURES
+
+
+def test_block_zscore_runs_with_phase_label_fallback(sample_store, tmp_path: Path):
+    """El preprocessed base de Azure sólo trae phaseLabel; build() tiene que
+    derivar w_high/medium/low + label_after_rules a partir de ahí."""
+    pre = sample_store.preprocessed_path("Spanish Segunda Division", "25-26")
+    out = tmp_path / "block.html"
+
+    bundle = block_zscore.generate(
+        out_path=out,
+        labeled_csv=pre,
+        team_a="Racing de Santander",
+        team_b="Huesca",
+    )
+
+    assert isinstance(bundle, ReportBundle)
+    assert bundle.report_type == "block_zscore"
+    assert out.exists()
+    html = out.read_text(encoding="utf-8")
+    assert "Z-score" in html
+    assert "Racing de Santander" in html
+    assert "Huesca" in html
+
+
+def test_block_zscore_bundle_has_canonical_figures(sample_store, tmp_path: Path):
+    pre = sample_store.preprocessed_path("Spanish Segunda Division", "25-26")
+    out = tmp_path / "block.html"
+    bundle = block_zscore.generate(
+        out_path=out,
+        labeled_csv=pre,
+        team_a="Racing de Santander",
+        team_b="Huesca",
+    )
+    assert [f.name for f in bundle.figures] == [s.name for s in BLOCK_ZSCORE_FIGURES]
+    for fig in bundle.figures:
+        assert fig.png_path.exists()
+        assert fig.svg_path is not None and fig.svg_path.exists()
+
+
+def test_block_zscore_with_date_filter(sample_store, tmp_path: Path):
+    pre = sample_store.preprocessed_path("Spanish Segunda Division", "25-26")
+    out = tmp_path / "block_filtered.html"
+    block_zscore.generate(
+        out_path=out,
+        labeled_csv=pre,
+        team_a="Racing de Santander",
+        team_b="Huesca",
+        date_from="2026-04-15",
+    )
+    assert out.exists()
+    assert "desde 15/04/2026" in out.read_text(encoding="utf-8")
+
+
+def test_require_labeled_falls_back_to_base(sample_store):
+    """Si Azure no tiene el labeled, require_labeled devuelve el base."""
+    path = sample_store.require_labeled("Spanish Segunda Division", "25-26")
+    assert path == sample_store.preprocessed_path("Spanish Segunda Division", "25-26")

tests/test_match_index.py

@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+from racing_reports.match_index import MatchIndex
+
+
+def test_build_match_index(sample_store):
+    idx = MatchIndex(sample_store).build("Spanish Segunda Division", "25-26")
+    assert len(idx) == 2
+    first = idx[idx["match_id"] == "m1"].iloc[0]
+    assert first["home_team"] == "Racing de Santander"
+    assert first["away_team"] == "Almería"

tests/test_runner.py

@@ -0,0 +1,62 @@
+from __future__ import annotations
+
+import json
+
+from racing_reports import runner as runner_mod
+from racing_reports.models import ReportRequest
+from racing_reports.runner import ReportRunner
+
+
+def _stub_adapters(monkeypatch):
+    """Evita correr los scripts pesados reales (torch); sólo orquestación."""
+    calls: list[str] = []
+
+    def fake_pre(*, out_path, **_):
+        out_path.write_text("pre", encoding="utf-8")
+        calls.append("pre_match")
+        return out_path
+
+    def fake_post(*, out_path, **_):
+        out_path.write_text("post", encoding="utf-8")
+        calls.append("post_match")
+        return out_path
+
+    def fake_block(*, out_path, **_):
+        out_path.write_text("block", encoding="utf-8")
+        calls.append("block_zscore")
+        return out_path
+
+    monkeypatch.setattr(runner_mod.pre_match, "generate", fake_pre)
+    monkeypatch.setattr(runner_mod.post_match, "generate", fake_post)
+    monkeypatch.setattr(runner_mod.block_zscore, "generate", fake_block)
+    return calls
+
+
+def test_post_match_runs_pre_first_and_writes_manifest(monkeypatch, sample_store):
+    calls = _stub_adapters(monkeypatch)
+    monkeypatch.setattr(
+        sample_store, "prepare_vendor", lambda *a, **k: {"matches_csv": "x"}
+    )
+    monkeypatch.setattr(
+        sample_store,
+        "require_labeled",
+        lambda *a, **k: sample_store.preprocessed_path(
+            "Spanish Segunda Division", "25-26"
+        ),
+    )
+
+    request = ReportRequest(
+        league="Spanish Segunda Division",
+        season="25-26",
+        home_team="",
+        away_team="",
+        report_types=["post_match"],
+        match_id="m1",
+    )
+    result = ReportRunner(sample_store, settings=sample_store.settings).run(request)
+
+    assert calls == ["pre_match", "post_match"]  # pre se antepone solo
+    assert set(result.html_paths) == {"pre_match", "post_match"}
+    manifest = json.loads(result.manifest_path.read_text(encoding="utf-8"))
+    assert manifest["report_types_run"] == ["pre_match", "post_match"]
+    assert manifest["request"]["match_id"] == "m1"

tests/test_web_app.py

@@ -0,0 +1,106 @@
+from __future__ import annotations
+
+import time
+from pathlib import Path
+
+from fastapi.testclient import TestClient
+
+from racing_reports.config import Settings
+from racing_reports.models import ReportResult
+from racing_reports.web import app as web_app
+
+
+def test_home_is_spa_with_teams_and_report_cards():
+    """El nuevo home es un SPA que consume /api/. Verificamos que el HTML
+    contiene los selects de equipos y las cards de los reportes."""
+    client = TestClient(web_app.app)
+    resp = client.get("/")
+    assert resp.status_code == 200
+    assert "Racing de Santander" in resp.text  # desde vendor/data/team_ids_ssd.json
+    assert "Reporte previo" in resp.text
+    assert "Bloques" in resp.text
+    assert "post-partido" in resp.text  # card deshabilitada
+    assert "/api/reports/" in resp.text  # alpine consume la API
+
+
+def test_legacy_home_still_works():
+    """La UI vieja sigue accesible vía /legacy para retrocompatibilidad."""
+    client = TestClient(web_app.app)
+    resp = client.get("/legacy")
+    assert resp.status_code == 200
+    assert "Reporte previo / Bloques" in resp.text
+    assert "Reporte post-partido" in resp.text
+
+
+def test_legacy_routes_require_password_when_set(monkeypatch, tmp_path):
+    """Si ACCESS_PASSWORD está seteada, las rutas /view, /download, /status,
+    /legacy, / NO deben servir contenido sin cookie válida."""
+    # Settings con password forzada + DEFAULT_SETTINGS también, porque ambos
+    # se usan en el app code.
+    new_settings = Settings(
+        cache_dir=tmp_path / "cache",
+        output_dir=tmp_path / "outputs",
+        access_password="secret-1234",
+    )
+    monkeypatch.setattr(web_app, "DEFAULT_SETTINGS", new_settings)
+    from racing_reports import config as cfg
+    monkeypatch.setattr(cfg, "DEFAULT_SETTINGS", new_settings)
+    from racing_reports.api import deps
+    monkeypatch.setattr(deps, "DEFAULT_SETTINGS", new_settings)
+
+    client = TestClient(web_app.app)
+
+    # / → redirect a /login
+    assert client.get("/", follow_redirects=False).status_code in (303, 307)
+    # /legacy → redirect a /login
+    assert client.get("/legacy", follow_redirects=False).status_code in (303, 307)
+    # /view sin cookie → 401
+    assert client.get("/view", params={"path": str(tmp_path / "x.html")}).status_code == 401
+    # /download sin cookie → 401
+    assert client.get("/download", params={"path": str(tmp_path / "x.html")}).status_code == 401
+    # /status/<id> sin cookie → 401
+    assert client.get("/status/deadbeef").status_code == 401
+    # API también
+    assert client.get("/api/leagues").status_code == 401
+    # /api/health sigue siendo público (no expone data)
+    assert client.get("/api/health").status_code == 200
+
+
+def test_generate_enqueues_job_and_reports_links(monkeypatch, tmp_path: Path):
+    out = tmp_path / "pre_match.html"
+    out.write_text("<html>ok</html>", encoding="utf-8")
+    manifest = tmp_path / "manifest.json"
+    manifest.write_text("{}", encoding="utf-8")
+
+    class FakeRunner:
+        def run(self, request):
+            return ReportResult(
+                output_dir=tmp_path,
+                html_paths={"pre_match": out},
+                manifest_path=manifest,
+            )
+
+    monkeypatch.setattr(web_app, "ReportRunner", lambda *a, **k: FakeRunner())
+    client = TestClient(web_app.app)
+
+    resp = client.post(
+        "/generate",
+        data={
+            "flow": "pre",
+            "team_a": "Racing de Santander",
+            "team_b": "Huesca",
+            "pre_match": "on",
+        },
+        follow_redirects=False,
+    )
+    assert resp.status_code == 303
+    status_url = resp.headers["location"]
+
+    body = ""
+    for _ in range(50):
+        body = client.get(status_url).text
+        if "Volver al inicio" in body or "problema" in body:
+            break
+        time.sleep(0.05)
+    assert "Reporte previo (head-to-head)" in body
+    assert "/view?path=" in body

tests/test_yaml.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from racing_reports.runner import request_from_yaml
+
+
+def test_request_from_yaml(tmp_path: Path):
+    cfg = tmp_path / "request.yml"
+    cfg.write_text(
+        """
+league: Spanish Segunda Division
+season: 25-26
+match_id: m1
+home_team: Racing de Santander
+away_team: Almería
+report_types: [pre_match, block_zscore]
+settings:
+  block_zscore:
+    date_from: 2026-03-17
+""",
+        encoding="utf-8",
+    )
+    request = request_from_yaml(cfg)
+    assert request.report_types == ["pre_match", "block_zscore"]
+    assert request.settings["block_zscore"]["date_from"] == "2026-03-17"

vendor/data/modeling/attack_matchup_gnn_bundle.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:dcb1309239fc7a438e94385d8e94aedd6a3f53a33ff24cf38c00d8bdaad8d3de
+size 583663

vendor/data/modeling/attack_prediction_dataset.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:885726cff0233d7ab8a2c6fea06d4d66c7707bf60c1b40b7a6560874e6904164
+size 10009594

vendor/data/modeling/pv_distribution_gnn_bundle.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6e65acabebf66b9ba96b122c60d3ec3c747750485f1f4af73a16d7adca49111a
+size 1430997

vendor/scripts/build_head_to_head_report_pro.py

@@ -24,14 +24,14 @@ REPORTS_DIR.mkdir(parents=True, exist_ok=True)
 MATCH_FEATURES_PATH = PROJECT_ROOT / "data" / "match_features.parquet"
 EVENTS_ROOT = PROJECT_ROOT / "data" / "processed" / "events_parquet"
 MODELING_DATASET_PATH = PROJECT_ROOT / "data" / "modeling" / "attack_prediction_dataset.parquet"
-ATTACK_MODEL_PATH = PROJECT_ROOT / "data" / "modeling" / "attack_distribution_gnn_bundle.pt"
+ATTACK_MODEL_PATH = PROJECT_ROOT / "data" / "modeling" / "attack_matchup_gnn_bundle.pt"
 PV_MODEL_PATH = PROJECT_ROOT / "data" / "modeling" / "pv_distribution_gnn_bundle.pt"
 
 if str(SCRIPT_DIR) not in sys.path:
     sys.path.insert(0, str(SCRIPT_DIR))
 
 import build_head_to_head_report as base  # noqa: E402
-import experiment_attack_distribution_gnn as attack_model_mod  # noqa: E402
+import train_attack_matchup_gnn as attack_model_mod  # noqa: E402
 import experiment_pv_distribution_gnn as pv_model_mod  # noqa: E402
 import train_attack_prediction_ffn as train_model_mod  # noqa: E402
 

vendor/scripts/train_attack_matchup_gnn.py

@@ -0,0 +1,526 @@
+"""Rediseño del modelo de predicción de distribución de ataque por zona.
+
+Mejoras vs ``experiment_attack_distribution_gnn`` (ResidualAttackGNN):
+
+1. **Selección de features**: de ~950 features globales (muchas redundantes de la
+   familia ``mf`` y rolling) se queda con un subconjunto de alta señal (varianza +
+   NaN + poda por correlación + top-K por correlación con los targets). Esto ataca
+   el sobreajuste (¡~950 features para ~9800 filas!) que hacía que el modelo apenas
+   le ganara al baseline de promedio de temporada.
+2. **Interacción atacante × defensor explícita**: una rama bilineal por zona que
+   cruza la proyección "ofensiva" con la "defensiva" de los node features (que ya
+   incluyen ataque/PV propios + concedidos + del rival). Esto modela el *matchup*,
+   no solo el promedio del equipo.
+3. **Regularización real**: weight decay fuerte, dropout calibrado, early stopping y
+   promedio multi-seed para reportar estabilidad (el bundle usa la mejor seed).
+4. **Evaluación robusta**: métricas vs dos baselines (temporada y últimos 8) con
+   **intervalos bootstrap** sobre el delta modelo-baseline, y foco en Racing.
+
+El módulo preserva el contrato que consume la app
+(``build_head_to_head_report_pro.py``): expone ``ZONE_ORDER``, ``ADJ_MATRIX``,
+``_build_feature_matrices(df, attack_targets)`` y una clase ``ResidualAttackGNN``
+con la firma ``forward(node_x, global_x, baseline_long, baseline_short, adj)`` y un
+bundle con ``model_state_dict`` / ``global_bundle`` / ``node_bundle``. La app solo
+necesita importar este módulo en vez del viejo y apuntar al bundle nuevo.
+"""
+
+from __future__ import annotations
+
+from io import BytesIO
+from pathlib import Path
+import argparse
+import base64
+import html
+import json
+import random
+import sys
+
+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+import torch
+from torch import nn
+
+SCRIPT_DIR = Path(__file__).resolve().parent
+PROJECT_ROOT = SCRIPT_DIR.parent
+MODEL_DIR = PROJECT_ROOT / "data" / "modeling"
+REPORTS_DIR = PROJECT_ROOT / "reports"
+REPORT_PATH = REPORTS_DIR / "attack_matchup_gnn_report.html"
+JSON_PATH = MODEL_DIR / "attack_matchup_gnn_metrics.json"
+MODEL_PATH = MODEL_DIR / "attack_matchup_gnn_bundle.pt"
+PRED_PATH = MODEL_DIR / "attack_matchup_gnn_test_predictions.parquet"
+
+if str(SCRIPT_DIR) not in sys.path:
+    sys.path.insert(0, str(SCRIPT_DIR))
+
+import train_attack_prediction_ffn as base  # noqa: E402
+import experiment_attack_distribution_gnn as gnn_base  # noqa: E402
+
+# --- Contrato re-exportado para la app (mismos nombres que el modelo viejo) ---
+ZONE_ORDER = gnn_base.ZONE_ORDER
+PRETTY_ZONE = gnn_base.PRETTY_ZONE
+NODE_FEATURE_PREFIXES = gnn_base.NODE_FEATURE_PREFIXES
+ADJ_MATRIX = gnn_base.ADJ_MATRIX
+EDGE_INDEX = gnn_base.EDGE_INDEX
+_build_feature_matrices = gnn_base._build_feature_matrices
+SplitData = gnn_base.SplitData
+
+# --- Hiperparámetros ---
+RANDOM_SEED = 42
+BATCH_SIZE = 256
+MAX_EPOCHS = 280
+PATIENCE = 34
+LEARNING_RATE = 4e-4
+WEIGHT_DECAY = 3e-4          # mucho más fuerte que el viejo (1e-5)
+GLOBAL_DROPOUT = 0.15
+GRAPH_DROPOUT = 0.10
+INTERACTION_DIM = 24
+DEFAULT_N_SEEDS = 3
+DEFAULT_TOP_K = 200          # features globales a conservar tras la poda
+VAR_EPS = 1e-9
+NAN_FRAC_MAX = 0.60
+CORR_PRUNE_THRESHOLD = 0.97
+SMOOTH_LAMBDA = gnn_base.SMOOTH_LAMBDA
+GATE_ENTROPY_LAMBDA = gnn_base.GATE_ENTROPY_LAMBDA
+BOOTSTRAP_SAMPLES = 1000
+
+
+def _set_seed(seed: int = RANDOM_SEED) -> None:
+    random.seed(seed)
+    np.random.seed(seed)
+    torch.manual_seed(seed)
+
+
+# ---------------------------------------------------------------------------
+# Selección de features (clave contra el sobreajuste)
+# ---------------------------------------------------------------------------
+def select_global_features(
+    global_features: pd.DataFrame,
+    targets: np.ndarray,
+    train_idx: np.ndarray,
+    top_k: int = DEFAULT_TOP_K,
+) -> list[str]:
+    """Devuelve el subconjunto de columnas globales de alta señal.
+
+    Pasos (todos calculados SOLO sobre filas de train para no filtrar test):
+      1. Descartar columnas con demasiados NaN.
+      2. Descartar columnas de varianza ~nula.
+      3. Poda por correlación: ante pares muy correlacionados, quedarse con el de
+         mayor señal contra los targets.
+      4. Top-K por máxima |correlación| con cualquiera de los 10 targets.
+    """
+    train = global_features.iloc[train_idx]
+    n = len(train)
+
+    # 1) NaN
+    nan_frac = train.isna().mean(axis=0)
+    keep = nan_frac[nan_frac <= NAN_FRAC_MAX].index.tolist()
+    train = train[keep]
+
+    # rellenar con mediana de train para los cálculos siguientes
+    medians = train.median(numeric_only=False)
+    filled = train.fillna(medians)
+
+    # 2) varianza
+    variances = filled.var(axis=0, ddof=0)
+    keep = variances[variances > VAR_EPS].index.tolist()
+    filled = filled[keep]
+
+    # señal: máxima |corr| con los targets
+    X = filled.to_numpy(dtype=float)
+    Xc = X - X.mean(axis=0, keepdims=True)
+    Xstd = Xc.std(axis=0, ddof=0)
+    Xstd[Xstd == 0] = 1.0
+    Xn = Xc / Xstd
+    Y = targets[train_idx].astype(float)
+    Yc = Y - Y.mean(axis=0, keepdims=True)
+    Ystd = Yc.std(axis=0, ddof=0)
+    Ystd[Ystd == 0] = 1.0
+    Yn = Yc / Ystd
+    # corr matrix (features x targets)
+    corr_ft = (Xn.T @ Yn) / max(n, 1)
+    signal = np.abs(corr_ft).max(axis=1)
+    signal_s = pd.Series(signal, index=keep).sort_values(ascending=False)
+
+    # 3) poda por correlación entre features, recorriendo por señal descendente
+    ordered = signal_s.index.tolist()
+    col_to_pos = {c: i for i, c in enumerate(keep)}
+    selected: list[str] = []
+    selected_pos: list[int] = []
+    for col in ordered:
+        pos = col_to_pos[col]
+        if selected_pos:
+            corrs = (Xn[:, pos] @ Xn[:, selected_pos]) / max(n, 1)
+            if np.abs(corrs).max() > CORR_PRUNE_THRESHOLD:
+                continue
+        selected.append(col)
+        selected_pos.append(pos)
+        if len(selected) >= top_k:
+            break
+    return selected
+
+
+# ---------------------------------------------------------------------------
+# Modelo: GNN residual con interacción bilineal atacante × defensor
+# ---------------------------------------------------------------------------
+class MatchupAttackGNN(nn.Module):
+    """Como ResidualAttackGNN pero con una rama de interacción explícita por zona.
+
+    Aprende un *delta* sobre un baseline mixto (gate entre promedio de temporada y
+    de los últimos 8 partidos), por lo que solo modela la corrección de matchup.
+    """
+
+    def __init__(
+        self,
+        node_dim: int,
+        global_dim: int,
+        hidden_dim: int = 96,
+        global_hidden: int = 96,
+        num_layers: int = 3,
+        interaction_dim: int = INTERACTION_DIM,
+        global_dropout: float = GLOBAL_DROPOUT,
+        graph_dropout: float = GRAPH_DROPOUT,
+    ) -> None:
+        super().__init__()
+        self.global_encoder = nn.Sequential(
+            nn.Linear(global_dim, 192),
+            nn.ReLU(),
+            nn.Dropout(global_dropout),
+            nn.Linear(192, global_hidden),
+            nn.ReLU(),
+        )
+        # rama de interacción: proyección ofensiva y defensiva por nodo (zona)
+        self.off_proj = nn.Linear(node_dim, interaction_dim)
+        self.def_proj = nn.Linear(node_dim, interaction_dim)
+        self.node_encoder = nn.Sequential(
+            nn.Linear(node_dim + global_hidden + interaction_dim, hidden_dim),
+            nn.ReLU(),
+        )
+        self.graph_blocks = nn.ModuleList(
+            [gnn_base.GraphBlock(hidden_dim, hidden_dim, dropout=graph_dropout) for _ in range(num_layers)]
+        )
+        self.gate_head = nn.Linear(hidden_dim, 1)
+        self.delta_head = nn.Linear(hidden_dim, 1)
+
+    def forward(
+        self,
+        node_x: torch.Tensor,
+        global_x: torch.Tensor,
+        baseline_long: torch.Tensor,
+        baseline_short: torch.Tensor,
+        adj: torch.Tensor,
+    ) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]:
+        g = self.global_encoder(global_x)
+        g_rep = g.unsqueeze(1).expand(-1, node_x.size(1), -1)
+        # interacción multiplicativa atacante × defensor (Hadamard de proyecciones)
+        inter = self.off_proj(node_x) * self.def_proj(node_x)
+        h = self.node_encoder(torch.cat([node_x, g_rep, inter], dim=-1))
+
+        gate = torch.sigmoid(self.gate_head(h)).squeeze(-1)
+        mixed = gate * baseline_short + (1.0 - gate) * baseline_long
+
+        for block in self.graph_blocks:
+            h = h + block(h, adj)
+        delta = self.delta_head(h).squeeze(-1)
+        logits = torch.log(torch.clamp(mixed, min=1e-6)) + delta
+        pred = torch.softmax(logits, dim=1)
+        return pred, delta, gate, mixed
+
+
+# Alias para que la app (que hace ``attack_model_mod.ResidualAttackGNN(...)``) funcione.
+ResidualAttackGNN = MatchupAttackGNN
+
+
+# ---------------------------------------------------------------------------
+# Entrenamiento
+# ---------------------------------------------------------------------------
+def _train_one_seed(
+    train: SplitData,
+    val: SplitData,
+    seed: int,
+    max_epochs: int = MAX_EPOCHS,
+) -> tuple[MatchupAttackGNN, float, list[dict[str, float]]]:
+    _set_seed(seed)
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    model = MatchupAttackGNN(
+        node_dim=train.node_x.shape[2],
+        global_dim=train.global_x.shape[1],
+    ).to(device)
+    optimizer = torch.optim.AdamW(model.parameters(), lr=LEARNING_RATE, weight_decay=WEIGHT_DECAY)
+    train_loader = gnn_base._make_loader(train, shuffle=True)
+    val_loader = gnn_base._make_loader(val, shuffle=False)
+    adj = ADJ_MATRIX.to(device)
+
+    best_state = None
+    best_val = float("inf")
+    patience_left = PATIENCE
+    history: list[dict[str, float]] = []
+
+    for epoch in range(1, max_epochs + 1):
+        model.train()
+        running = 0.0
+        n_batches = 0
+        for global_x, node_x, y_attack, baseline_long, baseline_short in train_loader:
+            global_x = global_x.to(device)
+            node_x = node_x.to(device)
+            y_attack = y_attack.to(device)
+            baseline_long = baseline_long.to(device)
+            baseline_short = baseline_short.to(device)
+            optimizer.zero_grad()
+            pred, delta, gate, mixed = model(node_x, global_x, baseline_long, baseline_short, adj)
+            loss, _ = gnn_base._distribution_loss(pred, y_attack, delta, gate)
+            loss.backward()
+            optimizer.step()
+            running += float(loss.item())
+            n_batches += 1
+
+        val_metrics = gnn_base._evaluate_loader(model, val_loader, device)
+        history.append({"epoch": epoch, "train_loss": running / max(n_batches, 1), "val_loss": val_metrics["loss"]})
+        if val_metrics["loss"] < best_val - 1e-6:
+            best_val = val_metrics["loss"]
+            best_state = {k: v.detach().cpu().clone() for k, v in model.state_dict().items()}
+            patience_left = PATIENCE
+        else:
+            patience_left -= 1
+        if patience_left <= 0:
+            break
+
+    if best_state is None:
+        best_state = {k: v.detach().cpu().clone() for k, v in model.state_dict().items()}
+    model.load_state_dict(best_state)
+    return model, best_val, history
+
+
+# ---------------------------------------------------------------------------
+# Evaluación con bootstrap
+# ---------------------------------------------------------------------------
+def _bootstrap_delta(
+    y_true: np.ndarray,
+    pred_model: np.ndarray,
+    pred_baseline: np.ndarray,
+    metric: str = "mae",
+    n_samples: int = BOOTSTRAP_SAMPLES,
+    seed: int = RANDOM_SEED,
+) -> dict[str, float]:
+    """IC bootstrap del delta (baseline - modelo); positivo = el modelo gana."""
+    rng = np.random.default_rng(seed)
+    n = y_true.shape[0]
+
+    def _per_row(yt: np.ndarray, yp: np.ndarray) -> np.ndarray:
+        if metric == "mae":
+            return np.abs(yt - yp).mean(axis=1)
+        # jsd por fila
+        p = base._normalize_rows(yt)
+        q = base._normalize_rows(yp)
+        m = 0.5 * (p + q)
+        eps = 1e-12
+        kl_pm = np.sum(p * (np.log(p + eps) - np.log(m + eps)), axis=1)
+        kl_qm = np.sum(q * (np.log(q + eps) - np.log(m + eps)), axis=1)
+        return 0.5 * (kl_pm + kl_qm)
+
+    err_model = _per_row(y_true, pred_model)
+    err_base = _per_row(y_true, pred_baseline)
+    diff = err_base - err_model  # positivo = modelo mejor
+    deltas = np.empty(n_samples, dtype=float)
+    for i in range(n_samples):
+        idx = rng.integers(0, n, size=n)
+        deltas[i] = diff[idx].mean()
+    lo, hi = np.percentile(deltas, [2.5, 97.5])
+    return {
+        "delta_mean": float(diff.mean()),
+        "delta_ci_low": float(lo),
+        "delta_ci_high": float(hi),
+        "wins": bool(lo > 0),
+        "rel_improvement": float(diff.mean() / max(err_base.mean(), 1e-12)),
+    }
+
+
+def _history_plot(history: list[dict[str, float]]) -> str:
+    hist = pd.DataFrame(history)
+    fig, ax = plt.subplots(figsize=(8, 4.2), facecolor="#F6F7F4")
+    ax.plot(hist["epoch"], hist["train_loss"], label="Train", color="#2B7A5A", linewidth=2)
+    ax.plot(hist["epoch"], hist["val_loss"], label="Validación", color="#D1495B", linewidth=2)
+    ax.set_xlabel("Epoch")
+    ax.set_ylabel("Loss")
+    ax.legend()
+    ax.set_facecolor("#FFFFFF")
+    buf = BytesIO()
+    fig.savefig(buf, format="png", dpi=150, bbox_inches="tight", facecolor=fig.get_facecolor())
+    plt.close(fig)
+    return base64.b64encode(buf.getvalue()).decode("ascii")
+
+
+def _report_html(summary: dict, history_img: str) -> str:
+    tm = summary["test_metrics"]
+    vm = summary["val_metrics"]
+    bs = summary["bootstrap_test"]
+
+    def _row(name: str, key: str) -> str:
+        return (
+            f"<tr><td>{name}</td><td>{tm['model_' + key]:.4f}</td>"
+            f"<td>{tm['season_baseline_' + key]:.4f}</td>"
+            f"<td>{tm['short8_baseline_' + key]:.4f}</td></tr>"
+        )
+
+    return f"""<!doctype html><html lang="es"><head><meta charset="utf-8">
+<title>Attack Matchup GNN</title>
+<style>body{{font-family:system-ui;margin:24px;background:#F6F7F4;color:#102a21}}
+table{{border-collapse:collapse;margin:8px 0}} td,th{{border:1px solid #ccc;padding:6px 12px;text-align:right}}
+th:first-child,td:first-child{{text-align:left}} .card{{background:#fff;padding:16px;border-radius:12px;margin:12px 0;box-shadow:0 1px 4px rgba(0,0,0,.06)}}
+.win{{color:#2B7A5A;font-weight:700}} .lose{{color:#D1495B;font-weight:700}}</style></head>
+<body>
+<h1>Attack Matchup GNN — rediseño</h1>
+<p>Train {summary['train_rows']} · Val {summary['val_rows']} · Test {summary['test_rows']} ·
+features globales {summary['global_feature_count']} (de {summary['global_feature_count_full']}) ·
+node {summary['node_feature_count']} · seeds {summary['n_seeds']}</p>
+<div class="card"><h2>Test — modelo vs baselines</h2>
+<table><tr><th>Métrica</th><th>Modelo</th><th>Temporada</th><th>Últimos 8</th></tr>
+{_row('MAE', 'mae')}{_row('JSD', 'jsd')}{_row('KL', 'kl_proxy')}</table></div>
+<div class="card"><h2>Validación</h2>
+<table><tr><th>Métrica</th><th>Modelo</th><th>Temporada</th><th>Últimos 8</th></tr>
+<tr><td>MAE</td><td>{vm['model_mae']:.4f}</td><td>{vm['season_baseline_mae']:.4f}</td><td>{vm['short8_baseline_mae']:.4f}</td></tr>
+<tr><td>JSD</td><td>{vm['model_jsd']:.4f}</td><td>{vm['season_baseline_jsd']:.4f}</td><td>{vm['short8_baseline_jsd']:.4f}</td></tr></table></div>
+<div class="card"><h2>Bootstrap (test, delta = baseline − modelo, &gt;0 = modelo gana)</h2>
+<table><tr><th>vs baseline</th><th>Métrica</th><th>Delta medio</th><th>IC 95%</th><th>Mejora rel.</th><th>Gana</th></tr>
+<tr><td>Temporada</td><td>MAE</td><td>{bs['vs_season_mae']['delta_mean']:.5f}</td>
+<td>[{bs['vs_season_mae']['delta_ci_low']:.5f}, {bs['vs_season_mae']['delta_ci_high']:.5f}]</td>
+<td>{bs['vs_season_mae']['rel_improvement']*100:.1f}%</td>
+<td class="{'win' if bs['vs_season_mae']['wins'] else 'lose'}">{'sí' if bs['vs_season_mae']['wins'] else 'no'}</td></tr>
+<tr><td>Temporada</td><td>JSD</td><td>{bs['vs_season_jsd']['delta_mean']:.5f}</td>
+<td>[{bs['vs_season_jsd']['delta_ci_low']:.5f}, {bs['vs_season_jsd']['delta_ci_high']:.5f}]</td>
+<td>{bs['vs_season_jsd']['rel_improvement']*100:.1f}%</td>
+<td class="{'win' if bs['vs_season_jsd']['wins'] else 'lose'}">{'sí' if bs['vs_season_jsd']['wins'] else 'no'}</td></tr>
+</table></div>
+<div class="card"><h2>Entrenamiento</h2><img src="data:image/png;base64,{history_img}"></div>
+</body></html>"""
+
+
+# ---------------------------------------------------------------------------
+# Main
+# ---------------------------------------------------------------------------
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Entrena el Attack Matchup GNN.")
+    parser.add_argument("--top-k", type=int, default=DEFAULT_TOP_K, help="Features globales a conservar.")
+    parser.add_argument("--seeds", type=int, default=DEFAULT_N_SEEDS, help="Cantidad de seeds (el bundle usa la mejor).")
+    parser.add_argument("--max-epochs", type=int, default=MAX_EPOCHS)
+    args = parser.parse_args()
+
+    _set_seed()
+    MODEL_DIR.mkdir(parents=True, exist_ok=True)
+    REPORTS_DIR.mkdir(parents=True, exist_ok=True)
+
+    df, attack_targets = gnn_base._load_data()
+    y_attack = df[attack_targets].to_numpy(dtype=np.float32)
+    train_idx, val_idx, test_idx, val_start_date = gnn_base._train_val_test_indices(df)
+
+    global_features_full, node_tensor, _zone_arr, global_cols_full, node_feat_names = _build_feature_matrices(df, attack_targets)
+
+    # selección de features (solo con train)
+    selected_cols = select_global_features(global_features_full, y_attack, train_idx, top_k=args.top_k)
+    global_features = global_features_full[selected_cols].copy()
+    print(f"Features globales: {len(global_cols_full)} -> {len(selected_cols)} (top_k={args.top_k})")
+
+    global_x, global_bundle = gnn_base._standardize_global(train_idx, global_features)
+    node_x, node_bundle = gnn_base._standardize_node(train_idx, node_tensor)
+
+    baseline_long = base._normalize_rows(
+        df[[f"long_mean__actual_attack_share__{zone}" for zone in ZONE_ORDER]].to_numpy(dtype=float)
+    ).astype(np.float32)
+    baseline_short = base._normalize_rows(
+        df[[f"short_mean__actual_attack_share__{zone}" for zone in ZONE_ORDER]].to_numpy(dtype=float)
+    ).astype(np.float32)
+
+    train_split = gnn_base._make_split(df, train_idx, global_x, node_x, y_attack, baseline_long, baseline_short)
+    val_split = gnn_base._make_split(df, val_idx, global_x, node_x, y_attack, baseline_long, baseline_short)
+    test_split = gnn_base._make_split(df, test_idx, global_x, node_x, y_attack, baseline_long, baseline_short)
+
+    # multi-seed: entrena varias, elige la de mejor val para el bundle
+    seeds = [RANDOM_SEED + i for i in range(max(args.seeds, 1))]
+    trained: list[tuple[MatchupAttackGNN, float, list]] = []
+    for s in seeds:
+        model_s, val_s, hist_s = _train_one_seed(train_split, val_split, s, max_epochs=args.max_epochs)
+        print(f"  seed {s}: best val loss {val_s:.5f}")
+        trained.append((model_s, val_s, hist_s))
+    best_model, best_val, history = min(trained, key=lambda t: t[1])
+
+    val_pred, val_gates, _ = gnn_base._predict(best_model, val_split)
+    test_pred, test_gates, test_mixed = gnn_base._predict(best_model, test_split)
+
+    val_true = val_split.metadata[attack_targets].to_numpy(dtype=float)
+    test_true = test_split.metadata[attack_targets].to_numpy(dtype=float)
+    val_long, val_short = val_split.baseline_long.astype(float), val_split.baseline_short.astype(float)
+    test_long, test_short = test_split.baseline_long.astype(float), test_split.baseline_short.astype(float)
+
+    val_metrics = gnn_base._metrics_against_baselines(val_true, val_pred, val_long, val_short)
+    test_metrics = gnn_base._metrics_against_baselines(test_true, test_pred, test_long, test_short)
+
+    bootstrap_test = {
+        "vs_season_mae": _bootstrap_delta(test_true, test_pred, test_long, metric="mae"),
+        "vs_short8_mae": _bootstrap_delta(test_true, test_pred, test_short, metric="mae"),
+        "vs_season_jsd": _bootstrap_delta(test_true, test_pred, test_long, metric="jsd"),
+        "vs_short8_jsd": _bootstrap_delta(test_true, test_pred, test_short, metric="jsd"),
+    }
+
+    # predicciones de test para inspección
+    pred_df = test_split.metadata.copy().reset_index(drop=True)
+    for i, zone in enumerate(ZONE_ORDER):
+        tcol = f"target_attack_share__{zone}"
+        pred_df[f"pred_model__{tcol}"] = test_pred[:, i]
+        pred_df[f"pred_season__{tcol}"] = test_long[:, i]
+        pred_df[f"pred_short8__{tcol}"] = test_short[:, i]
+        pred_df[f"gate__{zone}"] = test_gates[:, i]
+    keep = [c for c in ["matchId", "fecha", "league", "season", "teamId", "team_name", "opponent_name", "is_home"] if c in pred_df.columns]
+    keep += attack_targets
+    keep += [f"pred_{k}__target_attack_share__{z}" for k in ("model", "season", "short8") for z in ZONE_ORDER]
+    keep += [f"gate__{z}" for z in ZONE_ORDER]
+    pred_df[keep].to_parquet(PRED_PATH, index=False)
+
+    summary = {
+        "model": "attack_matchup_gnn",
+        "train_rows": int(len(train_split.metadata)),
+        "val_rows": int(len(val_split.metadata)),
+        "test_rows": int(len(test_split.metadata)),
+        "val_start_date": val_start_date,
+        "n_seeds": len(seeds),
+        "best_seed_val_loss": float(best_val),
+        "top_k": int(args.top_k),
+        "global_feature_count": int(global_x.shape[1]),
+        "global_feature_count_full": int(len(global_cols_full)),
+        "node_feature_count": int(node_x.shape[2]),
+        "zone_order": ZONE_ORDER,
+        "selected_global_features": selected_cols,
+        "val_metrics": val_metrics,
+        "test_metrics": test_metrics,
+        "bootstrap_test": bootstrap_test,
+        "weight_decay": WEIGHT_DECAY,
+        "interaction_dim": INTERACTION_DIM,
+    }
+
+    torch.save(
+        {
+            "model_state_dict": best_model.state_dict(),
+            "global_bundle": global_bundle,
+            "node_bundle": node_bundle,
+            "zone_order": ZONE_ORDER,
+            "attack_targets": attack_targets,
+            "summary": summary,
+        },
+        MODEL_PATH,
+    )
+    history_img = _history_plot(history)
+    JSON_PATH.write_text(json.dumps({k: v for k, v in summary.items() if k != "selected_global_features"}, ensure_ascii=False, indent=2), encoding="utf-8")
+    REPORT_PATH.write_text(_report_html(summary, history_img), encoding="utf-8")
+
+    print(f"Modelo guardado en:      {MODEL_PATH}")
+    print(f"Métricas guardadas en:   {JSON_PATH}")
+    print(f"Reporte guardado en:     {REPORT_PATH}")
+    print("--- TEST ---")
+    print(f"  MAE  modelo {test_metrics['model_mae']:.4f} | temporada {test_metrics['season_baseline_mae']:.4f} | últimos8 {test_metrics['short8_baseline_mae']:.4f}")
+    print(f"  JSD  modelo {test_metrics['model_jsd']:.4f} | temporada {test_metrics['season_baseline_jsd']:.4f} | últimos8 {test_metrics['short8_baseline_jsd']:.4f}")
+    print(f"  Bootstrap vs temporada (MAE): delta {bootstrap_test['vs_season_mae']['delta_mean']:.5f} "
+          f"IC[{bootstrap_test['vs_season_mae']['delta_ci_low']:.5f},{bootstrap_test['vs_season_mae']['delta_ci_high']:.5f}] "
+          f"mejora {bootstrap_test['vs_season_mae']['rel_improvement']*100:.1f}% gana={bootstrap_test['vs_season_mae']['wins']}")
+
+
+if __name__ == "__main__":
+    main()