diff --git a/apps/tenis/artefactos/tenis-2.1-capa-edad.json b/apps/tenis/artefactos/tenis-2.1-capa-edad.json new file mode 100644 index 00000000..b91f837e --- /dev/null +++ b/apps/tenis/artefactos/tenis-2.1-capa-edad.json @@ -0,0 +1,771 @@ +{ + "version": "tenis-modelo-s3-1.0.0", + "temporadas_ajuste": [ + 2005, + 2018 + ], + "ventana_verosimilitud": [ + 2007, + 2018 + ], + "sha256_export": "fd4be4661a4c869a3920654b4e7514722159f3224f0e6efa4c8c3bd0c4e3a881", + "especificacion": { + "tiempo": "ns UTC; Δt en años = Δns/(365,25·86400e9); inactividad en días por encima de 60", + "orden": "partidos por (corte_utc, partido_key); antes de cada uno se aplican los eventos con visible_resultado_utc < corte en bloques de igual visibilidad, cada bloque desde el estado previo (Woodbury si un jugador aparece varias veces; términos ordenados por partido_key)", + "actualiza": "solo eventos estado=completado cuyo partido se pronosticó; walkover y retirada no; un evento repetido (misma partido_key) se aplica una vez", + "no_pronosticable": "excluir_motivo no nulo, por_equipos o jjoo, superficie nula, formato no soportado (solo (3|5, tiebreak_7|tiebreak_10|ventaja)), o un lado sin estado y sin rank PIT", + "prior": "θ0 = b_rank·(ln rank − ln 100), var σ_θ0²; d ~ N(0, σ_d²Ω), Ω equicorrelada r_Ω; t_last = corte del partido que lo inicializa", + "propagacion": "V_θθ += τ_θ²Δt + τ_I²·max(0, días−60)/365,25; V_dd += τ_d²Δt·Ω; desde la última actualización (la predicción no modifica el estado)", + "rho": "κ_s(1+γ_pregs·z)·(θ1−θ2) + d1_s − d2_s − [φ1(F1−F2)/60 + φ2(max(0,F1−F90)−max(0,F2−F90))/60]; término de fatiga 0 y marca si F desconocida", + "fatiga": "F = Σ λ^(Δ días)·minutos de eventos del jugador con 0 < corte − visible ≤ 96 h; walkover = 0; minutos nulos en un partido jugado ⇒ desconocida", + "enlace": "π = E_u[M(ρ+u)]/(E_u[M(ρ+u)] + E_u[M(−ρ+u)]), u ~ N(0, v), v = aᵀV1a + aᵀV2a, a = κ_s(1+γz)e_θ + e_ds; M(ρ) = simulador.mezcla.prob_ganar(expit(ℓ̄_s+ρ), expit(ℓ̄_s−ρ), formato, Incertidumbre(σ_ε, ρ_ε)); ρ recortado a ±r_lim (M(−r_lim) ≥ 1e-13)", + "actualizacion": "g = ∂ln M/∂ρ (ganador lado 1) o −∂ln M(−ρ)/∂ρ, h = max(0, −∂²); h_ef = h/(1+h·q_rival), g_ef = g/(1+h·q_rival); m += V a g_ef/(1+h_ef q), V −= h_ef/(1+h_ef q)·(Va)(Va)ᵀ" + }, + "priors": { + "ln_kappa_de": 0.5, + "gamma_de": 0.1 + }, + "circuitos": { + "wta": { + "n_partidos_ajuste": 39012, + "n_obs_p": 28141, + "psi_p": { + "sigma_alpha0": 0.16300001304835657, + "sigma_beta0": 0.12119580023819611, + "tau_alpha": 0.06273543497593298, + "tau_beta": 0.045027062205503066, + "sigma_ab": 0.03752117056964157, + "kappa": [ + 0.9782955082979278, + 0.9798645894956981, + 1.0, + 1.148583015591594 + ], + "sigma_eps": 0.17927273327692572, + "rho_eps": -0.7337716704960073, + "tau_mu": 0.01005271130174088 + }, + "x_p": { + "ln_sigma_alpha0": -1.8140049981241106, + "ln_sigma_beta0": -2.110347857447332, + "ln_tau_alpha": -2.7688288398497116, + "ln_tau_beta": -3.100491587625201, + "ln_sigma_ab": -3.2828499567795633, + "ln_kappa_clay": -0.021943498863314613, + "ln_kappa_grass": -0.020340890848405364, + "ln_kappa_indoor": 0.13852902228631267, + "ln_sigma_eps": -1.7188469831259483, + "x_rho_eps": -0.9368500742893404, + "ln_tau_mu": -4.5999128995937255 + }, + "menos_loglik_p": 16605.505675461372, + "lbar": [ + 0.1797659492209295, + 0.3305814573291176, + 0.22036621306896254, + 0.257794020629328 + ], + "lbar_comun": 0.22192833348729377, + "error_tablas": { + "max_error_tabla_v0": 2.5293923622271564e-09, + "max_error_con_v_q61": 1.4739632954174908e-06, + "tablas_distintas": 24 + }, + "fijo_r": { + "sigma_eps": 0.17927273327692572, + "rho_eps": -0.7337716704960073, + "lbar": [ + 0.1797659492209295, + 0.3305814573291176, + 0.22036621306896254, + 0.257794020629328 + ], + "lam": 0.5, + "f90": 129.74895908002406 + }, + "psi_r": { + "tau_theta": 0.06413840868661237, + "tau_inact": 0.009916640571055405, + "sigma_theta0": 0.05898039506958511, + "b_rank": -0.07134774744496457, + "kappa": [ + 0.9314211542731533, + 0.9469575485924111, + 1.0, + 0.8663767193334275 + ], + "sigma_d": 0.052736784131307154, + "tau_d": 0.012423660688880506, + "r_omega": 0.49640959732902584, + "phi": [ + 9.061972715021625e-07, + 0.012513231254146067 + ], + "gamma": [ + -0.07586146230655405, + 0.0, + 0.0 + ], + "lam": 0.5, + "f90": 129.74895908002406, + "sigma_eps": 0.17927273327692572, + "rho_eps": -0.7337716704960073, + "lbar": [ + 0.1797659492209295, + 0.3305814573291176, + 0.22036621306896254, + 0.257794020629328 + ], + "sigma_r": 0.0036464415579814643, + "sigma_r_challenger": null, + "c_inf": 0.013819667540437069 + }, + "x_r": { + "ln_tau_theta": -2.7467118950247085, + "ln_tau_inact": -4.613541067152282, + "ln_sigma_theta0": -2.8305501772521455, + "b_rank": -0.07134774744496457, + "ln_kappa_clay": -0.07104373635212802, + "ln_kappa_grass": -0.05450101405277194, + "ln_kappa_indoor": -0.14343545423182955, + "ln_sigma_d": -2.9424420758109227, + "ln_tau_d": -4.388152504448777, + "x_r_omega": 0.3442319602777539, + "u_phi1": -13.91400836254159, + "u_phi2": -4.374705554333586, + "gamma_pregs": -0.07586146230655405, + "ln_sigma_r": -5.614003502548587 + }, + "menos_loglik_r": 17617.731960828467, + "rejilla_lambda": { + "0.75": { + "menos_loglik": 17618.46583901461, + "f90": 150.20574986604908, + "x": [ + -2.7467104420509174, + -4.61354058002255, + -2.8305483191395466, + -0.07133088156823654, + -0.07104817702311471, + -0.0544952961427406, + -0.14343570399256708, + -2.9424393411450684, + -4.388155084177392, + 0.3442321139155479, + -8.34746475772448, + -5.564199820692609, + -0.075865329037879 + ] + }, + "0.5": { + "menos_loglik": 17617.731895618403, + "f90": 129.74895908002406, + "x": [ + -2.7467104420509174, + -4.61354058002255, + -2.8305483191395466, + -0.07133088156823654, + -0.07104817702311471, + -0.0544952961427406, + -0.14343570399256708, + -2.9424393411450684, + -4.388155084177392, + 0.3442321139155479, + -13.91400836154744, + -4.3747055591958315, + -0.075865329037879 + ] + }, + "0.9": { + "menos_loglik": 17618.443745400247, + "f90": 166.19979732746498, + "x": [ + -2.7467104420509174, + -4.61354058002255, + -2.8305483191395466, + -0.07133088156823654, + -0.07104817702311471, + -0.0544952961427406, + -0.14343570399256708, + -2.9424393411450684, + -4.388155084177392, + 0.3442321139155479, + -15.203007668644108, + -5.307312242548907, + -0.075865329037879 + ] + } + }, + "lambda_elegido": 0.5, + "ablacion_sin_superficie": { + "psi_r": { + "tau_theta": 0.06070442613855541, + "tau_inact": 0.009861256730986973, + "sigma_theta0": 0.07120649071963767, + "b_rank": -0.068335678825793, + "kappa": [ + 1.0, + 1.0, + 1.0, + 1.0 + ], + "sigma_d": 0.0, + "tau_d": 0.0, + "r_omega": 0.49640964170854057, + "phi": [ + 9.061862430522208e-07, + 0.012446462187297653 + ], + "gamma": [ + -0.06590972287298828, + 0.0, + 0.0 + ], + "lam": 0.5, + "f90": 129.74895908002406, + "sigma_eps": 0.17927273327692572, + "rho_eps": -0.7337716704960073, + "lbar": [ + 0.1797659492209295, + 0.3305814573291176, + 0.22036621306896254, + 0.257794020629328 + ], + "sigma_r": 0.0011580908023724969, + "sigma_r_challenger": null, + "c_inf": 0.013819667540437069 + }, + "x_r": [ + -2.801738665312235, + -4.619141660985861, + -2.642171302926527, + -0.068335678825793, + -0.07104817702311471, + -0.0544952961427406, + -0.14343570399256708, + -2.9424393411450684, + -4.388155084177392, + 0.3442321139155479, + -13.914020532653325, + -4.380089172262978, + -0.06590972287298828, + -6.760982489803151 + ], + "menos_loglik": 17683.605153196862 + }, + "ablacion_sin_fatiga": { + "psi_r": { + "tau_theta": 0.0641385018781069, + "tau_inact": 0.009916645401747037, + "sigma_theta0": 0.0589805046619021, + "b_rank": -0.07133088156823654, + "kappa": [ + 0.9314170181474407, + 0.9469629632259576, + 1.0, + 0.8663765029465662 + ], + "sigma_d": 0.05273692834898717, + "tau_d": 0.012423628639248856, + "r_omega": 0.49640964170854057, + "phi": [ + 0.0, + 0.0 + ], + "gamma": [ + -0.075865329037879, + 0.0, + 0.0 + ], + "lam": 0.5, + "f90": 129.74895908002406, + "sigma_eps": 0.17927273327692572, + "rho_eps": -0.7337716704960073, + "lbar": [ + 0.1797659492209295, + 0.3305814573291176, + 0.22036621306896254, + 0.257794020629328 + ], + "sigma_r": 0.00940048226978873, + "sigma_r_challenger": null, + "c_inf": 0.013819667540437069 + }, + "x_r": [ + -2.7467104420509174, + -4.61354058002255, + -2.8305483191395466, + -0.07133088156823654, + -0.07104817702311471, + -0.0544952961427406, + -0.14343570399256708, + -2.9424393411450684, + -4.388155084177392, + 0.3442321139155479, + -13.91400836154744, + -4.3747055591958315, + -0.075865329037879, + -4.666994285725577 + ], + "menos_loglik": 17618.770388814406 + }, + "parche_sigma_r": { + "menos_loglik_antes": 17617.731895618403, + "sigma_r_solo": 0.003646441558952333, + "menos_loglik_sigma_r_solo": 17617.73196422496, + "menos_loglik_reajuste_corto": 17617.731960828467, + "usa_reajuste": true, + "platt_2012_2018_antes": 0.8539842941599404, + "platt_2012_2018_despues": 0.8539979073147882 + }, + "c_inf": 0.013819667540437069, + "c_inf_evaluacion": { + "G_calibracion": { + "pasa": true, + "n": 13980, + "pendiente": 0.9747146711109161, + "pend_lo": 0.9292118891807224, + "pend_hi": 1.025361818178106, + "intercepto": -0.008258151248900026, + "int_lo": -0.0434882807782033, + "int_hi": 0.02850635047871444 + }, + "G_calibracion_base": { + "n": 13980, + "pendiente": 0.8756340345087894, + "pend_lo": 0.8335194404974047, + "pend_hi": 0.9201116755965955, + "intercepto": -0.008292900402758265, + "int_lo": -0.04544753352643737, + "int_hi": 0.028972776319729526 + }, + "metricas_cinf": { + "n": 13980, + "logloss": 0.622152780622885, + "brier": 0.21689452294430336, + "acierto": 0.6486409155937053 + }, + "metricas_base": { + "n": 13980, + "logloss": 0.6232266298145109, + "brier": 0.2172936420902707, + "acierto": 0.6486409155937053 + }, + "n_evaluados": 13980 + }, + "capa_edad": { + "pendiente": 0.9790358470936495, + "beta": -0.15236119655785269, + "escala": 5.766447766565482, + "n": 28682, + "desde": 2013, + "hasta": 2024 + } + }, + "atp": { + "n_partidos_ajuste": 126167, + "n_obs_p": 93250, + "psi_p": { + "sigma_alpha0": 0.2533138316039382, + "sigma_beta0": 0.16796811595968225, + "tau_alpha": 0.08115557987496022, + "tau_beta": 0.05414206398119436, + "sigma_ab": 0.0501818126870431, + "kappa": [ + 0.9766889935918989, + 1.010361534906718, + 1.0, + 1.111665701414173 + ], + "sigma_eps": 0.17980547307995082, + "rho_eps": -0.6801484032539825, + "tau_mu": 0.23417006748907124 + }, + "x_p": { + "ln_sigma_alpha0": -1.3731261178437917, + "ln_sigma_beta0": -1.7839811035447837, + "ln_tau_alpha": -2.5113872273735653, + "ln_tau_beta": -2.916143872486179, + "ln_sigma_ab": -2.9921026150007477, + "ln_kappa_clay": -0.023587005567424907, + "ln_kappa_grass": 0.010308222155621275, + "ln_kappa_indoor": 0.10585952240600262, + "ln_sigma_eps": -1.7158797175861482, + "x_rho_eps": -0.8293901378555657, + "ln_tau_mu": -1.4517076434628031 + }, + "menos_loglik_p": 58906.45550258839, + "lbar": [ + 0.4375194290911775, + 0.5934961560357145, + 0.5072061633831914, + 0.5335288071698687 + ], + "lbar_comun": 0.4887631847060511, + "error_tablas": { + "max_error_tabla_v0": 2.257343534317613e-09, + "max_error_con_v_q61": 1.5164033647652175e-06, + "tablas_distintas": 24 + }, + "fijo_r": { + "sigma_eps": 0.17980547307995082, + "rho_eps": -0.6801484032539825, + "lbar": [ + 0.4375194290911775, + 0.5934961560357145, + 0.5072061633831914, + 0.5335288071698687 + ], + "lam": 0.5, + "f90": 176.8735810194933 + }, + "psi_r": { + "tau_theta": 0.06429318852887476, + "tau_inact": 0.04094885610531957, + "sigma_theta0": 0.0902480928720455, + "b_rank": -0.14243704429202975, + "kappa": [ + 1.0081911953492928, + 1.0430587775710451, + 1.0, + 1.114829017762988 + ], + "sigma_d": 0.05841496974380035, + "tau_d": 0.016653192940832635, + "r_omega": 0.3967945769778876, + "phi": [ + 2.3215252412494064e-06, + 0.009655565399887807 + ], + "gamma": [ + -0.038156469732258974, + 0.0, + 0.0 + ], + "lam": 0.5, + "f90": 176.8735810194933, + "sigma_eps": 0.17980547307995082, + "rho_eps": -0.6801484032539825, + "lbar": [ + 0.4375194290911775, + 0.5934961560357145, + 0.5072061633831914, + 0.5335288071698687 + ], + "sigma_r": 0.0009646935586372839, + "sigma_r_challenger": null, + "c_inf": 0.017299659141840125 + }, + "x_r": { + "ln_tau_theta": -2.7443015860267344, + "ln_tau_inact": -3.1954314030092483, + "ln_sigma_theta0": -2.4051928136041067, + "b_rank": -0.14243704429202975, + "ln_kappa_clay": 0.0081578295884792, + "ln_kappa_grass": 0.0421575287654446, + "ln_kappa_indoor": 0.10870104585541455, + "ln_sigma_d": -2.840183090765734, + "ln_tau_d": -4.095153312722682, + "x_r_omega": 0.006032209813692497, + "u_phi1": -12.973284995963656, + "u_phi2": -4.635389137218541, + "gamma_pregs": -0.038156469732258974, + "ln_sigma_r": -6.943700062873099 + }, + "menos_loglik_r": 59734.605540330114, + "rejilla_lambda": { + "0.75": { + "menos_loglik": 59738.89263337273, + "f90": 217.7492749691321, + "x": [ + -2.741712723305241, + -3.1923403316387264, + -2.4053821391581875, + -0.14275782901988268, + 0.006338021087183231, + 0.04768080003711913, + 0.10846188912239448, + -2.839982749871357, + -4.098206469074932, + 0.008340542252745973, + -7.165950862804159, + -5.791535882572361, + -0.03912993297350013 + ] + }, + "0.5": { + "menos_loglik": 59734.638936138006, + "f90": 176.8735810194933, + "x": [ + -2.741712723305241, + -3.1923403316387264, + -2.4053821391581875, + -0.14275782901988268, + 0.006338021087183231, + 0.04768080003711913, + 0.10846188912239448, + -2.839982749871357, + -4.098206469074932, + 0.008340542252745973, + -12.97327217770184, + -4.635388741011188, + -0.03912993297350013 + ] + }, + "0.9": { + "menos_loglik": 59735.19880051252, + "f90": 248.73269668262543, + "x": [ + -2.741712723305241, + -3.1923403316387264, + -2.4053821391581875, + -0.14275782901988268, + 0.006338021087183231, + 0.04768080003711913, + 0.10846188912239448, + -2.839982749871357, + -4.098206469074932, + 0.008340542252745973, + -13.853716170159355, + -5.036874700605927, + -0.03912993297350013 + ] + } + }, + "lambda_elegido": 0.5, + "ablacion_sin_superficie": { + "psi_r": { + "tau_theta": 0.0644912969318676, + "tau_inact": 0.0390363438099783, + "sigma_theta0": 0.10364611031761461, + "b_rank": -0.14240412377441122, + "kappa": [ + 1.0, + 1.0, + 1.0, + 1.0 + ], + "sigma_d": 0.0, + "tau_d": 0.0, + "r_omega": 0.3974812969359968, + "phi": [ + 2.320799485059728e-06, + 0.008708139649194134 + ], + "gamma": [ + -0.050064398047001316, + 0.0, + 0.0 + ], + "lam": 0.5, + "f90": 176.8735810194933, + "sigma_eps": 0.17980547307995082, + "rho_eps": -0.6801484032539825, + "lbar": [ + 0.4375194290911775, + 0.5934961560357145, + 0.5072061633831914, + 0.5335288071698687 + ], + "sigma_r": 0.00030344187191467934, + "sigma_r_challenger": null, + "c_inf": 0.017299659141840125 + }, + "x_r": [ + -2.74122499557333, + -3.2432621742312486, + -2.2667729678897497, + -0.14240412377441122, + 0.006338021087183231, + 0.04768080003711913, + 0.10846188912239448, + -2.839982749871357, + -4.098206469074932, + 0.008340542252745973, + -12.973597665619778, + -4.73913986937687, + -0.050064398047001316, + -8.100320491624675 + ], + "menos_loglik": 60119.403294672724 + }, + "ablacion_sin_fatiga": { + "psi_r": { + "tau_theta": 0.06420121459019783, + "tau_inact": 0.04101555661309926, + "sigma_theta0": 0.09025364005082782, + "b_rank": -0.14247318585871174, + "kappa": [ + 1.0073679494036731, + 1.0466500671744823, + 1.0, + 1.1137608849938225 + ], + "sigma_d": 0.058364305146735136, + "tau_d": 0.01660887629625701, + "r_omega": 0.39733304954223875, + "phi": [ + 0.0, + 0.0 + ], + "gamma": [ + -0.03932721969000651, + 0.0, + 0.0 + ], + "lam": 0.5, + "f90": 176.8735810194933, + "sigma_eps": 0.17980547307995082, + "rho_eps": -0.6801484032539825, + "lbar": [ + 0.4375194290911775, + 0.5934961560357145, + 0.5072061633831914, + 0.5335288071698687 + ], + "sigma_r": 0.00030345368646133306, + "sigma_r_challenger": null, + "c_inf": 0.017299659141840125 + }, + "x_r": [ + -2.7457331496147472, + -3.193803854655245, + -2.405131349609338, + -0.14247318585871174, + 0.007340938659187652, + 0.04559465173885349, + 0.10774247303801714, + -2.841050789255753, + -4.097818009887653, + 0.00784222352671197, + -12.97327217770184, + -4.635388741011188, + -0.03932721969000651, + -8.100281557259471 + ], + "menos_loglik": 59742.01162817932 + }, + "variante_challenger": { + "psi_r": { + "tau_theta": 0.06445985040718145, + "tau_inact": 0.04107562777127697, + "sigma_theta0": 0.09023100821918947, + "b_rank": -0.14275782901988268, + "kappa": [ + 1.006358148843747, + 1.0488358135338218, + 1.0, + 1.114562430776531 + ], + "sigma_d": 0.05842667382344758, + "tau_d": 0.016602425678651295, + "r_omega": 0.3974812969359968, + "phi": [ + 2.321554999323941e-06, + 0.00965556920708467 + ], + "gamma": [ + -0.03912993297350013, + 0.0, + 0.0 + ], + "lam": 0.5, + "f90": 176.8735810194933, + "sigma_eps": 0.17980547307995082, + "rho_eps": -0.6801484032539825, + "lbar": [ + 0.4375194290911775, + 0.5934961560357145, + 0.5072061633831914, + 0.5335288071698687 + ], + "sigma_r": 5.841199075730705e-06, + "sigma_r_challenger": 0.04612575035200707, + "c_inf": 0.017299659141840125 + }, + "x_r": [ + -2.741712723305241, + -3.1923403316387264, + -2.4053821391581875, + -0.14275782901988268, + 0.006338021087183231, + 0.04768080003711913, + 0.10846188912239448, + -2.839982749871357, + -4.098206469074932, + 0.008340542252745973, + -12.97327217770184, + -4.635388741011188, + -0.03912993297350013, + -12.050574461012884, + -3.0763839089595737 + ], + "menos_loglik": 59734.15074124104, + "razon_verosimilitud": 0.9771977535274345, + "justificada_chi2_1gl": false + }, + "parche_sigma_r": { + "menos_loglik_antes": 59734.638936138006, + "sigma_r_solo": 0.0009646956241399823, + "menos_loglik_sigma_r_solo": 59734.63934011781, + "menos_loglik_reajuste_corto": 59734.605540330114, + "usa_reajuste": true, + "platt_2012_2018_antes": 0.8665905134662272, + "platt_2012_2018_despues": 0.8668991651902506 + }, + "c_inf": 0.017299659141840125, + "c_inf_evaluacion": { + "G_calibracion": { + "pasa": false, + "n": 46078, + "pendiente": 0.9019037716641949, + "pend_lo": 0.8763715439354032, + "pend_hi": 0.928780762194309, + "intercepto": -0.006894301356861207, + "int_lo": -0.02683752092411115, + "int_hi": 0.014316246164970575 + }, + "G_calibracion_base": { + "n": 46078, + "pendiente": 0.7966204240090253, + "pend_lo": 0.7745818626092043, + "pend_hi": 0.8203127289525047, + "intercepto": -0.006862142018607718, + "int_lo": -0.025432518839812093, + "int_hi": 0.01228687257800849 + }, + "metricas_cinf": { + "n": 46078, + "logloss": 0.636839907354771, + "brier": 0.2233577761220697, + "acierto": 0.6302573896436477 + }, + "metricas_base": { + "n": 46078, + "logloss": 0.6391015838461929, + "brier": 0.22411207263956984, + "acierto": 0.6302573896436477 + }, + "n_evaluados": 46078 + }, + "capa_edad": { + "pendiente": 0.960266439078184, + "beta": -0.16596992323746734, + "escala": 5.800831699388082, + "n": 94858, + "desde": 2013, + "hasta": 2024 + } + } + }, + "segundos": 16260, + "parche_sigma_r": { + "fecha": "2026-11-06", + "sha256_antes": "0f2d5a5281f5df62aecb651f36e4e0d2e6bb4dbe394f383a303595a93813d650", + "regla": "Σ_m += σ_R²·[[1,−1],[−1,1]] en verosimilitud y predicción; resto congelado salvo reajuste corto" + }, + "c_inf_fecha": "2026-11-07", + "c_inf_protocolo": "factor de inflación de varianza predictiva (opción A): v_pred = v + c_inf, solo en Tabla.prob(); estimado por MV predictiva ≤ 2018 (búsqueda dorada); Ψ congelado; evaluado en 2019–2024", + "nota_capa_edad": "Capa de edad 17-nov-2026: logit π' = b·logit π + β·(Δedad/escala), sin intercepto; reemplaza la pendiente de recalibración. Ver docs/tenis_capa_edad_20261117.md.", + "sha256_contenido": "55c17ba1c6e28445b0e99b2bfab64c1d7b681766c29d6574c62089a488f41f94" +} \ No newline at end of file diff --git a/apps/tenis/ops/Dockerfile.tenis-motor b/apps/tenis/ops/Dockerfile.tenis-motor index c104b654..b0e81cf9 100644 --- a/apps/tenis/ops/Dockerfile.tenis-motor +++ b/apps/tenis/ops/Dockerfile.tenis-motor @@ -21,8 +21,11 @@ RUN pip install --no-cache-dir -r requirements.txt COPY src/ /app/src/ COPY apps/tenis/src/ /app/apps/tenis/src/ COPY apps/tenis/config/ /app/apps/tenis/config/ +# Artefactos congelados (plan §H.2): el motor recalcula su huella al arrancar y no sella si no coincide con la registrada. +COPY apps/tenis/artefactos/ /app/apps/tenis/artefactos/ -ENV PYTHONPATH="/app/src:/app/apps/tenis/src" +ENV PYTHONPATH="/app/src:/app/apps/tenis/src" \ + TENIS_ARTEFACTOS_DIR="/app/apps/tenis/artefactos" # Usuario no root para ejecución segura RUN useradd -m -u 1000 qf && chown -R qf:qf /app diff --git a/apps/tenis/ops/congelar_capa_edad.py b/apps/tenis/ops/congelar_capa_edad.py new file mode 100644 index 00000000..b15ddc06 --- /dev/null +++ b/apps/tenis/ops/congelar_capa_edad.py @@ -0,0 +1,51 @@ +"""Congela la capa de edad en un artefacto de hiperparámetros NUEVO (no toca el existente ni la base de datos). + +Uso: python apps/tenis/ops/congelar_capa_edad.py --dir + [--salida hiperparametros_capa_edad.json] + +- Lee `evaluacion_wf.json` (salida de `evaluar_wf.py`) y exige, por circuito, que `G_capa_edad.capa_activa` sea verdadera: + el IC95 de Δ log-loss frente a la capa de pendiente actual debe quedar por debajo de 0. Si un circuito no pasa, no + se le añade capa y se avisa. +- Añade `circuitos[c]["capa_edad"]` (b, β, escala, n, rango de temporadas) al JSON de hiperparámetros y lo escribe con su + propia huella sha256. Registrarlo como `artefacto_activo` (nueva `version_modelo`) es una decisión de despliegue aparte. +""" +import argparse +import json +import sys +from pathlib import Path + +from tenis.modelo import capa_edad as ce +from tenis.modelo import hiperparametros as hp + + +def main(): + ap = argparse.ArgumentParser() + ap.add_argument("--dir", required=True) + ap.add_argument("--salida", default="hiperparametros_capa_edad.json") + a = ap.parse_args() + carpeta = Path(a.dir) + hpj = hp.leer(carpeta / "hiperparametros.json") + informe = json.loads((carpeta / "evaluacion_wf.json").read_text(encoding="utf-8")) + if informe.get("sha256_hiperparametros") != hp.huella(hpj): + sys.exit("evaluacion_wf.json no corresponde a este hiperparametros.json (huellas distintas)") + puestas = [] + for c, r in informe["circuitos"].items(): + g = r["compuertas"].get("G_capa_edad") + if not g or not g["capa_activa"] or not r.get("capa_edad_final"): + print(f"{c}: la capa de edad NO pasa su compuerta; no se añade") + continue + capa = ce.CapaEdad.desde_dict(r["capa_edad_final"]) # valida rangos y finitud + hpj["circuitos"][c]["capa_edad"] = capa.como_dict() + puestas.append(c) + print(f"{c}: b={capa.pendiente:.4f} β={capa.beta:.4f} escala={capa.escala:.3f} años, n={capa.n}, " + f"temporadas {capa.desde}-{capa.hasta}; Δlog-loss {g['dif_logloss']:+.4f} [{g['lo']:+.4f}, {g['hi']:+.4f}]") + if not puestas: + sys.exit("ningún circuito pasa la compuerta: no se escribe artefacto") + hpj["nota_capa_edad"] = ("Capa de edad 17-nov-2026: logit π' = b·logit π + β·(Δedad/escala), sin intercepto; reemplaza la " + "pendiente de recalibración. Ver docs/tenis_capa_edad_20261117.md.") + sha = hp.escribir(carpeta / a.salida, hpj) + print(f"escrito {carpeta / a.salida} sha256_contenido={sha}") + + +if __name__ == "__main__": + main() diff --git a/apps/tenis/ops/evaluar_wf.py b/apps/tenis/ops/evaluar_wf.py index 531c1d74..6476327c 100644 --- a/apps/tenis/ops/evaluar_wf.py +++ b/apps/tenis/ops/evaluar_wf.py @@ -17,6 +17,7 @@ import numpy as np import pandas as pd +from tenis.modelo import capa_edad as ce from tenis.modelo import datos as dm from tenis.modelo import evaluacion as ev from tenis.modelo import hiperparametros as hp @@ -31,6 +32,7 @@ SALIDA = Path(r"C:\Users\huye\Documents\apuesta proyec\data\tennis\rediseno_20261104\modelo_s3") EVAL_DEFECTO, HASTA_DEFECTO, SEMILLA = (2019, 2024), 2024, 20261105 +DESDE_CAPA_EDAD = 2013 # la capa de edad se ajusta con las temporadas DESDE_CAPA_EDAD..T−1 (la edad escasea antes) COLS_PRED = ["partido_key", "circuito", "temporada", "corte_utc", "pi_lado1", "prior_ranking_1", "prior_ranking_2", "prior_ranking", "historia_corta", "fatiga_desconocida", "rho", "var_rho", "fatiga_1", "fatiga_2", "S_hat"] @@ -45,7 +47,7 @@ def sha_df(df: pd.DataFrame) -> str: return hashlib.sha256(buf.getvalue().encode("utf-8")).hexdigest() -def correr_circuito(d, cfg: dict, obs, eval_rango: tuple[int, int] = EVAL_DEFECTO) -> pd.DataFrame: +def correr_circuito(d, cfg: dict, obs, eval_rango: tuple[int, int] = EVAL_DEFECTO, edades: pd.DataFrame | None = None) -> pd.DataFrame: psi = Psi.desde_dict(cfg["psi_r"]) tabs = tabla.construir_todas(tuple(cfg["lbar"]), psi.sigma_eps, psi.rho_eps) tabs_c = tabla.construir_todas((cfg["lbar_comun"],) * 4, psi.sigma_eps, psi.rho_eps) @@ -75,6 +77,14 @@ def correr_circuito(d, cfg: dict, obs, eval_rango: tuple[int, int] = EVAL_DEFECT for col, base in (("pi_recal", "pi_lado1"), ("p_elo_cal", "p_elo")): f[col], bs = rc.por_temporada(f.temporada, f[base], f.y1, f.liquida & f[base].notna(), range(eval_rango[0], eval_rango[1] + 1), 2012) cfg.setdefault("_pendientes_recal", {})[col] = bs + # Capa de edad (17-nov): segunda etapa sobre π, ajustada solo con temporadas anteriores a cada evaluada. + if edades is not None: + f["edad_dif"] = ce.diferencia_edad(p.partido_key.map(edades.edad_1).to_numpy(), p.partido_key.map(edades.edad_2).to_numpy()) + f["pi_edad"], capas = ce.por_temporada(f.temporada, f.pi_lado1, f.edad_dif, f.y1, f.liquida & f.pi_lado1.notna(), + range(eval_rango[0], eval_rango[1] + 1), DESDE_CAPA_EDAD) + cfg["_capas_edad"] = {t: (c.como_dict() if c else None) for t, c in capas.items()} + sel = f.liquida & f.pi_lado1.notna() & (f.temporada >= DESDE_CAPA_EDAD) & (f.temporada <= eval_rango[1]) + cfg["_capa_edad_final"] = ce.ajustar(f.pi_lado1[sel], f.edad_dif[sel], f.y1[sel], DESDE_CAPA_EDAD, eval_rango[1]).como_dict() return f @@ -92,6 +102,15 @@ def evaluar(f: pd.DataFrame, cfg: dict, rng, reps: int, eval_rango: tuple[int, i else: out["comparaciones"][nombre] = ev.por_origen(s.temporada, y, pi, s[ref], rng, reps) out["calibracion"] = {c: ev.calibracion(y, s[c].to_numpy(), rng, reps) for c in ("pi_lado1", "p_elo_cal")} + if "pi_edad" in s and s.pi_edad.notna().all(): + out["metricas"]["pi_edad"] = ev.metricas(y, s.pi_edad.to_numpy()) + out["comparaciones"]["edad_vs_recal"] = ev.por_origen(s.temporada, y, s.pi_edad, s.pi_recal, rng, reps) + out["comparaciones"]["edad_vs_elo_recalibrado"] = ev.por_origen(s.temporada, y, s.pi_edad, s.p_elo_cal, rng, reps) + out["calibracion"]["pi_edad"] = ev.calibracion(y, s.pi_edad.to_numpy(), rng, reps) + con = s.edad_dif.notna().to_numpy() + out["capa_edad_por_conocimiento"] = { + nombre: ev.dif_bootstrap(y[m], s.pi_edad.to_numpy()[m], s.pi_recal.to_numpy()[m], rng, reps) + for nombre, m in (("con_edad", con), ("sin_edad", ~con)) if m.sum() >= 50} if s.pi_var_ch.notna().all(): out["variante_challenger"] = {"calibracion": ev.calibracion(y, s.pi_var_ch.to_numpy(), rng, reps), "vs_principal": ev.por_origen(s.temporada, y, s.pi_var_ch, pi, rng, reps)["combinado"]} @@ -148,7 +167,13 @@ def compuertas(r: dict) -> dict: cal = r["calibracion"]["pi_lado1"] rec = r["comparaciones"]["recal_menos_sin_capa"]["combinado"] bri = [v["brier"] for v in r["por_temporada_brier"].values() if v["n"] >= 500] + [r["metricas"]["pi_lado1"]["brier"]] - return {"G_linea_base": {"pasa": lb["hi"] <= 0.002, "objetivo_dif_negativa": lb["dif_logloss"] < 0, **lb}, + g_edad = {} + if "edad_vs_recal" in r["comparaciones"]: + ed = r["comparaciones"]["edad_vs_recal"]["combinado"] + malas = [t["temporada"] for t in r["comparaciones"]["edad_vs_recal"]["por_temporada"] if t["dif_logloss"] > 0] + # Regla (17-nov): se activa si el IC95 de Δ log-loss frente a la capa de pendiente EXCLUYE 0 por debajo. + g_edad = {"G_capa_edad": {"capa_activa": ed["hi"] < 0, "temporadas_que_empeoran": malas, **ed}} + return g_edad | {"G_linea_base": {"pasa": lb["hi"] <= 0.002, "objetivo_dif_negativa": lb["dif_logloss"] < 0, **lb}, "G_calibracion": {"pasa": bool(cal["pend_lo"] <= 1 <= cal["pend_hi"] and abs(cal["pendiente"] - 1) <= 0.10 and cal["int_lo"] <= 0 <= cal["int_hi"]), **cal}, "G_recalibracion": {"capa_activa": rec["hi"] < 0, **rec}, @@ -192,24 +217,28 @@ def main(): p, e = dm.cargar_export(hasta=a.hasta) stats = pd.read_parquet(dm.RUTA_EXPORT / "estadisticas_saque.parquet", columns=["partido_key", "lado", "puntos_saque", "puntos_saque_ganados", "visible_desde"]) + edades = pd.read_parquet(dm.RUTA_EXPORT / "partidos.parquet", columns=["partido_key", "edad_1", "edad_2"], + filters=[("temporada", "<=", int(a.hasta))]).drop_duplicates("partido_key").set_index("partido_key") rng = np.random.default_rng(SEMILLA) informe, preds, filas = {"sha256_hiperparametros": hp.huella(hpj), "reps": a.reps, "eval_rango": eval_rango, "hasta": a.hasta, "circuitos": {}}, [], [] for c in a.circuitos: cfg = hpj["circuitos"][c] d = dm.preparar(p, e, c, a.hasta) - f = correr_circuito(d, cfg, observaciones(d, stats), eval_rango) + f = correr_circuito(d, cfg, observaciones(d, stats), eval_rango, edades) t = f.temporada.to_numpy() pr = f[(t >= eval_rango[0]) & (t <= eval_rango[1]) & f.pi_lado1.notna()][COLS_PRED].reset_index(drop=True) r = evaluar(f, cfg, rng, a.reps, eval_rango) r["compuertas"] = compuertas(r) r["no_fuga"] = no_fuga(f) r["pendientes_recal"] = cfg.get("_pendientes_recal") + r["capa_edad_por_temporada"] = cfg.get("_capas_edad") + r["capa_edad_final"] = cfg.get("_capa_edad_final") r["union_muestra"] = muestra_union(f, cfg, rng, eval_rango=eval_rango) r[f"omitidos_{eval_rango[0]}_{eval_rango[1]}"] = f[(t >= eval_rango[0]) & (t <= eval_rango[1])].motivo.value_counts(dropna=False).rename( index=lambda k: k or "pronosticado").to_dict() r["sha256_predicciones"] = sha_df(pr) if a.repetir: - r["sha256_segunda_corrida"] = sha_df(correr_circuito(d, cfg, observaciones(d, stats), eval_rango) + r["sha256_segunda_corrida"] = sha_df(correr_circuito(d, cfg, observaciones(d, stats), eval_rango, edades) .pipe(lambda g: g[(g.temporada >= eval_rango[0]) & (g.temporada <= eval_rango[1]) & g.pi_lado1.notna()][COLS_PRED].reset_index(drop=True))) informe["circuitos"][c] = r diff --git a/apps/tenis/ops/registrar_artefacto.py b/apps/tenis/ops/registrar_artefacto.py new file mode 100644 index 00000000..1d52eef4 --- /dev/null +++ b/apps/tenis/ops/registrar_artefacto.py @@ -0,0 +1,75 @@ +"""Registra o reactiva un artefacto del motor de tenis (plan §H.1, §H.4). Por omisión solo VALIDA y muestra el plan (sin tocar la base). + + python apps/tenis/ops/registrar_artefacto.py validar --json apps/tenis/artefactos/tenis-2.1-capa-edad.json \ + --informe [--menor 1] + python apps/tenis/ops/registrar_artefacto.py registrar --json ... --informe ... --imagen tenis-motor: \ + --aprobado-en-chat "" [--dsn | PG_DSN] [--esquema tenis] --ejecutar + python apps/tenis/ops/registrar_artefacto.py reactivar --sha256 --imagen tenis-motor: \ + --aprobado-en-chat "" --ejecutar # vuelta atrás + +`registrar` y `reactivar` sin `--ejecutar` solo imprimen lo que harían. Con `--ejecutar` exigen el OK escrito del titular. +El DSN debe ser de un rol que pueda INSERTAR en artefacto y artefacto_activo (el motor solo lee). Nunca se imprime el DSN. +""" +import argparse +import json +import os +import re +import sys +from pathlib import Path + +import psycopg + +from tenis import artefactos as art + + +def _conectar(a): + if not a.dsn: + sys.exit("falta --dsn o PG_DSN") + if not re.fullmatch(r"[a-z_][a-z0-9_]*", a.esquema): + sys.exit("nombre de esquema no válido") + db = psycopg.connect(a.dsn, autocommit=True) + db.execute(f"SET search_path TO {a.esquema}, public") + return db + + +def main(argv=None) -> int: + ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) + ap.add_argument("accion", choices=["validar", "registrar", "reactivar"]) + ap.add_argument("--json", type=Path) + ap.add_argument("--informe", type=Path) + ap.add_argument("--menor", type=int, default=1) + ap.add_argument("--sha256") + ap.add_argument("--imagen") + ap.add_argument("--aprobado-en-chat", default="") + ap.add_argument("--dsn", default=os.environ.get("PG_DSN")) + ap.add_argument("--esquema", default="tenis") + ap.add_argument("--ejecutar", action="store_true") + a = ap.parse_args(argv) + + if a.accion in ("validar", "registrar"): + if not a.json or not a.informe: + sys.exit("--json e --informe son obligatorios") + plan = art.validar(a.json, a.informe, a.menor) + print(json.dumps({k: plan[k] for k in ("sha256", "version_modelo", "capa_edad", "advertencias")}, indent=1, ensure_ascii=False)) + if a.accion == "validar": + return 0 + print(f"imagen: {a.imagen}\naprobado_en_chat: {a.aprobado_en_chat!r}") + if not a.ejecutar: + print("(sin --ejecutar: no se ha tocado la base)") + return 0 + with _conectar(a) as db: + print(json.dumps(art.registrar(db, plan, a.imagen, a.aprobado_en_chat), indent=1, default=str, ensure_ascii=False)) + return 0 + + if not a.sha256: + sys.exit("--sha256 es obligatorio") + if not a.ejecutar: + print(f"reactivaría {a.sha256} con la imagen {a.imagen} (sin --ejecutar: no se ha tocado la base)") + return 0 + with _conectar(a) as db: + print(json.dumps(art.reactivar(db, a.sha256, a.imagen, a.aprobado_en_chat), indent=1, default=str, ensure_ascii=False)) + return 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/apps/tenis/src/tenis/artefactos.py b/apps/tenis/src/tenis/artefactos.py new file mode 100644 index 00000000..0cc5245a --- /dev/null +++ b/apps/tenis/src/tenis/artefactos.py @@ -0,0 +1,113 @@ +"""Registro y activación de artefactos del motor (plan §H.1, §H.2, §H.4). + +- `validar`: comprueba un artefacto de hiperparámetros ANTES de registrarlo (huella, estructura, compuertas del informe) y + construye el plan de registro. No toca la base. +- `registrar`: inserta el artefacto y su activación en una sola transacción. Exige el texto del OK del titular en el chat + (`aprobado_en_chat`) y una imagen `tenis-motor:`. Solo anexa filas (las tablas son inmutables). +- `reactivar`: vuelta atrás = OTRA fila de activación que apunta a un artefacto ya registrado (plan §H.4). +La base solo la escribe un rol administrador; el motor (`tenis_motor`) únicamente lee estas tablas. +""" +from __future__ import annotations + +import json +import re +from pathlib import Path +from typing import Any + +from tenis.modelo import hiperparametros as hp +from tenis.modelo.capa_edad import CapaEdad +from tenis.modelo.parametros import Psi +from tenis.modelo.puntos import PsiP + +IMAGEN = re.compile(r"^tenis-motor:[A-Za-z0-9._-]+$") +TIPO = "modelo" + + +def version_modelo(sha256: str, menor: int) -> str: + """Plan §H.2: `tenis-2.+`.""" + return f"tenis-2.{int(menor)}+{sha256[:12]}" + + +def _base_sin_capa(contenido: dict) -> dict: + """El mismo contenido sin la capa de edad: debe coincidir con el artefacto que se evaluó.""" + base = json.loads(json.dumps(contenido)) + base.pop("nota_capa_edad", None) + for cfg in base["circuitos"].values(): + cfg.pop("capa_edad", None) + return base + + +def validar(ruta_json: Path, ruta_informe: Path, menor: int = 1) -> dict[str, Any]: + """Plan de registro de un artefacto. Lanza ValueError si algo impide registrarlo; las advertencias no bloquean.""" + contenido = hp.leer(Path(ruta_json)) # falla si la huella declarada no coincide + sha = hp.huella(contenido) + advertencias: list[str] = [] + resumen: dict[str, Any] = {} + for c, cfg in contenido["circuitos"].items(): + for clave in ("psi_r", "psi_p", "lbar"): + if clave not in cfg: + raise ValueError(f"{c}: falta {clave}") + Psi.desde_dict(cfg["psi_r"]) + PsiP(**{k: (tuple(v) if isinstance(v, list) else v) for k, v in cfg["psi_p"].items()}) + resumen[c] = {"capa_edad": CapaEdad.desde_dict(cfg["capa_edad"]).como_dict() if cfg.get("capa_edad") else None} + + informe = json.loads(Path(ruta_informe).read_text(encoding="utf-8")) + if informe["sha256_hiperparametros"] != hp.huella(_base_sin_capa(contenido)): + raise ValueError("el informe de compuertas no corresponde a los hiperparámetros base de este artefacto") + compuertas: dict[str, Any] = {} + for c, r in informe["circuitos"].items(): + g = r["compuertas"] + if not g["G_linea_base"]["pasa"] or not g["G_cordura"]["pasa"]: + raise ValueError(f"{c}: no pasa G_linea_base o G_cordura") + if resumen.get(c, {}).get("capa_edad") and not g.get("G_capa_edad", {}).get("capa_activa"): + raise ValueError(f"{c}: el artefacto trae capa de edad pero no pasa G_capa_edad") + if not g["G_calibracion"]["pasa"]: + advertencias.append(f"{c}: G_calibracion no pasa (pendiente {r['calibracion']['pi_lado1']['pendiente']:.3f} antes de la capa)") + compuertas[c] = {k: v for k, v in g.items() if k != "G_recalibracion"} | { + "n_evaluados": r["n_evaluados"], "no_fuga_violaciones": r["no_fuga"]["violaciones"]} + informe_compuertas = {"sha256_hiperparametros_base": informe["sha256_hiperparametros"], "eval_rango": informe["eval_rango"], + "sha256_predicciones_base": informe["sha256_predicciones_total"], "circuitos": compuertas} + return {"sha256": sha, "version_modelo": version_modelo(sha, menor), "tipo": TIPO, "informe_compuertas": informe_compuertas, + "capa_edad": {c: v["capa_edad"] for c, v in resumen.items()}, "advertencias": advertencias} + + +def activo(db: Any) -> dict | None: + fila = db.execute("SELECT a.sha256, a.version_modelo, aa.imagen, aa.activado_en FROM artefacto_activo aa " + "JOIN artefacto a ON a.sha256 = aa.sha256 ORDER BY aa.activo_id DESC LIMIT 1").fetchone() + return None if not fila else {"sha256": fila[0], "version_modelo": fila[1], "imagen": fila[2], "activado_en": fila[3]} + + +def _exigir_aprobacion(aprobado_en_chat: str, imagen: str) -> None: + if not aprobado_en_chat or not aprobado_en_chat.strip(): + raise ValueError("falta el OK del titular en el chat (aprobado_en_chat)") + if not IMAGEN.match(imagen or ""): + raise ValueError("imagen debe ser el nombre completo tenis-motor:") + + +def registrar(db: Any, plan: dict, imagen: str, aprobado_en_chat: str) -> dict: + """Inserta el artefacto (si no existe) y su activación, en una transacción. Devuelve el artefacto activo resultante.""" + _exigir_aprobacion(aprobado_en_chat, imagen) + previo = activo(db) + if previo and previo["sha256"] == plan["sha256"] and previo["imagen"] == imagen: + raise ValueError("ese artefacto ya está activo con esa imagen") + with db.transaction(): + db.execute("INSERT INTO artefacto (sha256, tipo, version_modelo, informe_compuertas) VALUES (%s, %s, %s, %s::jsonb) " + "ON CONFLICT (sha256) DO NOTHING", + (plan["sha256"], plan["tipo"], plan["version_modelo"], json.dumps(plan["informe_compuertas"]))) + db.execute("INSERT INTO artefacto_activo (sha256, aprobado_en_chat, imagen) VALUES (%s, %s, %s)", + (plan["sha256"], aprobado_en_chat.strip(), imagen)) + ahora = activo(db) + if not ahora or ahora["sha256"] != plan["sha256"]: + raise RuntimeError("la activación no quedó registrada") + return ahora | {"anterior": previo} + + +def reactivar(db: Any, sha256: str, imagen: str, aprobado_en_chat: str) -> dict: + """Vuelta atrás: activa de nuevo un artefacto YA registrado (otra fila, nunca un UPDATE).""" + _exigir_aprobacion(aprobado_en_chat, imagen) + if not db.execute("SELECT 1 FROM artefacto WHERE sha256 = %s", (sha256,)).fetchone(): + raise ValueError("ese artefacto no está registrado") + previo = activo(db) + db.execute("INSERT INTO artefacto_activo (sha256, aprobado_en_chat, imagen) VALUES (%s, %s, %s)", + (sha256, aprobado_en_chat.strip(), imagen)) + return activo(db) | {"anterior": previo} diff --git a/apps/tenis/src/tenis/datos/exportar_pit.py b/apps/tenis/src/tenis/datos/exportar_pit.py index 556931ce..33e04255 100644 --- a/apps/tenis/src/tenis/datos/exportar_pit.py +++ b/apps/tenis/src/tenis/datos/exportar_pit.py @@ -293,6 +293,8 @@ def marcar(mask, texto): for lado in (1, 2): K = K.merge(nac.rename(columns={"jugador_id": f"jugador_{lado}", "nacimiento": f"nac_{lado}"}), on=f"jugador_{lado}", how="left") + if K[f"nac_{lado}"].dtype == object: # base sin ninguna fecha de nacimiento: columna vacía de tipo object + K[f"nac_{lado}"] = pd.to_datetime(K[f"nac_{lado}"]) K[f"edad_{lado}"] = ((K["fecha_partido"] - K[f"nac_{lado}"]).dt.days / 365.25).round(3) # ---- ranking «as of» diff --git a/apps/tenis/src/tenis/inferencia.py b/apps/tenis/src/tenis/inferencia.py new file mode 100644 index 00000000..bc6a09a7 --- /dev/null +++ b/apps/tenis/src/tenis/inferencia.py @@ -0,0 +1,127 @@ +"""Inferencia del motor: reproduce el filtro con Ψ congelado desde la evidencia de la base (plan §H.1, §H.2). + +El motor nunca ajusta Ψ. Para pronosticar un partido futuro: +1. lee la evidencia COMPLETA en una transacción de solo lectura (`datos.lectura.leer_todo`); +2. la convierte en el mismo conjunto punto-en-el-tiempo que se usó para entrenar y evaluar (`exportar_pit.construir`), + pasado por Parquet en memoria para que los tipos sean idénticos a los del walk-forward; +3. corre el MISMO filtro (R) y la pieza P que `ops/evaluar_wf.py` y toma, para cada partido pedido, π, Var(ρ) y Ŝ. + +No hay valores por omisión: si el partido no se puede pronosticar (jugador sin historia ni ranking, superficie o formato +desconocido, fuera de la exportación...), se devuelve el motivo y el motor no sella (plan D.6: nunca un promedio silencioso). +El corte de cada partido es el de la exportación (inicio programado − 60 min), que es también el del sellado en vivo. +""" +from __future__ import annotations + +import io +import math +from datetime import date +from typing import Any + +import pandas as pd +import pyarrow.parquet as pq + +from tenis.datos import exportar_pit as xp +from tenis.datos.lectura import leer_todo +from tenis.modelo import datos as dm +from tenis.modelo import tabla +from tenis.modelo.parametros import Psi +from tenis.modelo.puntos import PsiP, filtrar_p, observaciones +from tenis.modelo.rating import filtrar +from tenis.modelo.rating_completo import filtrar_completo + +# Ventana de la exportación con la que se ajustó y evaluó el modelo (`exportar_pit_cli.py --desde 2005-01-01`). El filtro +# parte de 2005; con más historia las probabilidades cambiarían (medido: hasta 0,045), así que se usa la misma ventana. +DESDE_EXPORTACION = date(2005, 1, 1) + +COLUMNAS_SALIDA = ["partido_key", "partido_id_tml", "partido_id_sofascore", "jugador_1", "jugador_2", "fmt", "pi", "var_rho", + "s_hat", "motivo", "prior_ranking", "historia_corta", "fatiga_desconocida"] + + +def _por_parquet(df: pd.DataFrame) -> pd.DataFrame: + """Mismos tipos que al leer los ficheros de la exportación (la ruta validada).""" + buf = io.BytesIO() + pq.write_table(xp._tabla_arrow(df), buf) + buf.seek(0) + return pd.read_parquet(buf) + + +def _flotante(serie: pd.Series): + """Ids con posibles nulos → float con NaN (las comparaciones con un id entero nunca dan NA).""" + return pd.to_numeric(serie, errors="coerce").astype("Float64").to_numpy(dtype="float64", na_value=float("nan")) + + +def conjunto_desde_db(db: Any) -> tuple[pd.DataFrame, pd.DataFrame, pd.DataFrame]: + """(partidos, eventos_resultado, estadisticas_saque) del estado actual de la base, solo lectura.""" + with db.transaction(): + db.execute("SET TRANSACTION READ ONLY") + db.execute("SET LOCAL TIME ZONE 'UTC'") + tablas = leer_todo(db) + tablas["sin_resolver_conteo"] = {f"{f}:{m}": n for f, m, n in db.execute( + "SELECT fuente, motivo, count(*) FROM sin_resolver GROUP BY 1, 2 ORDER BY 1, 2").fetchall()} + salidas = xp.construir(tablas, DESDE_EXPORTACION) + return tuple(_por_parquet(salidas[k]) for k in ("partidos", "eventos_resultado", "estadisticas_saque")) + + +def pronosticar_circuito(p: pd.DataFrame, e: pd.DataFrame, stats: pd.DataFrame, cfg: dict, circuito: str) -> pd.DataFrame: + """Filtro R + pieza P con Ψ congelado sobre TODO el conjunto del circuito. Una fila por partido (orden de la exportación).""" + d = dm.preparar(p, e, circuito, 9999) + if d.p.empty: + return pd.DataFrame(columns=COLUMNAS_SALIDA) + psi = Psi.desde_dict(cfg["psi_r"]) + tabs = tabla.construir_todas(tuple(cfg["lbar"]), psi.sigma_eps, psi.rho_eps) + fil = filtrar_completo if cfg.get("filtro") == "covarianza_completa" else filtrar + sal = fil(d, psi, tabs) + psip = PsiP(**{k: (tuple(v) if isinstance(v, list) else v) for k, v in cfg["psi_p"].items()}) + _, s_hat, _ = filtrar_p(d, observaciones(d, stats), psip) + q = d.p + return pd.DataFrame({ + "partido_key": q.partido_key.to_numpy(), "partido_id_tml": _flotante(q.partido_id_tml), + "partido_id_sofascore": _flotante(q.partido_id_sofascore), "jugador_1": q.jugador_1.to_numpy(), + "jugador_2": q.jugador_2.to_numpy(), "fmt": q.fmt.to_numpy(), "pi": sal.pi, "var_rho": sal.var_rho, + "s_hat": s_hat, "motivo": sal.motivo, "prior_ranking": sal.prior1 | sal.prior2, + "historia_corta": (q.n_prev_1.fillna(0) < 20).to_numpy() | (q.n_prev_2.fillna(0) < 20).to_numpy(), + "fatiga_desconocida": sal.fat_desc}) + + +def _fila(pron: pd.DataFrame, partido_id: int): + for col in ("partido_id_sofascore", "partido_id_tml"): + sel = pron[pron[col] == partido_id] + if len(sel): + return sel.iloc[0] + return None + + +def resolver(pron: pd.DataFrame, partido: dict) -> dict: + """Resultado para UN partido de la base (orientado como `partido.jugador_1`), o el motivo por el que no se puede.""" + fila = _fila(pron, partido["partido_id"]) + if fila is None: + return {"ok": False, "motivo": "fuera_de_la_exportacion"} + if pd.notna(fila.motivo) and fila.motivo: # pandas 3 guarda NaN (no None) donde no hay motivo + return {"ok": False, "motivo": str(fila.motivo)} + if {int(fila.jugador_1), int(fila.jugador_2)} != {int(partido["jugador_1"]), int(partido["jugador_2"])}: + return {"ok": False, "motivo": "jugadores_no_coinciden"} + if not (math.isfinite(fila.pi) and math.isfinite(fila.var_rho)): + return {"ok": False, "motivo": "pi_no_finito"} + if not math.isfinite(fila.s_hat): + return {"ok": False, "motivo": "sin_s_hat"} + pi = float(fila.pi) if int(fila.jugador_1) == int(partido["jugador_1"]) else 1.0 - float(fila.pi) # la exportación orienta los lados al azar + return {"ok": True, "motivo": None, "pi_lado1": pi, "var_rho": float(fila.var_rho), "s_hat": float(fila.s_hat), + "fmt": int(fila.fmt), "prior_ranking": bool(fila.prior_ranking), "historia_corta": bool(fila.historia_corta), + "fatiga_desconocida": bool(fila.fatiga_desconocida), "partido_key": str(fila.partido_key)} + + +def inferir(db: Any, parametros: dict, partidos: list[dict]) -> dict[int, dict]: + """partido_id → resultado de `resolver`. Una sola lectura de la base y un filtro por circuito presente.""" + if not partidos: + return {} + p, e, stats = conjunto_desde_db(db) + out: dict[int, dict] = {} + for circ in sorted({x["circuito"].lower() for x in partidos}): + grupo = [x for x in partidos if x["circuito"].lower() == circ] + cfg = (parametros.get("circuitos") or {}).get(circ) + if not cfg or "psi_r" not in cfg or "psi_p" not in cfg or "lbar" not in cfg: + out.update({x["partido_id"]: {"ok": False, "motivo": "sin_parametros_del_circuito"} for x in grupo}) + continue + pron = pronosticar_circuito(p, e, stats, cfg, circ) + out.update({x["partido_id"]: resolver(pron, x) for x in grupo}) + return out diff --git a/apps/tenis/src/tenis/modelo/capa_edad.py b/apps/tenis/src/tenis/modelo/capa_edad.py new file mode 100644 index 00000000..de9891ee --- /dev/null +++ b/apps/tenis/src/tenis/modelo/capa_edad.py @@ -0,0 +1,120 @@ +"""Capa de edad (17-nov-2026): segunda etapa sobre π del filtro congelado. + + logit π' = b · logit π + β · z, z = (edad_1 − edad_2) / escala + +- Sin intercepto: los lados están en orden pseudoaleatorio, así que π'(A, B) + π'(B, A) = 1 por construcción. +- Edad desconocida (cualquiera de los dos jugadores, o fuera de [14, 50] años) ⇒ z = 0: solo actúa la pendiente b. + Medido en el walk-forward 2019-24: sin edad conocida la capa cambia el log-loss en 0,0000. +- `b` absorbe la recalibración de pendiente que ya existía (`recalibracion.py`); esta capa la REEMPLAZA, no se apila. +- Se ajusta SOLO con temporadas anteriores a la evaluada (`por_temporada`) y se congela para producción con + `ajustar` sobre todo el histórico liquidado. No toca el filtro, el simulador ni los triggers de la base de datos. +- `β` no tiene signo impuesto: lo estima la verosimilitud (en los datos sale negativo: el jugador más joven rinde + por encima de lo que su rating anticipa). +""" +import math +from dataclasses import asdict, dataclass + +import numpy as np + +from .recalibracion import logit + +EDAD_MIN, EDAD_MAX = 14.0, 50.0 # fuera de este rango la fecha de nacimiento se trata como desconocida +DIF_MAX = 20.0 # |edad_1 − edad_2| se recorta aquí (casos raros; el ajuste ya lo incluye) +MIN_FILAS = 2000 # menos partidos liquidados que esto no sostienen el ajuste +ITERACIONES = 50 + + +@dataclass(frozen=True) +class CapaEdad: + pendiente: float # b: pendiente sobre logit π + beta: float # β: efecto por desviación estándar de la diferencia de edad (en logit) + escala: float # desviación estándar de la diferencia de edad en la muestra de ajuste (años) + n: int # partidos liquidados del ajuste + desde: int # primera y última temporada del ajuste + hasta: int + + def __post_init__(self): + if not all(math.isfinite(x) for x in (self.pendiente, self.beta, self.escala)): + raise ValueError("la capa de edad exige coeficientes finitos") + if not (0.0 < self.pendiente <= 3.0): + raise ValueError("pendiente b fuera de (0, 3]") + if abs(self.beta) > 2.0: + raise ValueError("|β| > 2: el ajuste no es creíble") + if not self.escala > 0.0: + raise ValueError("escala de la edad debe ser > 0") + + def como_dict(self) -> dict: + return asdict(self) + + @classmethod + def desde_dict(cls, d: dict) -> "CapaEdad": + return cls(**{k: d[k] for k in ("pendiente", "beta", "escala", "n", "desde", "hasta")}) + + +def diferencia_edad(edad_1, edad_2): + """edad_1 − edad_2 recortada a ±DIF_MAX; NaN si falta alguna o está fuera de [EDAD_MIN, EDAD_MAX].""" + a, b = np.asarray(edad_1, dtype=float), np.asarray(edad_2, dtype=float) + ok = (np.isfinite(a) & np.isfinite(b) & (a >= EDAD_MIN) & (a <= EDAD_MAX) & (b >= EDAD_MIN) & (b <= EDAD_MAX)) + return np.where(ok, np.clip(a - b, -DIF_MAX, DIF_MAX), np.nan) + + +def _z(dedad, escala: float) -> np.ndarray: + return np.nan_to_num(np.asarray(dedad, dtype=float), nan=0.0) / escala + + +def _newton(x: np.ndarray, y: np.ndarray) -> np.ndarray: + """Máxima verosimilitud de y ~ Bernoulli(expit(X·c)); c arranca en (1, 0).""" + c = np.array([1.0, 0.0]) + for _ in range(ITERACIONES): + q = 1 / (1 + np.exp(-(x @ c))) + w = q * (1 - q) + g = x.T @ (y - q) + h = (x * w[:, None]).T @ x + 1e-9 * np.eye(2) + paso = np.linalg.solve(h, g) + c = c + paso + if np.max(np.abs(paso)) < 1e-10: + break + return c + + +def ajustar(pi, dedad, y, desde: int = 0, hasta: int = 0) -> CapaEdad: + """Ajusta (b, β) con los partidos dados. `y` ∈ {0, 1}; `dedad` con NaN donde no se conoce.""" + pi, dedad, y = (np.asarray(v, dtype=float) for v in (pi, dedad, y)) + ok = np.isfinite(pi) & ((y == 0) | (y == 1)) & (pi > 0) & (pi < 1) + if int(ok.sum()) < MIN_FILAS: + raise ValueError(f"capa de edad: {int(ok.sum())} partidos liquidados (mínimo {MIN_FILAS})") + conocida = ok & np.isfinite(dedad) + escala = float(np.std(dedad[conocida])) if conocida.sum() > 1 else 0.0 + if not escala > 0.0: + raise ValueError("capa de edad: sin diferencias de edad conocidas en la muestra de ajuste") + x = np.column_stack([logit(pi[ok]), _z(dedad[ok], escala)]) + c = _newton(x, y[ok]) + return CapaEdad(pendiente=float(c[0]), beta=float(c[1]), escala=escala, n=int(ok.sum()), desde=int(desde), + hasta=int(hasta)) + + +def aplicar(pi, dedad, capa: CapaEdad): + """π' con la capa. Conserva NaN de π; edad desconocida ⇒ z = 0.""" + pi = np.asarray(pi, dtype=float) + z = capa.pendiente * logit(np.where(np.isfinite(pi), pi, 0.5)) + capa.beta * _z(dedad, capa.escala) + return np.where(np.isfinite(pi), 1 / (1 + np.exp(-z)), np.nan) + + +def por_temporada(temporada, pi, dedad, y, liquida, evaluar, desde: int): + """Para cada temporada T evaluada: capa ajustada con las temporadas desde..T−1 (liquidadas) y aplicada a T. + + Devuelve (π', {T: CapaEdad | None}). Con menos de MIN_FILAS antes de T no se ajusta: π' = NaN para esa temporada. + """ + temporada, pi, dedad, y, liquida = (np.asarray(v) for v in (temporada, pi, dedad, y, liquida)) + out, capas = np.full(len(pi), np.nan), {} + for t in evaluar: + tr = liquida.astype(bool) & (temporada >= desde) & (temporada < t) & np.isfinite(pi.astype(float)) + try: + capa = ajustar(pi[tr], dedad[tr], y[tr], desde, int(t) - 1) + except ValueError: + capas[int(t)] = None + continue + sel = temporada == t + out[sel] = aplicar(pi[sel], dedad[sel], capa) + capas[int(t)] = capa + return out, capas diff --git a/apps/tenis/src/tenis/motor.py b/apps/tenis/src/tenis/motor.py index 840fd5bc..83615d1f 100644 --- a/apps/tenis/src/tenis/motor.py +++ b/apps/tenis/src/tenis/motor.py @@ -13,12 +13,17 @@ import argparse import json import logging +import math +import os +import re from datetime import datetime, timedelta, timezone from pathlib import Path from typing import Any from tenis.alertas import enviar_alerta -from tenis.modelo.datos import FORMATOS, indice_formato +from tenis.modelo import capa_edad +from tenis.inferencia import inferir +from tenis.modelo.datos import FORMATOS from tenis.modelo.hiperparametros import huella from tenis.modelo.union import sigma_m, unir from tenis.sellado import redondear_distribucion, sellar_pronostico @@ -28,6 +33,8 @@ log = logging.getLogger(__name__) UTC = timezone.utc +# Artefactos congelados que viajan en la imagen del motor (apps/tenis/artefactos/); `TENIS_ARTEFACTOS_DIR` lo sobrescribe. +DIRECTORIO_ARTEFACTOS = Path(__file__).resolve().parents[2] / "artefactos" def cargar_artefacto_activo(db: Any, ruta_directorio: Path | None = None) -> dict[str, Any]: @@ -43,37 +50,54 @@ def cargar_artefacto_activo(db: Any, ruta_directorio: Path | None = None) -> dic sha256_esperado, tipo, version_modelo, imagen = row - # Si se proporciona directorio o se busca en ubicaciones conocidas - rutas_candidatas = [] - if ruta_directorio: - rutas_candidatas.extend(list(ruta_directorio.glob("*.json"))) - - rutas_candidatas.extend([ - Path(r"C:\Users\huye\Documents\apuesta proyec\data\tennis\rediseno_20261104\modelo_s3\hiperparametros.json"), - Path("hiperparametros.json"), - ]) - - for r in rutas_candidatas: - if r.exists(): - try: - datos = json.loads(r.read_text(encoding="utf-8")) - copia = dict(datos) - copia.pop("sha256_contenido", None) - if huella(copia) == sha256_esperado: - return {"version_modelo": version_modelo, "sha256": sha256_esperado, "parametros": datos} - except Exception: - continue - - # Si no se encuentra archivo con esa huella, pero se dispone de los hiperparámetros por defecto - for r in rutas_candidatas: - if r.exists(): - try: - datos = json.loads(r.read_text(encoding="utf-8")) - return {"version_modelo": version_modelo, "sha256": sha256_esperado, "parametros": datos} - except Exception: - pass - - raise FileNotFoundError(f"No se encontró el fichero JSON del artefacto activo {sha256_esperado}") + # Plan §H.2: la huella se recalcula al arrancar; si ningún fichero coincide con la registrada, el motor NO sella. + # Sin ruta fija ni respaldo: solo ficheros dentro del directorio de artefactos de la imagen (o el pasado por parámetro). + directorio = ruta_directorio or Path(os.environ.get("TENIS_ARTEFACTOS_DIR") or DIRECTORIO_ARTEFACTOS) + for r in sorted(directorio.glob("*.json")): + try: + datos = json.loads(r.read_text(encoding="utf-8")) + except (OSError, ValueError): + continue + copia = dict(datos) + declarada = copia.pop("sha256_contenido", None) + if huella(copia) == sha256_esperado and declarada in (None, sha256_esperado): + return {"version_modelo": version_modelo, "sha256": sha256_esperado, "parametros": datos} + + raise FileNotFoundError(f"Ningún fichero de {directorio} tiene la huella del artefacto activo {sha256_esperado}") + + +def edades_al_corte(db: Any, jugador_1: int, jugador_2: int, corte: datetime) -> tuple[float | None, float | None]: + """Edad (años) de cada jugador en la fecha del corte, con la misma regla que la exportación PIT: aserción + `fecha_nacimiento` visible en el corte, la de mayor prioridad de fuente y, a igualdad, la más reciente. + (fecha_corte − nacimiento) / 365,25; sin fecha de nacimiento → None.""" + out = [] + for j in (jugador_1, jugador_2): + row = db.execute( + "SELECT a.valor FROM jugador_asercion a JOIN fuente f ON f.fuente = a.fuente " + "WHERE a.jugador_id = %s AND a.campo = 'fecha_nacimiento' AND a.recibido_en <= %s " + "ORDER BY f.prioridad_calendario ASC, a.recibido_en DESC, a.asercion_id DESC LIMIT 1", + (j, corte), + ).fetchone() + try: + nac = datetime.strptime(row[0], "%Y-%m-%d").replace(tzinfo=UTC) if row else None + except (TypeError, ValueError): + nac = None + out.append(None if nac is None else (corte - nac).days / 365.25) + return out[0], out[1] + + +def aplicar_capa_edad(pi_lado1: float, edad_1: float | None, edad_2: float | None, circ_params: dict[str, Any]) -> tuple[float, dict]: + """Aplica la capa de edad del artefacto (si la trae) a π del lado 1. Devuelve (π', trazas para las entradas selladas). + + Sin `capa_edad` en el artefacto, π pasa intacta. Edad desconocida: solo actúa la pendiente de la capa.""" + cfg = circ_params.get("capa_edad") + if not cfg: + return pi_lado1, {} # sin capa: las entradas selladas quedan como antes + capa = capa_edad.CapaEdad.desde_dict(cfg) + dif = capa_edad.diferencia_edad(float("nan") if edad_1 is None else edad_1, float("nan") if edad_2 is None else edad_2) + pi = float(capa_edad.aplicar(pi_lado1, dif, capa)) + return pi, {"capa_edad": True, "pi_base": round(pi_lado1, 6), + "edad_dif": None if math.isnan(float(dif)) else round(float(dif), 3)} def buscar_partidos_pendientes( @@ -112,8 +136,12 @@ def simular_y_sellar_partido( parametros: dict[str, Any], forzar_corte: datetime | None = None, dry_run: bool = False, + inferencia: dict[str, Any] | None = None, ) -> dict[str, Any]: - """Ejecuta inferencia con parámetros congelados y sella el pronóstico.""" + """Ejecuta inferencia con parámetros congelados y sella el pronóstico. + + `inferencia` (resultado de `tenis.inferencia.resolver` para este partido) la calcula la pasada del motor una sola vez para + todos los partidos en ventana; si no se pasa, se calcula aquí solo para este partido.""" partido_id = partido["partido_id"] t_ref = partido["inicio_programado_utc"] if not t_ref.tzinfo: @@ -132,23 +160,24 @@ def simular_y_sellar_partido( circ = partido["circuito"].lower() circ_params = parametros.get("circuitos", {}).get(circ, {}) - psi_p = circ_params.get("psi_p", {}) - psi_r = circ_params.get("psi_r", {}) - - sig_eps = float(psi_p.get("sigma_eps", 0.179)) - rho_eps = float(psi_p.get("rho_eps", -0.733)) - c_inf = float(circ_params.get("c_inf", 0.020)) - - mejor_de = int(partido.get("mejor_de", 3)) - decisivo = "tiebreak_7" if mejor_de == 3 else "tiebreak_10" - fmt_idx = indice_formato(mejor_de, decisivo) - if fmt_idx < 0: - fmt_idx = 0 - - # Inferencia simplificada de demostración si no hay ratings previos cargados - s_hat = 1.25 - pi_lado1 = 0.585 - var_rho = 0.009 + + # Inferencia REAL: filtro con Ψ congelado reproducido desde la evidencia (tenis.inferencia). Sin valores por omisión. + if inferencia is None: + inferencia = inferir(db, parametros, [partido]).get(partido_id, {"ok": False, "motivo": "sin_inferencia"}) + if not inferencia.get("ok"): + motivo = inferencia.get("motivo", "desconocido") + enviar_alerta("jugador_sin_historia" if motivo == "sin_historia_ni_ranking" else "sin_pronostico", + f"Partido {partido_id} sin pronóstico: {motivo}", partido_id=partido_id) + return {"estado": "omitido_sin_modelo", "partido_id": partido_id, "motivo": motivo} + + psi_r = circ_params["psi_r"] + sig_eps, rho_eps, c_inf = float(psi_r["sigma_eps"]), float(psi_r["rho_eps"]), float(psi_r.get("c_inf", 0.0)) + mejor_de, decisivo = FORMATOS[inferencia["fmt"]] + fmt_idx = inferencia["fmt"] + s_hat, pi_lado1, var_rho = inferencia["s_hat"], inferencia["pi_lado1"], inferencia["var_rho"] + # Capa de edad (17-nov-2026): solo si el artefacto activo la incluye. Las edades se leen al corte, en vivo. + e1, e2 = edades_al_corte(db, partido["jugador_1"], partido["jugador_2"], corte) if circ_params.get("capa_edad") else (None, None) + pi_lado1, traza_edad = aplicar_capa_edad(pi_lado1, e1, e2, circ_params) var_pred = var_rho + c_inf u = unir(s_hat, pi_lado1, fmt_idx, sig_eps, rho_eps, var_pred) @@ -171,7 +200,12 @@ def simular_y_sellar_partido( "S_hat": round(s_hat, 4), "pi_modelo": round(pi_lado1, 6), "var_pred": round(var_pred, 6), - } + "formato": f"mejor_de_{mejor_de}_{decisivo}", + "prior_ranking": inferencia["prior_ranking"], + "historia_corta": inferencia["historia_corta"], + "fatiga_desconocida": inferencia["fatiga_desconocida"], + "fuente_pi": "filtro_psi_congelado", + } | traza_edad # Buscar referencia de mercado a la fecha de corte ref_row = db.execute( @@ -203,6 +237,16 @@ def simular_y_sellar_partido( return {"estado": "sellado", "partido_id": partido_id, "hash": h} +def _en_ventana(partido: dict[str, Any], ahora: datetime, forzar_corte: datetime | None) -> bool: + """¿Toca sellar este partido ahora? Mismas reglas que `simular_y_sellar_partido` antes de inferir.""" + t_ref = partido["inicio_programado_utc"] + if not t_ref.tzinfo: + t_ref = t_ref.replace(tzinfo=UTC) + if forzar_corte is not None: + return True + return (t_ref - timedelta(minutes=60)) <= ahora < t_ref + + def ejecutar_pasada_motor( db: Any, version_datos: str = "d_actual", @@ -210,11 +254,26 @@ def ejecutar_pasada_motor( dry_run: bool = False, ) -> dict[str, Any]: """Ejecuta una pasada completa del motor programado sobre partidos pendientes.""" - artefacto = cargar_artefacto_activo(db) + try: + artefacto = cargar_artefacto_activo(db) + except (FileNotFoundError, RuntimeError) as exc: # sin artefacto verificable no se sella nada (plan §H.2) + enviar_alerta("contrato_roto", f"Motor sin artefacto activo verificable: {exc}") + return {"version_modelo": None, "total_encontrados": 0, "resultados": [], "error": str(exc)} v_modelo = artefacto["version_modelo"] params = artefacto["parametros"] pendientes = buscar_partidos_pendientes(db, v_modelo) + + # El filtro solo se reproduce si algún partido está dentro de su ventana de sellado (una lectura de la base por pasada). + ahora = datetime.now(UTC) + en_ventana = [p for p in pendientes if _en_ventana(p, ahora, forzar_corte)] + try: + inferencias = inferir(db, params, en_ventana) + except Exception as exc: # sin inferencia no se sella nada: alerta y se reintenta en la pasada siguiente + log.exception("inferencia fallida") + enviar_alerta("inferencia_fallida", f"La inferencia del motor falló: {exc!r}") + inferencias = {p["partido_id"]: {"ok": False, "motivo": "inferencia_fallida"} for p in en_ventana} + resultados = [] for p in pendientes: res = simular_y_sellar_partido( @@ -225,6 +284,7 @@ def ejecutar_pasada_motor( parametros=params, forzar_corte=forzar_corte, dry_run=dry_run, + inferencia=inferencias.get(p["partido_id"], {"ok": False, "motivo": "fuera_de_ventana"}), ) resultados.append(res) @@ -235,12 +295,36 @@ def ejecutar_pasada_motor( } -def main(): +def main(argv=None) -> int: + """Una pasada del motor (el cron la lanza cada 30 min). Código de salida 0 si terminó; 1 si no pudo sellar por un fallo.""" + import psycopg parser = argparse.ArgumentParser(description="Motor programado de tenis v2") parser.add_argument("--dry-run", action="store_true", help="Simula sin persistir sellos") - args = parser.parse_args() - print(f"Motor de tenis v2 iniciado (dry_run={args.dry_run})") + parser.add_argument("--dsn", default=os.environ.get("PG_DSN"), help="por omisión, la variable de entorno PG_DSN") + parser.add_argument("--esquema", default="tenis") + args = parser.parse_args(argv) + if not args.dsn: + print("falta --dsn o PG_DSN", flush=True) + return 1 + if not re.fullmatch(r"[a-z_][a-z0-9_]*", args.esquema): + print("nombre de esquema no válido", flush=True) + return 1 + print(f"Motor de tenis v2 iniciado (dry_run={args.dry_run})", flush=True) + try: + with psycopg.connect(args.dsn, autocommit=True) as db: + db.execute(f"SET search_path TO {args.esquema}, public") + resumen = ejecutar_pasada_motor(db, dry_run=args.dry_run) + except Exception as exc: # el motor no sella a medias: alerta y sale con error + log.exception("pasada del motor fallida") + enviar_alerta("motor_fallido", f"La pasada del motor falló: {exc!r}") + return 1 + conteo: dict[str, int] = {} + for r in resumen["resultados"]: + conteo[r["estado"]] = conteo.get(r["estado"], 0) + 1 + print(json.dumps({"version_modelo": resumen["version_modelo"], "pendientes": resumen["total_encontrados"], + "estados": conteo, "error": resumen.get("error")}, ensure_ascii=False), flush=True) + return 1 if resumen.get("error") else 0 if __name__ == "__main__": - main() + raise SystemExit(main()) diff --git a/apps/tenis/tests/inferencia_util.py b/apps/tenis/tests/inferencia_util.py new file mode 100644 index 00000000..6a777ad9 --- /dev/null +++ b/apps/tenis/tests/inferencia_util.py @@ -0,0 +1,32 @@ +"""Ayudas de prueba para la inferencia del motor: parámetros sintéticos y mundo mínimo con ranking para ambos jugadores.""" +from tenis.modelo.puntos import PsiP +from tenis.modelo.sintetico import LBAR, RHO_EPS, SIGMA_EPS, psi_prueba + +from db_util import insertar, ts + + +def params_prueba(capa_edad: dict | None = None, c_inf: float = 0.02) -> dict: + """Artefacto sintético con la estructura de `hiperparametros.json` (solo lo que usa la inferencia).""" + psi_p = PsiP(0.25, 0.05, 0.01, 0.01, 0.01, (1.0, 1.0, 1.0, 1.0), SIGMA_EPS, RHO_EPS, 0.01) + cfg = {"psi_r": psi_prueba(c_inf=c_inf).como_dict(), "psi_p": psi_p.como_dict(), "lbar": [LBAR] * 4} + if capa_edad: + cfg["capa_edad"] = capa_edad + return {"circuitos": {"atp": cfg}} + + +def ranking(db, jugador: int, posicion: int, puntos: int | None = None, fecha="2026-03-02") -> int: + r = db.execute("SELECT recibo_id FROM recibo LIMIT 1").fetchone()[0] + return insertar(db, "INSERT INTO ranking (circuito, fecha_publicacion, jugador_id, posicion, puntos, origen, fuente, " + "recibo_id, recibido_en) VALUES ('atp', %s, %s, %s, %s, 'oficial_capturado', 'sofascore', %s, %s) " + "RETURNING ranking_id", (fecha, jugador, posicion, puntos or max(10000 - 50 * posicion, 100), r, ts("2026-01-05"))) + + +def partido_futuro(db, m: dict, j1: int, j2: int, ronda: str = "SF", inicio: str = "2099-01-01T14:00:00Z") -> int: + """Partido programado en el futuro entre j1 y j2 (lado 1 = j1) en la edición del mundo mínimo.""" + r = db.execute("SELECT recibo_id FROM recibo LIMIT 1").fetchone()[0] + p = insertar(db, "INSERT INTO partido (edicion_id, ronda, jugador_1, jugador_2, mejor_de, fuente, recibo_id, recibido_en) " + "VALUES (%s, %s, %s, %s, 3, 'sofascore', %s, %s) RETURNING partido_id", + (m["edicion"], ronda, j1, j2, r, ts("2026-01-05"))) + db.execute("INSERT INTO programa (partido_id, inicio_programado_utc, tipo_hora, estado, fuente, recibo_id, recibido_en) " + "VALUES (%s, %s, 'fija', 'programado', 'sofascore', %s, %s)", (p, ts(inicio), r, ts("2026-01-05"))) + return p diff --git a/apps/tenis/tests/test_artefactos.py b/apps/tenis/tests/test_artefactos.py new file mode 100644 index 00000000..ae7811fc --- /dev/null +++ b/apps/tenis/tests/test_artefactos.py @@ -0,0 +1,113 @@ +"""Registro de artefactos: validación previa, anexado en la base, carga estricta por huella y pasada real del motor.""" +import json +import shutil +from pathlib import Path + +import pytest + +from tenis import artefactos as art +from tenis.modelo import hiperparametros as hp + +ARTEFACTO = Path(__file__).resolve().parents[1] / "artefactos" / "tenis-2.1-capa-edad.json" + + +def _informe(contenido, pasa=True, capa=True, base=None): + g = {"G_linea_base": {"pasa": pasa}, "G_cordura": {"pasa": True}, "G_calibracion": {"pasa": False}, "G_recalibracion": {}, + "G_capa_edad": {"capa_activa": capa}} + circ = {"compuertas": g, "n_evaluados": 100, "no_fuga": {"violaciones": 0}, "calibracion": {"pi_lado1": {"pendiente": 0.9}}} + return {"sha256_hiperparametros": hp.huella(base or art._base_sin_capa(contenido)), "eval_rango": [2019, 2024], + "sha256_predicciones_total": "0" * 64, "circuitos": {c: circ for c in contenido["circuitos"]}} + + +def _escribir(tmp_path, informe): + ruta = tmp_path / "informe.json" + ruta.write_text(json.dumps(informe), encoding="utf-8") + return ruta + + +def test_el_artefacto_del_repo_es_valido_y_trae_la_capa_en_los_dos_circuitos(tmp_path): + contenido = hp.leer(ARTEFACTO) + plan = art.validar(ARTEFACTO, _escribir(tmp_path, _informe(contenido)), menor=1) + assert plan["sha256"] == json.loads(ARTEFACTO.read_text(encoding="utf-8"))["sha256_contenido"] + assert plan["version_modelo"] == f"tenis-2.1+{plan['sha256'][:12]}" + assert set(plan["capa_edad"]) == {"atp", "wta"} and all(plan["capa_edad"].values()) + assert any("G_calibracion" in x for x in plan["advertencias"]) # advierte, no bloquea + + +def test_validar_rechaza_lo_que_no_debe_registrarse(tmp_path): + contenido = hp.leer(ARTEFACTO) + with pytest.raises(ValueError, match="no corresponde"): + art.validar(ARTEFACTO, _escribir(tmp_path, _informe(contenido, base={"otro": 1}))) + with pytest.raises(ValueError, match="G_linea_base"): + art.validar(ARTEFACTO, _escribir(tmp_path, _informe(contenido, pasa=False))) + with pytest.raises(ValueError, match="G_capa_edad"): + art.validar(ARTEFACTO, _escribir(tmp_path, _informe(contenido, capa=False))) + alterado = tmp_path / "alterado.json" + d = json.loads(ARTEFACTO.read_text(encoding="utf-8")); d["circuitos"]["atp"]["c_inf"] = 0.5 + alterado.write_text(json.dumps(d), encoding="utf-8") + with pytest.raises(ValueError, match="alterado"): + art.validar(alterado, _escribir(tmp_path, _informe(contenido))) + + +psycopg = pytest.importorskip("psycopg") +from db_util import cargar_minimo # noqa: E402 +from inferencia_util import partido_futuro, ranking # noqa: E402 +from tenis import motor # noqa: E402 + + +def _plan(tmp_path): + contenido = hp.leer(ARTEFACTO) + return art.validar(ARTEFACTO, _escribir(tmp_path, _informe(contenido))) + + +def test_registrar_anexa_exige_aprobacion_y_el_motor_lo_carga(esquema, tmp_path): + plan = _plan(tmp_path) + with esquema.conectar() as db: + cargar_minimo(db) # ya hay un artefacto activo de prueba + with pytest.raises(ValueError, match="OK del titular"): + art.registrar(db, plan, "tenis-motor:v21", " ") + with pytest.raises(ValueError, match="tenis-motor"): + art.registrar(db, plan, "v21", "OK en el chat") + antes = db.execute("SELECT count(*) FROM artefacto_activo").fetchone()[0] + res = art.registrar(db, plan, "tenis-motor:v21", "OK del titular 17-nov") + assert res["sha256"] == plan["sha256"] and res["anterior"]["version_modelo"] == "v1" + assert db.execute("SELECT count(*) FROM artefacto_activo").fetchone()[0] == antes + 1 + info = db.execute("SELECT informe_compuertas FROM artefacto WHERE sha256 = %s", (plan["sha256"],)).fetchone()[0] + assert info["circuitos"]["atp"]["G_capa_edad"]["capa_activa"] is True + with pytest.raises(ValueError, match="ya está activo"): + art.registrar(db, plan, "tenis-motor:v21", "OK otra vez") + carga = motor.cargar_artefacto_activo(db, ARTEFACTO.parent) # la huella registrada coincide con el fichero de la imagen + assert carga["sha256"] == plan["sha256"] and carga["parametros"]["circuitos"]["atp"]["capa_edad"]["beta"] < 0 + # vuelta atrás: otra fila que apunta al artefacto anterior; nunca un UPDATE + previo = res["anterior"]["sha256"] + vuelta = art.reactivar(db, previo, "tenis-motor:v1", "OK vuelta atrás") + assert vuelta["sha256"] == previo and vuelta["anterior"]["sha256"] == plan["sha256"] + with pytest.raises(ValueError, match="no está registrado"): + art.reactivar(db, "f" * 64, "tenis-motor:v1", "OK") + + +def test_cargador_estricto_sin_fichero_con_esa_huella(esquema, tmp_path): + with esquema.conectar() as db: + cargar_minimo(db) # el artefacto activo es de prueba: no existe fichero + shutil.copy(ARTEFACTO, tmp_path / "otro.json") # un JSON válido pero con OTRA huella NO se usa + with pytest.raises(FileNotFoundError, match="huella"): + motor.cargar_artefacto_activo(db, tmp_path) + assert motor.ejecutar_pasada_motor(db, dry_run=True)["error"] # sin artefacto verificable no se sella nada + + +def test_main_una_pasada_real_y_codigos_de_salida(esquema, tmp_path, monkeypatch, capsys): + plan = _plan(tmp_path) + monkeypatch.setattr(motor, "enviar_alerta", lambda *a, **k: {}) + monkeypatch.setenv("TENIS_ARTEFACTOS_DIR", str(ARTEFACTO.parent)) + with esquema.conectar() as db: + m = cargar_minimo(db) + ranking(db, m["jugadores"][1], 80) + args = ["--dry-run", "--dsn", esquema.dsn, "--esquema", esquema.nombre] + assert motor.main(args) == 1 # el artefacto activo de prueba no tiene fichero + assert "error" in capsys.readouterr().out + with esquema.conectar() as db: + art.registrar(db, plan, "tenis-motor:v21", "OK del titular") + assert motor.main(args) == 0 + salida = json.loads(capsys.readouterr().out.strip().splitlines()[-1]) + assert salida["version_modelo"] == plan["version_modelo"] and salida["error"] is None + assert motor.main(["--dry-run", "--dsn", esquema.dsn, "--esquema", "no valido!"]) == 1 diff --git a/apps/tenis/tests/test_capa_edad.py b/apps/tenis/tests/test_capa_edad.py new file mode 100644 index 00000000..3c5dbde6 --- /dev/null +++ b/apps/tenis/tests/test_capa_edad.py @@ -0,0 +1,91 @@ +"""Capa de edad: recuperación de coeficientes, simetría de lados, edad desconocida, no fuga y validaciones.""" +import numpy as np +import pytest + +from tenis.modelo import capa_edad as ce +from tenis.modelo.recalibracion import logit + + +def _mundo(n=20000, beta=-0.15, b=0.95, semilla=7, tasa_edad=0.8): + rng = np.random.default_rng(semilla) + pi = np.clip(rng.beta(2.2, 2.2, n), 0.03, 0.97) + e1, e2 = rng.normal(26, 4, n), rng.normal(26, 4, n) + conocida = rng.random(n) < tasa_edad + dedad = np.where(conocida, ce.diferencia_edad(e1, e2), np.nan) + escala = np.nanstd(dedad) + z = b * logit(pi) + beta * np.nan_to_num(dedad) / escala + y = (rng.random(n) < 1 / (1 + np.exp(-z))).astype(float) + temp = np.sort(rng.integers(2013, 2025, n)) + return pi, dedad, y, temp, escala + + +def test_recupera_coeficientes(): + pi, dedad, y, _, escala = _mundo() + capa = ce.ajustar(pi, dedad, y, 2013, 2024) + assert capa.pendiente == pytest.approx(0.95, abs=0.04) + assert capa.beta == pytest.approx(-0.15, abs=0.04) + assert capa.escala == pytest.approx(escala, rel=1e-6) + + +def test_simetria_de_lados(): + pi, dedad, y, _, _ = _mundo(n=5000) + capa = ce.ajustar(pi, dedad, y) + a = ce.aplicar(pi, dedad, capa) + b = ce.aplicar(1 - pi, -dedad, capa) # mismo partido con los lados intercambiados + assert np.allclose(a + b, 1.0, atol=1e-12) + + +def test_edad_desconocida_solo_aplica_pendiente(): + pi, dedad, y, _, _ = _mundo(n=5000) + capa = ce.ajustar(pi, dedad, y) + sin_edad = ce.aplicar(pi[:50], np.full(50, np.nan), capa) + solo_pendiente = 1 / (1 + np.exp(-capa.pendiente * logit(pi[:50]))) + assert np.allclose(sin_edad, solo_pendiente) + + +def test_diferencia_edad_rangos_y_recorte(): + d = ce.diferencia_edad([20.0, 13.9, 50.1, np.nan, 40.0, 49.0], [30.0, 25.0, 25.0, 25.0, np.nan, 14.0]) + assert d[0] == -10.0 + assert np.isnan(d[1]) and np.isnan(d[2]) and np.isnan(d[3]) and np.isnan(d[4]) + assert d[5] == ce.DIF_MAX # 35 años de diferencia se recorta a 20 + + +def test_pi_nan_se_conserva(): + capa = ce.CapaEdad(1.0, -0.1, 5.0, 3000, 2013, 2018) + out = ce.aplicar(np.array([0.6, np.nan]), np.array([2.0, 2.0]), capa) + assert np.isfinite(out[0]) and np.isnan(out[1]) + + +def test_por_temporada_no_usa_el_futuro(): + pi, dedad, y, temp, _ = _mundo(n=30000) + liq = np.ones(len(pi), bool) + base, capas = ce.por_temporada(temp, pi, dedad, y, liq, range(2019, 2025), 2013) + y_alt = y.copy() + y_alt[temp >= 2022] = 1 - y_alt[temp >= 2022] # se destruyen las etiquetas desde 2022 + alt, _ = ce.por_temporada(temp, pi, dedad, y_alt, liq, range(2019, 2025), 2013) + pasado = temp <= 2022 # π' de 2019-2022 solo depende de etiquetas ≤ 2021 + assert np.allclose(base[pasado & (temp >= 2019)], alt[pasado & (temp >= 2019)], equal_nan=True) + assert capas[2019].hasta == 2018 and capas[2024].hasta == 2023 + + +def test_por_temporada_sin_datos_suficientes_deja_nan(): + pi, dedad, y, temp, _ = _mundo(n=30000) + out, capas = ce.por_temporada(temp, pi, dedad, y, np.ones(len(pi), bool), [2013], 2013) + assert capas[2013] is None and np.isnan(out[temp == 2013]).all() + + +def test_serializacion_y_validaciones(): + capa = ce.CapaEdad(0.96, -0.12, 4.9, 12345, 2013, 2024) + assert ce.CapaEdad.desde_dict(capa.como_dict()) == capa + for malo in (dict(pendiente=0.0), dict(pendiente=3.5), dict(beta=2.5), dict(escala=0.0), dict(beta=float("nan"))): + with pytest.raises(ValueError): + ce.CapaEdad(**(dict(pendiente=0.96, beta=-0.12, escala=4.9, n=1, desde=0, hasta=0) | malo)) + + +def test_ajuste_exige_muestra_y_edades(): + rng = np.random.default_rng(1) + with pytest.raises(ValueError): + ce.ajustar(np.full(100, 0.6), np.zeros(100), rng.integers(0, 2, 100).astype(float)) + pi = np.full(3000, 0.6) + with pytest.raises(ValueError): # ninguna edad conocida + ce.ajustar(pi, np.full(3000, np.nan), rng.integers(0, 2, 3000).astype(float)) diff --git a/apps/tenis/tests/test_capa_edad_motor.py b/apps/tenis/tests/test_capa_edad_motor.py new file mode 100644 index 00000000..b2d1930c --- /dev/null +++ b/apps/tenis/tests/test_capa_edad_motor.py @@ -0,0 +1,72 @@ +"""Gancho de la capa de edad en el motor: lectura de edades al corte (PIT) y aplicación sobre π.""" +from datetime import datetime, timedelta, timezone + +import pytest + +from tenis import motor +from tenis.modelo import capa_edad as ce + +UTC = timezone.utc +CAPA = ce.CapaEdad(0.96, -0.15, 5.0, 12000, 2013, 2024) +PARAMS = {"capa_edad": CAPA.como_dict()} + + +def test_sin_capa_pi_intacta_y_sin_trazas(): + pi, traza = motor.aplicar_capa_edad(0.585, 22.0, 30.0, {}) + assert pi == 0.585 and traza == {} + + +def test_con_capa_el_mas_joven_sube(): + base, _ = motor.aplicar_capa_edad(0.5, None, None, PARAMS) + joven, traza = motor.aplicar_capa_edad(0.5, 21.0, 31.0, PARAMS) # lado 1 diez años más joven + viejo, _ = motor.aplicar_capa_edad(0.5, 31.0, 21.0, PARAMS) + assert base == pytest.approx(0.5) and joven > 0.5 > viejo + assert joven + viejo == pytest.approx(1.0) # simetría de lados + assert traza == {"capa_edad": True, "pi_base": 0.5, "edad_dif": -10.0} + + +def test_edad_desconocida_solo_pendiente(): + pi, traza = motor.aplicar_capa_edad(0.7, None, 25.0, PARAMS) + esperado = float(ce.aplicar(0.7, float("nan"), CAPA)) + assert pi == pytest.approx(esperado) and traza["edad_dif"] is None + + +psycopg = pytest.importorskip("psycopg") +from db_util import cargar_minimo, ts # noqa: E402 +from inferencia_util import params_prueba, partido_futuro, ranking # noqa: E402 + + +def test_edades_al_corte_pit(esquema): + with esquema.conectar() as db: + m = cargar_minimo(db) + a, b, c, _ = m["jugadores"] + r = m["recibo"] + for j, valor, cuando in ((a, "1996-04-10", "2026-01-05"), (b, "2002-09-01", "2026-01-05"), + (b, "2000-01-01", "2026-03-01")): # esta última llega DESPUÉS del corte + db.execute("INSERT INTO jugador_asercion (jugador_id, campo, valor, fuente, recibo_id, recibido_en) " + "VALUES (%s, 'fecha_nacimiento', %s, 'sofascore', %s, %s)", (j, valor, r, ts(cuando))) + corte = datetime(2026, 2, 1, tzinfo=UTC) + e1, e2 = motor.edades_al_corte(db, a, b, corte) + assert e1 == pytest.approx((corte - datetime(1996, 4, 10, tzinfo=UTC)).days / 365.25) + assert e2 == pytest.approx((corte - datetime(2002, 9, 1, tzinfo=UTC)).days / 365.25) # ignora la aserción futura + assert motor.edades_al_corte(db, c, a, corte)[0] is None # sin fecha → None + + +def test_motor_con_capa_cambia_la_probabilidad_y_deja_traza(esquema): + with esquema.conectar() as db: + m = cargar_minimo(db) + a, b, _, _ = m["jugadores"] + r = m["recibo"] + for j, valor in ((a, "1996-04-10"), (b, "2003-02-01")): + db.execute("INSERT INTO jugador_asercion (jugador_id, campo, valor, fuente, recibo_id, recibido_en) " + "VALUES (%s, 'fecha_nacimiento', %s, 'sofascore', %s, %s)", (j, valor, r, ts("2026-01-05"))) + ranking(db, b, 80) + partido = partido_futuro(db, m, a, b, "SF") + partido = next(x for x in motor.buscar_partidos_pendientes(db, "vx") if x["partido_id"] == partido) + corte = datetime.now(UTC) - timedelta(hours=2) + kw = dict(db=db, partido=partido, version_modelo="vx", version_datos="d", forzar_corte=corte, dry_run=True) + sin = motor.simular_y_sellar_partido(parametros=params_prueba(), **kw) + con = motor.simular_y_sellar_partido(parametros=params_prueba(capa_edad=CAPA.como_dict()), **kw) + assert sin["estado"] == con["estado"] == "dry_run_ok" + # lado 2 (b) es ~7 años más joven: la capa le quita probabilidad al lado 1 + assert con["distribucion"]["mercados"]["gana_a"] < sin["distribucion"]["mercados"]["gana_a"] diff --git a/apps/tenis/tests/test_inferencia.py b/apps/tenis/tests/test_inferencia.py new file mode 100644 index 00000000..e4bfaf7c --- /dev/null +++ b/apps/tenis/tests/test_inferencia.py @@ -0,0 +1,126 @@ +"""Inferencia del motor: el mismo filtro que el walk-forward, orientación de lados y motivos de omisión.""" +import numpy as np +import pandas as pd +import pytest + +from tenis import inferencia as inf +from tenis.modelo import datos as dm +from tenis.modelo.rating import filtrar +from tenis.modelo.sintetico import mundo, tablas_prueba, psi_prueba + +from inferencia_util import params_prueba + +STATS_VACIAS = pd.DataFrame({"partido_key": pd.Series(dtype="object"), "lado": pd.Series(dtype="int64"), + "puntos_saque": pd.Series(dtype="float64"), "puntos_saque_ganados": pd.Series(dtype="float64"), + "visible_desde": pd.Series(dtype="datetime64[ns, UTC]")}) + + +def _mundo(): + p, e = mundo(semilla=71, n_semanas=30) + p["partido_id_tml"] = pd.array([pd.NA] * len(p), dtype="Int64") + p["partido_id_sofascore"] = pd.array(np.arange(1, len(p) + 1), dtype="Int64") + return p, e + + +def test_pronosticar_circuito_es_el_filtro_de_la_evaluacion(): + p, e = _mundo() + cfg = params_prueba()["circuitos"]["atp"] + pron = inf.pronosticar_circuito(p, e, STATS_VACIAS, cfg, "atp") + d = dm.preparar(p, e, "atp", 9999) + esperado = filtrar(d, psi_prueba(c_inf=0.02), tablas_prueba()).pi + np.testing.assert_allclose(pron.pi.to_numpy(), esperado, rtol=0, atol=1e-12, equal_nan=True) + assert list(pron.partido_key) == list(d.p.partido_key) + assert np.isfinite(pron.pi).sum() > 100 and np.isfinite(pron.s_hat).all() + + +def _partido_db(pron, i, invertir=False): + f = pron.iloc[i] + a, b = int(f.jugador_1), int(f.jugador_2) + return {"partido_id": int(f.partido_id_sofascore), "jugador_1": b if invertir else a, "jugador_2": a if invertir else b} + + +def test_resolver_orienta_segun_el_partido_de_la_base(): + p, e = _mundo() + pron = inf.pronosticar_circuito(p, e, STATS_VACIAS, params_prueba()["circuitos"]["atp"], "atp") + i = int(np.flatnonzero(np.isfinite(pron.pi.to_numpy()) & (pron.motivo.isna()).to_numpy())[-1]) + a = inf.resolver(pron, _partido_db(pron, i)) + b = inf.resolver(pron, _partido_db(pron, i, invertir=True)) # mismo partido con los lados cambiados + assert a["ok"] and b["ok"] + assert a["pi_lado1"] + b["pi_lado1"] == pytest.approx(1.0, abs=1e-12) + assert a["s_hat"] == b["s_hat"] and a["var_rho"] == b["var_rho"] + + +def test_resolver_motivos(): + p, e = _mundo() + pron = inf.pronosticar_circuito(p, e, STATS_VACIAS, params_prueba()["circuitos"]["atp"], "atp") + assert inf.resolver(pron, {"partido_id": 10**9, "jugador_1": 1, "jugador_2": 2}) == {"ok": False, "motivo": "fuera_de_la_exportacion"} + ok = _partido_db(pron, 40) + assert inf.resolver(pron, ok | {"jugador_2": 987654})["motivo"] == "jugadores_no_coinciden" + malo = pron.copy(); malo.loc[malo.index[40], "motivo"] = "sin_historia_ni_ranking" + assert inf.resolver(malo, ok) == {"ok": False, "motivo": "sin_historia_ni_ranking"} + malo.loc[malo.index[40], "motivo"] = None + malo.loc[malo.index[40], "s_hat"] = np.nan + assert inf.resolver(malo, ok)["motivo"] == "sin_s_hat" + + +def test_sin_parametros_del_circuito_no_pronostica(): + class _Sin: # `inferir` solo toca la base si hay algo que pronosticar con parámetros + pass + assert inf.inferir(_Sin(), {}, []) == {} + + +psycopg = pytest.importorskip("psycopg") +from db_util import cargar_minimo # noqa: E402 +from inferencia_util import partido_futuro, ranking # noqa: E402 + + +def test_inferir_desde_la_base_con_ranking_como_prior(esquema): + with esquema.conectar() as db: + m = cargar_minimo(db) + a, b, c, _ = m["jugadores"] + # a ya trae el puesto 5 del mundo mínimo. La base exige jugador_1 < jugador_2 (orden canónico por id): + ranking(db, b, 80) + ranking(db, c, 3) # c (id mayor) es el mejor del cuadro + d = m["jugadores"][3] # d sin ranking ni historia + p_ab = partido_futuro(db, m, a, b, "SF") # favorito = lado 1 + p_bc = partido_futuro(db, m, b, c, "QF") # favorito = lado 2 + p_ad = partido_futuro(db, m, a, d, "R16") + base = {"circuito": "atp", "inicio_programado_utc": None, "mejor_de": 3, "superficie": "clay"} + pend = [base | {"partido_id": p_ab, "jugador_1": a, "jugador_2": b}, + base | {"partido_id": p_bc, "jugador_1": b, "jugador_2": c}, + base | {"partido_id": p_ad, "jugador_1": a, "jugador_2": d}] + res = inf.inferir(db, params_prueba(), pend) + assert res[p_ab]["ok"] and res[p_bc]["ok"] + assert res[p_ab]["pi_lado1"] > 0.5 # puesto 5 contra 80 + assert res[p_bc]["pi_lado1"] < 0.5 # puesto 80 contra 3: la orientación aleatoria de la exportación se deshace + assert res[p_ab]["prior_ranking"] is True + assert res[p_ad] == {"ok": False, "motivo": "sin_historia_ni_ranking"} + assert inf.inferir(db, {"circuitos": {}}, pend[:1])[p_ab]["motivo"] == "sin_parametros_del_circuito" + + +def test_pasada_del_motor_infiere_una_vez_y_omite_sin_historia(esquema, monkeypatch): + from datetime import datetime, timedelta, timezone + from tenis import motor + with esquema.conectar() as db: + m = cargar_minimo(db) + a, b, _, d = m["jugadores"] + ranking(db, b, 80) + p_ok = partido_futuro(db, m, a, b, "SF") + p_sin = partido_futuro(db, m, a, d, "R16") # d: sin ranking ni historia + llamadas = [] + real = inf.inferir + monkeypatch.setattr(motor, "inferir", lambda *args: llamadas.append(args[2]) or real(*args)) + monkeypatch.setattr(motor, "cargar_artefacto_activo", + lambda *_: {"version_modelo": "vx", "sha256": "0" * 64, "parametros": params_prueba()}) + monkeypatch.setattr(motor, "enviar_alerta", lambda *a_, **k: {}) + forzado = datetime.now(timezone.utc) - timedelta(hours=1) + r = motor.ejecutar_pasada_motor(db, forzar_corte=forzado, dry_run=True) + por_id = {x["partido_id"]: x for x in r["resultados"]} + assert por_id[p_ok]["estado"] == "dry_run_ok" + assert por_id[p_sin] == {"estado": "omitido_sin_modelo", "partido_id": p_sin, "motivo": "sin_historia_ni_ranking"} + assert len(llamadas) == 1 # una sola inferencia para toda la pasada + # Sin forzar corte, ningún partido de 2099 está en ventana: no se infiere nada ni se sella + llamadas.clear() + r2 = motor.ejecutar_pasada_motor(db, dry_run=True) + assert all(x["estado"] == "pendiente_ventana" for x in r2["resultados"]) + assert llamadas == [[]] diff --git a/apps/tenis/tests/test_motor_alertas_salud.py b/apps/tenis/tests/test_motor_alertas_salud.py index 63aab073..00cdbf97 100644 --- a/apps/tenis/tests/test_motor_alertas_salud.py +++ b/apps/tenis/tests/test_motor_alertas_salud.py @@ -6,6 +6,7 @@ psycopg = pytest.importorskip("psycopg") from db_util import cargar_minimo, insertar, ts +from inferencia_util import params_prueba, ranking from tenis import alertas, salud from tenis.motor import ( buscar_partidos_pendientes, @@ -82,6 +83,7 @@ def test_motor_simulacion_y_sellado(esquema): "VALUES (%s, %s, 'fija', 'programado', 'sofascore', %s, %s)", (p, inicio_futuro, r, ts("2026-01-05")), ) + ranking(db, m["jugadores"][1], 80) # el jugador 1 ya trae ranking; sin esto el motor no pronostica (sin historia) pendientes = buscar_partidos_pendientes(db, "v1") assert any(x["partido_id"] == p for x in pendientes) @@ -94,7 +96,7 @@ def test_motor_simulacion_y_sellado(esquema): partido=partido_dict, version_modelo="v1", version_datos="d_test", - parametros={}, + parametros=params_prueba(), forzar_corte=datetime.now(UTC) - timedelta(hours=1), dry_run=True, ) @@ -108,7 +110,7 @@ def test_motor_simulacion_y_sellado(esquema): partido=partido_dict, version_modelo="v1", version_datos="d_test", - parametros={}, + parametros=params_prueba(), forzar_corte=corte_fijo, dry_run=False, ) diff --git a/docs/tenis_capa_edad_20261117.md b/docs/tenis_capa_edad_20261117.md new file mode 100644 index 00000000..7c62f97a --- /dev/null +++ b/docs/tenis_capa_edad_20261117.md @@ -0,0 +1,71 @@ +# Tenis v2: capa de edad (17-nov-2026) + +Decisión del titular (17-nov-2026): implementar la edad como versión nueva del modelo tras medirla con walk-forward. + +## Qué es + +Segunda etapa sobre la probabilidad π del filtro congelado (`apps/tenis/src/tenis/modelo/capa_edad.py`): + + logit π' = b · logit π + β · (edad_1 − edad_2) / escala + +- Sin intercepto: los lados están en orden pseudoaleatorio, así que π'(A, B) + π'(B, A) = 1 por construcción (prueba incluida). +- Edad de cualquiera de los dos desconocida o fuera de [14, 50] años ⇒ término de edad = 0; solo actúa la pendiente `b`. +- `|edad_1 − edad_2|` se recorta a 20 años. `b` sustituye a la capa de recalibración de pendiente (no se apilan). +- β no tiene signo impuesto. Sale negativo: el jugador más joven rinde por encima de lo que su rating anticipa. +- El filtro, el simulador, la pieza P y los triggers de la base de datos no se tocan. + +## Medición (walk-forward 2019-2024, reserva 2025-26 sin tocar) + +Para cada temporada T, (b, β) se ajusta con las temporadas 2013..T−1 y se aplica a T (`capa_edad.por_temporada`). +Δ = capa de edad − referencia (negativo = mejora). Código: `apps/tenis/ops/evaluar_wf.py`, informe `evaluacion_wf_capa_edad.json`. + +| | ATP | WTA | +|---|---|---| +| Δ log-loss vs capa de pendiente actual | −0,0022 [−0,0028; −0,0017] | −0,0026 [−0,0035; −0,0017] | +| Temporadas que mejoran | 6 de 6 | 5 de 6 (2022: +0,0006) | +| Δ log-loss vs Elo recalibrado (G-línea base) | −0,0087 [−0,0101; −0,0072] | −0,0082 [−0,0103; −0,0060] | +| Con edad conocida / sin edad conocida | −0,0035 / −0,0000 | −0,0029 / −0,0000 | +| Pendiente de calibración (antes → después) | 0,902 → 0,961 [0,931; 0,988] | 0,975 → 1,028 [0,978; 1,078] | +| No-fuga (violaciones) | 0 | 0 | + +- Compuerta `G_capa_edad` (nueva): la capa se activa si el IC95 de Δ log-loss frente a la capa de pendiente queda por debajo de 0. + Pasa en ATP y WTA. +- La mejora se concentra en partidos con más de 5 años de diferencia de edad (≈ −0,007 en ambos circuitos). +- El coeficiente es estable por temporada (β/escala entre −0,11 y −0,17). Medido también por separado en partidos con la edad + tomada del propio partido de SofaScore y en partidos de TML: mismo efecto, así que el sesgo de supervivencia de las fechas de nacimiento + no lo explica. +- `G_calibracion` de ATP sigue sin pasar por IC (el IC de la pendiente excluye 1), como antes; la pendiente mejora de 0,902 a 0,961. +- Las predicciones base de `evaluar_wf` no cambian: el sha256 de `predicciones_wf.parquet` coincide con el artefacto oficial (`af77e927…`). + +## Coeficientes congelados (ajuste con 2013-2024) + +| | b (pendiente) | β | escala (años) | partidos | +|---|---|---|---|---| +| ATP | 0,9603 | −0,1660 | 5,801 | 94.858 | +| WTA | 0,9790 | −0,1524 | 5,766 | 28.682 | + +Artefacto: `data/tennis/rediseno_20261104/modelo_s3/hiperparametros_capa_edad.json` (`sha256_contenido` +`55c17ba1c6e28445b0e99b2bfab64c1d7b681766c29d6574c62089a488f41f94`). Se genera con `apps/tenis/ops/congelar_capa_edad.py`, que exige que +la compuerta pase por circuito. El `hiperparametros.json` original queda intacto (vuelta atrás = seguir con ese artefacto). + +## Motor + +`motor.py` lee las edades al corte con la misma regla que la exportación PIT (`edades_al_corte`: aserción `fecha_nacimiento` visible en el +corte, mayor prioridad de fuente, la más reciente) y aplica la capa solo si el artefacto activo trae `capa_edad` (`aplicar_capa_edad`). +Con capa, las entradas selladas añaden `capa_edad`, `pi_base` y `edad_dif`; sin ella quedan exactamente como antes. + +**Actualización (mismo día):** el motor ya usa el filtro real en lugar de valores de demostración; ver `docs/tenis_motor_filtro_real_20261117.md`. +La capa de edad se aplica ahora sobre el π real del filtro. + +## Lo que NO se hizo + +- Registrar el artefacto nuevo en `artefacto_activo` con una `version_modelo` nueva: decisión de despliegue del titular. +- Edad dentro del filtro (afectando al rating de cada jugador): exigiría reestimar hiperparámetros. +- Variables de actividad reciente (partidos en 14 días, descanso): mejoran otros −0,0014 (ATP) y −0,0021 (WTA) pero con signo contrario a una + fatiga; sin explicación causal no se adoptan. La fatiga del modelo sigue sin validar (φ1 ≈ 0). + +## Reproducir + + python apps/tenis/ops/evaluar_wf.py --dir --reps 1000 + python apps/tenis/ops/congelar_capa_edad.py --dir + pytest apps/tenis/tests/test_capa_edad.py apps/tenis/tests/test_capa_edad_motor.py # estas últimas con QF_TEST_PG_DSN diff --git a/docs/tenis_motor_filtro_real_20261117.md b/docs/tenis_motor_filtro_real_20261117.md new file mode 100644 index 00000000..0686a8af --- /dev/null +++ b/docs/tenis_motor_filtro_real_20261117.md @@ -0,0 +1,56 @@ +# Tenis v2: el motor usa el filtro real (17-nov-2026) + +Decisión del titular (17-nov-2026): conectar el filtro al motor. Hasta hoy `motor.py` sellaba con valores de demostración +(`pi_lado1 = 0.585`, `S_hat = 1.25`, `var_rho = 0.009`) y el filtro solo corría en los scripts de entrenamiento y evaluación. + +## Cómo funciona (plan §H.1: «reproducir el filtro con Ψ congelado, simular, sellar») + +`apps/tenis/src/tenis/inferencia.py`: + +1. Lee la evidencia completa de la base en una transacción de solo lectura (`datos.lectura.leer_todo`). +2. La convierte con `exportar_pit.construir(tablas, desde=2005-01-01)` y la pasa por Parquet en memoria, para que los tipos sean + idénticos a los de la ruta validada. **La ventana desde 2005 es obligatoria**: con todo el histórico (1968-) las probabilidades + cambian hasta 0,045. +3. Corre el mismo filtro R y la pieza P que `ops/evaluar_wf.py` con el Ψ del artefacto activo y toma, para cada partido, π, Var(ρ) y Ŝ. +4. Deshace la orientación pseudoaleatoria de lados de la exportación para devolver π desde `partido.jugador_1` de la base. + +`motor.py`: la pasada (`ejecutar_pasada_motor`) infiere **una sola vez** para todos los partidos dentro de su ventana de sellado +([T_ref − 60 min, T_ref)); si ninguno está en ventana no lee la base ni corre el filtro. σ_ε, ρ_ε y c_inf salen de `psi_r` del artefacto +(como en `muestra_union`); el formato (mejor de, set decisivo) sale de la exportación, no de una suposición. Se aplica la capa de edad si +el artefacto la trae (`docs/tenis_capa_edad_20261117.md`). Las entradas selladas añaden formato, `prior_ranking`, `historia_corta`, +`fatiga_desconocida` y `fuente_pi`. + +**Sin pronóstico, no se sella.** Si el partido no se puede pronosticar (jugador sin historia ni ranking, superficie o formato +desconocido, fuera de la exportación, jugadores que no coinciden, π o Ŝ no finitos, sin parámetros del circuito), el motor devuelve +`omitido_sin_modelo` con el motivo y emite alerta (`jugador_sin_historia` o `sin_pronostico`). Si la inferencia entera falla, alerta +`inferencia_fallida` y no sella nada en esa pasada; la siguiente la reintenta. Nunca hay valores por omisión (plan D.6). + +## Verificación con datos reales + +Base local `tenis_dev` (la misma de la exportación del 5-nov): `conjunto_desde_db` produce 260.165 partidos, 260.165 eventos y 421.864 filas +de estadísticas, con las mismas claves que los ficheros de la exportación. Con el artefacto `hiperparametros_capa_edad.json`, π de +`pronosticar_circuito` frente a `evaluacion_filas.parquet` (walk-forward oficial): + +| | partidos comparados | máx \|Δπ\| | media \|Δπ\| | +|---|---|---|---| +| WTA ≤ 2024 | 14.183 de 14.183 | 0,0 | 0,0 | +| ATP ≤ 2024 | 46.558 de 46.558 | 0,0 | 0,0 | + +(Sin la ventana desde 2005 la diferencia era de hasta 0,045: así se detectó.) + +## Pruebas + +`test_inferencia.py`: el filtro del motor coincide con `filtrar` en un mundo sintético; orientación de lados; motivos de omisión; base de datos real con ranking +como prior, favorito en el lado 2 y jugador sin historia; pasada del motor (una sola inferencia, omisión sin historia, nada en ventana ⇒ nada se +infiere). `test_motor_alertas_salud.py` y `test_capa_edad_motor.py` ahora ejercitan el flujo completo (no valores de demostración). +También se corrigió `exportar_pit.construir`: con una base sin ninguna fecha de nacimiento la resta de edades fallaba (columna vacía de +tipo object); no cambia el caso normal. + +## Coste y límites + +- Una inferencia lee la base entera: ≈ 133 s de lectura y conversión + 31 s (WTA) y 80 s (ATP) de filtro en este equipo con 260.000 partidos. + Solo ocurre cuando hay partidos en ventana; con el cron horario son dos o tres minutos por pasada. Si molesta, el siguiente paso es el + estado del filtro en Parquet (`tenis_estado__.parquet`, plan H.2), que hoy NO existe. +- Orden de `jugador_1`/`jugador_2`: la base exige id menor primero; el resultado se devuelve siempre desde `partido.jugador_1`. +- Falta, para sellar de verdad: registrar `hiperparametros_capa_edad.json` (o el original) como `artefacto_activo` con una `version_modelo` + nueva, y un ensayo del motor contra la base de producción cuando se cargue (hoy la base `tenis` real no tiene datos cargados). diff --git a/docs/tenis_registro_artefacto_20261117.md b/docs/tenis_registro_artefacto_20261117.md new file mode 100644 index 00000000..d466d5f4 --- /dev/null +++ b/docs/tenis_registro_artefacto_20261117.md @@ -0,0 +1,67 @@ +# Tenis v2: registro del artefacto `tenis-2.1+55c17ba1c6e2` (preparado el 17-nov-2026, NO ejecutado) + +El plan (§H.1) exige el OK del titular en el chat para activar un artefacto. Aquí queda todo preparado; **no se ha escrito nada en ninguna base**. + +## El artefacto + +| | | +|---|---| +| Fichero | `apps/tenis/artefactos/tenis-2.1-capa-edad.json` (18 KB; viaja en la imagen del motor) | +| `sha256` (huella del contenido) | `55c17ba1c6e28445b0e99b2bfab64c1d7b681766c29d6574c62089a488f41f94` | +| `version_modelo` | `tenis-2.1+55c17ba1c6e2` (plan §H.2: `tenis-2.+`) | +| Contenido | Los hiperparámetros del 7-nov (R con σ_R = 0, c_inf, P, λ = 0,5) **más** la capa de edad (ATP b = 0,9603, β = −0,166; WTA b = 0,979, β = −0,152) | +| Informe | `data/tennis/rediseno_20261104/modelo_s3/evaluacion_wf_capa_edad.json` (walk-forward 2019-24, reserva 2025-26 intacta) | + +La validación (`registrar_artefacto.py validar`) comprueba: huella íntegra, `psi_r`/`psi_p`/`lbar`/capa de ambos circuitos, que el informe corresponda al artefacto +base (huella sin la capa), `G_linea_base`, `G_cordura` y `G_capa_edad`. **Advertencia, no bloquea:** `G_calibracion` de ATP no pasa por IC (pendiente 0,902 antes de la capa, +0,961 con ella); ya estaba aceptada por el titular (Opción 1). + +## Qué cambia respecto a lo que había + +- `motor.cargar_artefacto_activo` ya **no** tiene ruta fija ni respaldo: solo acepta un fichero de `TENIS_ARTEFACTOS_DIR` (la imagen: `/app/apps/tenis/artefactos`) + cuya huella recalculada coincida con la registrada. Si ninguno coincide: alerta `contrato_roto` y no se sella nada (plan §H.2). +- `python -m tenis.motor` hacía solo un `print`; ahora ejecuta una pasada real (`--dsn` o `PG_DSN`, `--esquema tenis`, `--dry-run`). Código de salida 1 si no pudo. +- La imagen copia `apps/tenis/artefactos/`. +- Las tablas `artefacto` y `artefacto_activo` son solo-anexar; el motor solo las lee. Registrar exige un rol que pueda insertar (administrador). + +## Antes de activar (bloqueos reales) + +1. **Fusionar el PR #505** a `main` (producción = `main`, `DEPLOYS.md`). +2. **La base `tenis` real no tiene datos cargados** (carga TML/SofaScore pendiente de tu OK, `harness/tareas.md`). Sin datos el motor omite todo con `sin_historia_ni_ranking`. +3. Construir la imagen `tenis-motor:` y ejecutar `ops/ensayo_operativo.sh` (colector y pasada `--dry-run` a mano). Anotar en `DEPLOYS.md` la imagen y su vuelta atrás + (`imagen_actual` con el nombre completo `tenis-motor:`, nunca solo la etiqueta). +4. Una pasada cuesta ≈ 3 min (lectura de toda la base + filtro) y solo corre si hay partidos en ventana. + +## Orden de ejecución (cuando des el OK) + +```bash +# 1. Validar (no toca la base) +python apps/tenis/ops/registrar_artefacto.py validar \ + --json apps/tenis/artefactos/tenis-2.1-capa-edad.json --informe + +# 2. Ver lo que haría (sin --ejecutar) +python apps/tenis/ops/registrar_artefacto.py registrar --json ... --informe ... \ + --imagen tenis-motor: --aprobado-en-chat "" + +# 3. Registrar y activar (rol administrador; el DSN no se imprime) +PG_DSN= python apps/tenis/ops/registrar_artefacto.py registrar ... --ejecutar + +# 4. Comprobar: una pasada en seco y la salud +python -m tenis.motor --dry-run +``` + +## Vuelta atrás + +Otra fila de activación apuntando al artefacto anterior (nunca UPDATE): + +```bash +python apps/tenis/ops/registrar_artefacto.py reactivar --sha256 \ + --imagen tenis-motor: --aprobado-en-chat "" --ejecutar +``` + +Con la imagen anterior (`imagen_actual.anterior`) el motor vuelve a cargar el fichero con la huella del artefacto anterior (ambos ficheros pueden convivir en el directorio). + +## Pruebas + +`tests/test_artefactos.py`: validación (rechaza informe ajeno, compuerta que falla, capa sin compuerta, fichero alterado), registro anexado con aprobación obligatoria, +imagen con formato, doble registro rechazado, vuelta atrás, carga por huella, cargador estricto, `ejecutar_pasada_motor` sin artefacto verificable y `motor.main` con código de salida. diff --git a/harness/progreso.md b/harness/progreso.md index 03770eca..5db4297e 100644 --- a/harness/progreso.md +++ b/harness/progreso.md @@ -1625,3 +1625,10 @@ El titular pidió TheRundown (cuenta Free) como último respaldo para fútbol, N - `flutter analyze --no-pub`: **0 issues**. - `flutter test --no-pub`: **673/673 tests pasados al 100%**. - Rediseño completo concluido a través de todas las fases autorizadas: F0, F1, F2, F3a-e, F4a-g, F5a-d, F6 y F8. + +## 17-nov-2026 · Tenis v2: capa de edad (`tenis/capa-edad`) +- **Decisión (pedido del titular):** la edad entra como segunda etapa sobre π (`logit π' = b·logit π + β·Δedad/escala`, sin intercepto, reemplaza la pendiente de recalibración). Walk-forward 2019-24 con ajuste solo en temporadas anteriores: −0,0022 ATP y −0,0026 WTA de log-loss frente a la capa actual (IC95 por debajo de 0), −0,0087/−0,0082 frente a Elo recalibrado. Reserva 2025-26 intacta. `docs/tenis_capa_edad_20261117.md`. +- **Por qué segunda etapa y no dentro del filtro:** la edad solo existe para 73-88 % de los partidos y viene de SofaScore; dentro del filtro exigiría reestimar todos los hiperparámetros. El efecto es el mismo en partidos de TML y de SofaScore, así que no es sesgo de supervivencia. +- **No adoptado:** actividad reciente (signo contrario a fatiga, sin causa conocida). La fatiga del modelo sigue en φ1 ≈ 0. +- **Motor con filtro real (pedido del titular):** `motor.py` sellaba con valores de demostración (`pi_lado1 = 0.585`). Ahora `tenis/inferencia.py` reproduce el filtro con Ψ congelado desde la evidencia de la base, una vez por pasada y solo si hay partidos en ventana; sin pronóstico (sin historia ni ranking, formato desconocido...) no sella y alerta. Verificado con datos reales: Δπ = 0 frente al walk-forward en 60.741 partidos. **Trampa:** hay que usar la ventana de exportación desde 2005; con todo el histórico las probabilidades difieren hasta 0,045. Falta registrar el artefacto como `artefacto_activo`. `docs/tenis_motor_filtro_real_20261117.md`. +- **Registro del artefacto preparado, no ejecutado (pedido del titular):** el plan §H.1 exige su OK en el chat para activar. Al prepararlo salieron tres huecos que habrían hecho inútil el registro: `python -m tenis.motor` solo imprimía «iniciado» (el cron no hacía nada), `cargar_artefacto_activo` tenía una ruta fija de tu PC y un respaldo que cargaba CUALQUIER json aunque la huella no coincidiera (contra §H.2), y la imagen no llevaba el artefacto. Ahora: cargador estricto por huella, `main` real, artefacto en `apps/tenis/artefactos/` y en la imagen, y `ops/registrar_artefacto.py` (validar/registrar/reactivar). `docs/tenis_registro_artefacto_20261117.md`. diff --git a/harness/tareas.md b/harness/tareas.md index 7deffa29..cf56559f 100644 --- a/harness/tareas.md +++ b/harness/tareas.md @@ -3374,3 +3374,17 @@ Referencia visual: `apps/mobile/docs/render_cybercore_20261114/` (36 láminas). - [x] **F7 · Servidor del rediseño CyberCore (15-nov-2026, PR #440):** código hecho (bajas con `regreso_fecha`/`jugador_id`/`foto`/`posicion`, `tenistas_sofascore.py` + bloque `tenis_sofascore`, comprobaciones F7c). Sin subir ni desplegar: ver la sección «Rediseño de la app — F7 servidor». Detalle: `apps/mobile/docs/PLAN_REDISENO_FASES_20261114.md` §F7. - [x] **F7c · Avisos push por deporte (15-nov-2026):** `db/115_push_por_deporte.sql` (`firebase_preferences.push_sports` TEXT[], NULL = todos; `account_notifications.sport`), `/app/v1/firebase/preferences` lee y guarda `push_sports` (sin el campo no se toca lo guardado: apps antiguas intactas), `enqueue(..., sport=)` y `deliver()` respetan la lista, `/notifications` devuelve `sport`, y la app 1.2.0+13 activa los interruptores por deporte (`kPushSports`, `push-sport-`). **Falta aplicar la migración y desplegar la API** (confirmación del titular). `enqueue` aún no tiene llamadores en producción: nada emite avisos todavía. + +## Tenis: capa de edad (2026-11-17) + +Plan y medición en `docs/tenis_capa_edad_20261117.md`. Rama `tenis/capa-edad`. + +- [x] Test de residuos de ~25 variables sobre el modelo congelado; la edad es la única con señal estable (6/6 temporadas ATP). +- [x] `modelo/capa_edad.py` (ajuste, aplicación, ventana expansiva), 9 pruebas; gancho en `motor.py` (`edades_al_corte`, `aplicar_capa_edad`) con pruebas contra Postgres. +- [x] `evaluar_wf.py` mide la capa y la compuerta `G_capa_edad`; `ops/congelar_capa_edad.py` escribe el artefacto nuevo con huella propia. +- [x] Walk-forward 2019-24: ATP −0,0022 [−0,0028; −0,0017], WTA −0,0026 [−0,0035; −0,0017] frente a la capa de pendiente; pasa en los dos circuitos. +- [x] Registro preparado (17-nov), **no ejecutado**: artefacto `apps/tenis/artefactos/tenis-2.1-capa-edad.json` (`tenis-2.1+55c17ba1c6e2`), `ops/registrar_artefacto.py` (validar / registrar / reactivar, sin `--ejecutar` no toca la base), cargador estricto por huella y `python -m tenis.motor` ya ejecuta una pasada real. `docs/tenis_registro_artefacto_20261117.md`. +- [ ] Activar el artefacto (OK del titular en el chat): antes, fusionar #505, cargar datos en la base `tenis` real y ensayar la imagen. +- [x] Motor con el filtro real (17-nov): `tenis/inferencia.py` reproduce el filtro desde la base; π idéntico (Δ = 0) al walk-forward en 60.741 partidos reales; sin pronóstico no se sella. Ver `docs/tenis_motor_filtro_real_20261117.md`. +- [ ] Estado del filtro en Parquet (plan H.2) para no leer toda la base en cada pasada (hoy ≈ 3 min). +- [ ] Opcional: edad dentro del filtro (reestimar hiperparámetros) y explicar la señal de actividad reciente.