Analisi più robusta: sigma con almeno 8 campioni, adeguatezza sulla scala dei residui, salti dai modelli

- sigma stimata solo con >= 8 campioni (altrimenti null); risultati.json senza NaN
- adeguatezza = scala robusta dei residui (scala_residui_vs_rumore_max)
- scarta_dopo_salto_n = 0, n_min_punti_parametri_fissi per i raffreddamenti a parametri fissi
- salto del riscaldamento stimato dai modelli adiacenti, con ripiego sulla misura corretta

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
This commit is contained in:
davideandClaude Sonnet 5.5 committed 2026-10-29 11:54:09 +01:00
1 parent 512d15f4c8
commit cbcbb7122b
6 files changed
+150 -71

No files matched your search

+72 -16
View File
@@ -1,10 +1,10 @@
"""Analisi: fit dei modelli per ogni dominio e serie e scelta con la regola di docs/algoritmi.md §6; il riscaldamento è descritto come salto."""
"""Analisi: fit dei modelli per ogni dominio e serie, scelta (docs/algoritmi.md §6) e stima dei salti del riscaldamento (§7)."""
import math
from .domini import sigma_rumore
from .fit import adatta
from .modelli import MODELLI
from .modelli import MODELLI, valuta
def valido(fit):
@@ -12,45 +12,100 @@ def valido(fit):
and math.isfinite(fit["aicc"]))
def fit_scelto(vs):
"""Il fit scelto di una voce di serie, o None (indeterminato, riscaldamento)."""
return next((x for x in vs["fit"] if x["modello"] == vs["scelta"]), None)
def scegli(fit_list, sigma, cfg):
"""(fit scelto, motivo, adeguato); (None, motivo, False) se nessun fit è valido."""
f = cfg["fit"]
validi = [x for x in fit_list if valido(x)]
if not validi:
return None, "indeterminato: nessun modello convergente, identificabile e lontano dai limiti", False
adeguati = [x for x in validi if x["rmse"] <= f["rmse_vs_rumore_max"] * sigma]
return None, "nessun modello convergente, identificabile e lontano dai limiti", False
noto = sigma is not None and math.isfinite(sigma) # con meno di 4 campioni σ non è stimabile
# adeguato = scala ROBUSTA dei residui vicina al rumore: come la perdita del fit, ignora gli scarti casuali (la RMSE no)
adeguati = [x for x in validi if noto and x["scala_residui"] <= f["scala_residui_vs_rumore_max"] * sigma]
pool = adeguati or validi
miglior = min(x["aicc"] for x in pool)
scelto = min((x for x in pool if x["aicc"] <= miglior + f["soglia_delta_aicc"]),
key=lambda x: (x["n_parametri"], x["aicc"]))
equivalenti = [x for x in pool if x["aicc"] <= miglior + f["soglia_delta_aicc"]]
scelto = min(equivalenti, key=lambda x: (x["n_parametri"], x["aicc"]))
motivo = (f"{len(validi)}/{len(fit_list)} modelli validi; "
+ ("modello adeguato" if adeguati else "nessun modello adeguato")
+ "; a parità di AICc, meno parametri")
return scelto, motivo, bool(adeguati)
+ ("modello adeguato" if adeguati else "nessun modello adeguato" if noto else "adeguatezza non valutabile (σ non stimabile)")
+ ("; tra i modelli equivalenti per AICc, quello con meno parametri" if len(equivalenti) > 1 else ""))
return scelto, motivo, bool(adeguati) if noto else None
def _gradino(t, y, d):
"""Descrizione del riscaldamento: salto dal campione prima della salita all'ultimo campione di salita."""
"""Descrizione del riscaldamento: salto misurato dal campione prima della salita all'ultimo campione di salita.
`_affina_salti` lo sostituisce con la stima dai modelli adiacenti quando possibile."""
i0, i1 = d["i0"], d["i1"]
prima, dopo = float(y[i0 - 1]), float(y[i1 - 1])
g = {"n": int(i1 - i0), "da": prima, "a": dopo, "delta": dopo - prima, "durata_s": float(t[i1 - 1] - t[i0 - 1])}
g = {"n": int(i1 - i0), "da": prima, "a": dopo, "delta": dopo - prima, "delta_misurato": dopo - prima,
"stima": "misura", "durata_s": float(t[i1 - 1] - t[i0 - 1])}
return {"sigma": None, "fit": [], "scelta": None, "gradino": g,
"motivo": f"salita rapida di {g['n']} campioni ({g['durata_s'] * 1000:.0f} ms), non fittata"}
def _serie(ty, yy, sigma, tipo, fissi, cfg):
voce = {"sigma": float(sigma), "fit": [], "scelta": None}
if len(yy) < cfg["domini"]["n_min_punti"]:
voce["motivo"] = f"indeterminato: {len(yy)} campioni < n_min_punti"
voce = {"sigma": float(sigma) if math.isfinite(sigma) else None, "fit": [], "scelta": None}
chiave = "n_min_punti_parametri_fissi" if fissi else "n_min_punti" # con c e τ fissi basta stimare A: bastano meno campioni
minimo = cfg["domini"][chiave]
if len(yy) < minimo:
voce["motivo"] = f"{len(yy)} campioni usati nel fit, meno del minimo {minimo} (`{chiave}`)"
return voce
for m in cfg["fit"]["modelli_per_tipo"][tipo]:
if len(MODELLI[m][1]) <= len(yy) - 2:
nomi = MODELLI[m][1]
if len(nomi) - len([p for p in (fissi or {}) if p in nomi]) <= len(yy) - 2: # parametri liberi ≤ n − 2
voce["fit"].append(adatta(ty, yy, m, sigma, cfg, fissi))
scelto, voce["motivo"], voce["adeguato"] = scegli(voce["fit"], sigma, cfg)
scelto, voce["motivo"], voce["adeguato"] = scegli(voce["fit"], voce["sigma"], cfg)
voce["scelta"] = scelto["modello"] if scelto else None
return voce
def _valore(dominio, nome, t):
"""Valore del modello scelto di un dominio (per la serie `nome`) all'istante t; None se non ha un modello."""
fit = fit_scelto(dominio["serie"][nome])
if fit is None:
return None
return float(valuta(fit["modello"], t - dominio["t0_s"], list(fit["parametri"].values())))
def _finale(risultati):
"""Il risultato del raffreddamento finale (ultimo dominio di raffreddamento), o None."""
return next((r for r in reversed(risultati) if r["tipo"] == "raffreddamento"), None)
def _affina_salti(t, serie, risultati, domini):
"""Stima il salto di ogni riscaldamento all'istante del gradino (a metà tra l'ultimo campione prima della salita e il
primo in salita), perché la misura sui campioni lo sottostima (l'ultimo campione di salita è già in parte decaduto):
1. "modelli": differenza tra i modelli scelti per i due domini adiacenti, valutati in quell'istante;
2. "misura corretta": se manca un modello adiacente (tratto indeterminato) ma c'è il raffreddamento finale, la misura
con i due campioni riportati all'istante del gradino usando $c$ e τ del finale (stessa legge di decadimento);
3. "misura": altrimenti la misura sui campioni.
Una stima che si discosta più del 50 % dalla misura è scartata (guardia contro fit anomali)."""
finale = _finale(risultati)
for i, (r, d) in enumerate(zip(risultati, domini, strict=True)):
if r["tipo"] != "riscaldamento" or i == 0 or i + 1 >= len(risultati):
continue
ts = float(0.5 * (t[d["i0"] - 1] + t[d["i0"]]))
for nome, vs in r["serie"].items():
g = vs["gradino"]
prima, dopo = _valore(risultati[i - 1], nome, ts), _valore(risultati[i + 1], nome, ts)
stima = "modelli"
if prima is None or dopo is None:
fit = fit_scelto(finale["serie"][nome]) if finale else None
if fit is None or "tau" not in fit["parametri"]:
continue
c, tau, y = fit["parametri"]["c"], fit["parametri"]["tau"], serie[nome]
prima = c + (y[d["i0"] - 1] - c) * math.exp(-(ts - t[d["i0"] - 1]) / tau)
dopo = c + (y[d["i1"] - 1] - c) * math.exp((t[d["i1"] - 1] - ts) / tau)
stima = "misura corretta"
delta = float(dopo - prima)
if math.isfinite(delta) and abs(delta - g["delta_misurato"]) <= 0.5 * abs(g["delta_misurato"]):
g.update(da=float(prima), a=float(dopo), delta=delta, stima=stima, istante_s=ts)
def analizza_domini(t, serie, domini, cfg):
"""Un risultato per dominio. Il raffreddamento finale (ultimo) si fitta per primo, con parametri liberi; i
raffreddamenti intermedi (tra due gradini, corti) fissano i parametri di `raffreddamento_intermedio_fissa_da_finale`
@@ -76,4 +131,5 @@ def analizza_domini(t, serie, domini, cfg):
par = next(x for x in vs["fit"] if x["modello"] == vs["scelta"])["parametri"]
fissi[nome] = {k: par[k] for k in cfg["fit"]["raffreddamento_intermedio_fissa_da_finale"] if k in par}
risultati[idx] = voce
_affina_salti(t, serie, risultati, domini)
return risultati