From bb4ba45aa4e7fc24872328c28e060f1eeb2b5fcf Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Rapha=C3=ABl=20Bonnet=20Guerrini?= <81559347+rbonnetguerrini@users.noreply.github.com> Date: Wed, 25 Feb 2026 19:40:46 +0100 Subject: [PATCH 01/21] Initial commit for the shapley value integration for NNPDF usage. --- .gitignore | 4 + pyproject.toml | 2 + validphys2/src/validphys/shapley/__init__.py | 66 +++ validphys2/src/validphys/shapley/analyzer.py | 528 ++++++++++++++++++ .../src/validphys/shapley/perturbation.py | 90 +++ .../shapley/runcards/sv_dis_hera.yaml | 29 + .../validphys/shapley/runcards/sv_dy_lhc.yaml | 35 ++ .../validphys/shapley/runcards/sv_global.yaml | 73 +++ .../src/validphys/shapley/scripts/__init__.py | 0 .../validphys/shapley/scripts/vp_shapley.py | 185 ++++++ validphys2/src/validphys/shapley/setup.py | 471 ++++++++++++++++ validphys2/src/validphys/shapley/sumrules.py | 97 ++++ 12 files changed, 1580 insertions(+) create mode 100644 validphys2/src/validphys/shapley/__init__.py create mode 100644 validphys2/src/validphys/shapley/analyzer.py create mode 100644 validphys2/src/validphys/shapley/perturbation.py create mode 100644 validphys2/src/validphys/shapley/runcards/sv_dis_hera.yaml create mode 100644 validphys2/src/validphys/shapley/runcards/sv_dy_lhc.yaml create mode 100644 validphys2/src/validphys/shapley/runcards/sv_global.yaml create mode 100644 validphys2/src/validphys/shapley/scripts/__init__.py create mode 100644 validphys2/src/validphys/shapley/scripts/vp_shapley.py create mode 100644 validphys2/src/validphys/shapley/setup.py create mode 100644 validphys2/src/validphys/shapley/sumrules.py diff --git a/.gitignore b/.gitignore index 7420df1138..11a18703b7 100644 --- a/.gitignore +++ b/.gitignore @@ -436,5 +436,9 @@ Session.vim # auto-generated tag files tags +# Shapley values results +sv_results + + # End of https://www.gitignore.io/api/c++,latex,cmake,python,jupyternotebook,qtcreator,vim diff --git a/pyproject.toml b/pyproject.toml index 261c28b207..1bafa9607d 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -55,10 +55,12 @@ vp-list = "validphys.scripts.vp_list:main" vp-nextfitruncard = "validphys.scripts.vp_nextfitruncard:main" vp-hyperoptplot = "validphys.scripts.vp_hyperoptplot:main" vp-deltachi2 = "validphys.scripts.vp_deltachi2:main" +vp-shapley = "validphys.shapley.scripts.vp_shapley:main" [tool.poetry.dependencies] # Generic dependencies (i.e., validphys) python = ">=3.9" +shapley-values = "*" matplotlib = "^3.9" pineappl = "^1.0.0" # TODO: make the code compatible with pandas 3 diff --git a/validphys2/src/validphys/shapley/__init__.py b/validphys2/src/validphys/shapley/__init__.py new file mode 100644 index 0000000000..c6139fcb62 --- /dev/null +++ b/validphys2/src/validphys/shapley/__init__.py @@ -0,0 +1,66 @@ +"""Shapley value analysis for NNPDF PDF flavour importance. + +Subpackage of validphys that provides tools for computing exact Shapley +values to quantify the importance of individual PDF flavours in +constraining experimental observables. + +Uses the external ``shapley_values`` package for the problem-agnostic +Shapley computation, and wraps NNPDF-specific components: + - Dense FK tensor convolution for fast repeated chi2 evaluation + - Gaussian perturbation of PDF grid values + - MSR + VSR sum rule enforcement + - Evolution / physical-flavor basis support + +Typical usage via CLI:: + + vp-shapley runcards/sv_dis_hera.yaml + +Or from Python:: + + from validphys.shapley import ( + setup_observables, + NNPDFShapleyAnalyzer, + ) +""" + +from .setup import ( + setup_observables, + get_pdf_grid_values, + get_pdf_flavor_grid_values, + get_pdf_grid_values_all14, + FKEntry, + NNPDFObservable, + FLAVOR_PDG_NAMES, +) +from .perturbation import ( + gaussian_profile, + apply_gaussian_perturbation, + PERTURBATION_MODES, + PERTURBATION_XSPACES, +) +from .sumrules import ( + gen_integration_input, + compute_sumrule_normalization, +) +from .analyzer import NNPDFShapleyAnalyzer + +__all__ = [ + # Setup + "setup_observables", + "get_pdf_grid_values", + "get_pdf_flavor_grid_values", + "get_pdf_grid_values_all14", + "FKEntry", + "NNPDFObservable", + "FLAVOR_PDG_NAMES", + # Perturbation + "gaussian_profile", + "apply_gaussian_perturbation", + "PERTURBATION_MODES", + "PERTURBATION_XSPACES", + # Sum rules + "gen_integration_input", + "compute_sumrule_normalization", + # Analyzer + "NNPDFShapleyAnalyzer", +] diff --git a/validphys2/src/validphys/shapley/analyzer.py b/validphys2/src/validphys/shapley/analyzer.py new file mode 100644 index 0000000000..6df66fa6f4 --- /dev/null +++ b/validphys2/src/validphys/shapley/analyzer.py @@ -0,0 +1,528 @@ +"""NNPDF Shapley value analyzer. + +Wraps NNPDF chi2 evaluation into a value function for the generic +ExactShapley solver from the ``shapley_values`` package. Handles: + - Evolution and physical-flavor perturbation bases + - Multi-FK datasets with operations (ASY, RATIO, ADD) + - MSR + VSR sum rule enforcement + - Grid-value caching for performance +""" + +import functools +import time + +import numpy as np +import matplotlib.pyplot as plt +import matplotlib.patches as mpatches + +from validphys.convolution import FK_FLAVOURS +from validphys.pdfbases import evolution as evol_basis, ALL_FLAVOURS +from validphys.gridvalues import grid_values as _lhapdf_grid_values + +from shapley_values import ExactShapley, plot_shapley_bar + +from .setup import ( + get_pdf_grid_values, + get_pdf_flavor_grid_values, + get_pdf_grid_values_all14, + FLAVOR_PDG_NAMES, +) +from .perturbation import ( + gaussian_profile, + apply_gaussian_perturbation, + PERTURBATION_MODES, + PERTURBATION_XSPACES, +) +from .sumrules import ( + gen_integration_input, + compute_sumrule_normalization, +) + + +class NNPDFShapleyAnalyzer: + """Compute Shapley values for PDF flavour importance. + + Supports two perturbation bases: + - evolution : players are evolution-basis flavours (Sigma, g, V, T3, ...). + - flavor : players are physical quarks/gluon; rotated before convolution. + + Parameters + ---------- + pdf : validphys.core.PDF + observables : list of NNPDFObservable + flavor_info : dict + Flavor metadata from setup_observables. + n_replicas : int or None + basis : str + 'evolution' or 'flavor'. + enforce_sumrules : bool + If True, re-impose momentum and valence sum rules on the + perturbed PDF before convolution. + """ + + EVOL_LABELS = { + "photon": "gamma (photon)", + "\\Sigma": "Sigma (singlet)", + "g": "g (gluon)", + "V": "V (valence)", + "V3": "V3", "V8": "V8", "V15": "V15", "V24": "V24", "V35": "V35", + "T3": "T3", "T8": "T8", "T15": "T15", "T24": "T24", "T35": "T35", + } + + EVOL_SHORT = { + "photon": "gamma", + "\\Sigma": "Sigma", + "g": "g", + "V": "V", + "V3": "V3", "V8": "V8", "V15": "V15", "V24": "V24", "V35": "V35", + "T3": "T3", "T8": "T8", "T15": "T15", "T24": "T24", "T35": "T35", + } + + def __init__(self, pdf, observables, flavor_info, n_replicas=None, + basis='evolution', enforce_sumrules=False): + self.pdf = pdf + self.observables = observables + self.flavor_info = flavor_info + self.n_replicas = n_replicas + self.basis = basis + self.enforce_sumrules = enforce_sumrules + + self._gv_cache: dict = {} + + # Sum rule integration grid (lazily initialised) + self._sr_xgrid = None + self._sr_weights = None + self._sr_gv_evol = None + self._sr_gv_flav = None + self._sr_rotation = None + + if basis == 'evolution': + self.flavor_names = flavor_info["names"] + self.flavor_indices = flavor_info["indices"] + self.n_flavors = flavor_info["n_flavors"] + self.flavor_labels = [ + self.EVOL_LABELS.get(n, n) for n in self.flavor_names + ] + self.flavor_short = [ + self.EVOL_SHORT.get(n, n) for n in self.flavor_names + ] + elif basis == 'flavor': + self.flavor_names = flavor_info["names"] + self.flavor_indices = flavor_info["indices"] + self.n_flavors = flavor_info["n_flavors"] + self.flavor_labels = self.flavor_names + self.flavor_short = self.flavor_names + else: + raise ValueError( + f"Unknown basis '{basis}'. Use 'evolution' or 'flavor'." + ) + + # -- Sum rule setup and computation ------------------------------------ + + def _setup_sumrule_grid(self): + """Lazily initialise the integration grid for sum rules.""" + self._sr_xgrid, self._sr_weights = gen_integration_input(2000) + Q0 = self.observables[0].Q0 + + self._sr_gv_evol = evol_basis.grid_values( + self.pdf, qmat=[Q0], vmat=FK_FLAVOURS, xmat=self._sr_xgrid + ).squeeze(-1) + if self.n_replicas is not None: + self._sr_gv_evol = self._sr_gv_evol[1: self.n_replicas + 1] + + if self.basis == 'flavor': + self._sr_gv_flav = _lhapdf_grid_values( + self.pdf, list(ALL_FLAVOURS), self._sr_xgrid, [Q0] + ).squeeze(-1) + if self.n_replicas is not None: + self._sr_gv_flav = self._sr_gv_flav[1: self.n_replicas + 1] + + evol_row_inds = evol_basis._to_indexes(FK_FLAVOURS) + self._sr_rotation = evol_basis.from_flavour_mat[evol_row_inds, :] + + def _compute_sumrule_norm(self, flavor_subset, mu, sigma, amplitude, + mode, xspace): + """Compute normalization constants for a perturbed coalition.""" + if self._sr_xgrid is None: + self._setup_sumrule_grid() + + if self.basis == 'evolution': + gv = self._sr_gv_evol.copy() + perturb_idx = [self.flavor_indices[p] for p in flavor_subset] + gv_pert = apply_gaussian_perturbation( + gv, perturb_idx, mu, sigma, amplitude, + self._sr_xgrid, mode=mode, xspace=xspace + ) + else: + gv_flav = self._sr_gv_flav.copy() + perturb_idx = [self.flavor_indices[p] for p in flavor_subset] + gv_flav_pert = apply_gaussian_perturbation( + gv_flav, perturb_idx, mu, sigma, amplitude, + self._sr_xgrid, mode=mode, xspace=xspace + ) + gv_pert = np.einsum( + 'ef,rfx->rex', self._sr_rotation, gv_flav_pert + ) + + return compute_sumrule_normalization( + gv_pert, self._sr_xgrid, self._sr_weights + ) + + @staticmethod + def _apply_norm_to_gv(gv, norm, flavor_indices): + """Multiply grid values by per-flavour normalization constants.""" + local_norm = norm[:, flavor_indices] + return gv * local_norm[:, :, np.newaxis] + + # -- Grid-value caching ------------------------------------------------ + + def clear_cache(self): + """Drop cached grid values.""" + self._gv_cache.clear() + + def _get_gv_for_entry(self, obs, entry_idx): + """Cached evolution-basis grid values (FK-subset flavours).""" + key = (obs.name, entry_idx, 'evol') + if key not in self._gv_cache: + entry = obs.fk_entries[entry_idx] + self._gv_cache[key] = get_pdf_grid_values( + self.pdf, entry, n_replicas=self.n_replicas + ) + return self._gv_cache[key] + + def _get_flavor_gv_for_entry(self, obs, entry_idx): + """Cached physical flavor-basis grid values.""" + key = (obs.name, entry_idx, 'flavor') + if key not in self._gv_cache: + entry = obs.fk_entries[entry_idx] + self._gv_cache[key] = get_pdf_flavor_grid_values( + self.pdf, entry, n_replicas=self.n_replicas + ) + return self._gv_cache[key] + + def _get_gv_all14_for_entry(self, obs, entry_idx): + """Cached full 14-flavour evolution-basis grid values.""" + key = (obs.name, entry_idx, 'evol_all14') + if key not in self._gv_cache: + entry = obs.fk_entries[entry_idx] + self._gv_cache[key] = get_pdf_grid_values_all14( + self.pdf, entry, n_replicas=self.n_replicas + ) + return self._gv_cache[key] + + def _get_gv_list(self, obs): + """Get list of baseline grid values for all FK entries.""" + result = [] + for idx, entry in enumerate(obs.fk_entries): + if entry.hadronic: + result.append(self._get_gv_all14_for_entry(obs, idx)) + else: + result.append(self._get_gv_for_entry(obs, idx)) + return result + + def _local_flavor_indices_for_entry(self, entry, global_flavor_subset): + """Map global Shapley-player indices to local FK column indices.""" + local = [] + fi_list = entry.flavor_indices.tolist() + for player in global_flavor_subset: + global_fi = self.flavor_indices[player] + if global_fi in fi_list: + local.append(fi_list.index(global_fi)) + return local + + # -- Chi2 evaluation with perturbation ---------------------------------- + + def _evaluate_chi2(self, flavor_subset, mu, sigma, amplitude, + mode='additive', xspace='linear'): + """Mean chi2/Ndata across all observables for a given perturbation. + + Parameters + ---------- + flavor_subset : list of int + Global Shapley-player indices to perturb. + mu, sigma, amplitude : float + mode : str + xspace : str + + Returns + ------- + chi2 : float + """ + sr_norm = None + if self.enforce_sumrules: + sr_norm = self._compute_sumrule_norm( + flavor_subset, mu, sigma, amplitude, mode, xspace + ) + + total_chi2 = 0.0 + total_ndata = 0 + + for obs in self.observables: + if self.basis == 'flavor': + gv_pert_list = [] + for idx, entry in enumerate(obs.fk_entries): + gv_flav = self._get_flavor_gv_for_entry(obs, idx) + perturb_idx = [ + self.flavor_indices[p] for p in flavor_subset + ] + gv_pert = apply_gaussian_perturbation( + gv_flav, perturb_idx, mu, sigma, amplitude, + entry.xgrid, mode=mode, xspace=xspace + ) + gv_pert_list.append(gv_pert) + + if sr_norm is not None: + gv_evol_list = obs.rotate_to_evolution(gv_pert_list) + gv_evol_list = [ + self._apply_norm_to_gv( + gv, sr_norm, + range(14) if entry.hadronic + else entry.flavor_indices + ) + for gv, entry in zip(gv_evol_list, obs.fk_entries) + ] + chi2_arr = obs.chi2(gv_evol_list) + else: + chi2_arr = obs.chi2_from_flavor(gv_pert_list) + else: + gv_pert_list = [] + for idx, entry in enumerate(obs.fk_entries): + if entry.hadronic: + gv = self._get_gv_all14_for_entry(obs, idx) + perturb_idx = [ + self.flavor_indices[p] for p in flavor_subset + ] + else: + gv = self._get_gv_for_entry(obs, idx) + perturb_idx = self._local_flavor_indices_for_entry( + entry, flavor_subset + ) + gv_pert = apply_gaussian_perturbation( + gv, perturb_idx, mu, sigma, amplitude, + entry.xgrid, mode=mode, xspace=xspace + ) + if sr_norm is not None: + fi = (range(14) if entry.hadronic + else entry.flavor_indices) + gv_pert = self._apply_norm_to_gv( + gv_pert, sr_norm, fi + ) + gv_pert_list.append(gv_pert) + chi2_arr = obs.chi2(gv_pert_list) + + total_chi2 += np.mean(chi2_arr) + total_ndata += obs.ndata + + return total_chi2 / total_ndata + + # -- Build value function for ExactShapley ------------------------------ + + def build_value_function(self, mu, sigma, amplitude, + mode='additive', xspace='linear'): + """Return a callable v(coalition) -> float for ExactShapley. + + Parameters + ---------- + mu, sigma, amplitude : float + Gaussian perturbation parameters. + mode : str + xspace : str + + Returns + ------- + value_function : callable + f(List[int]) -> float + """ + def v(coalition): + return self._evaluate_chi2( + coalition, mu, sigma, amplitude, + mode=mode, xspace=xspace, + ) + return v + + # -- Convenience: run full Shapley analysis ----------------------------- + + def exact_shap(self, mu, sigma, amplitude, mode='additive', + xspace='linear', plot=True): + """Compute exact Shapley values for all flavour players. + + Uses the ``shapley_values.ExactShapley`` solver with the NNPDF + chi2 value function. + + Parameters + ---------- + mu, sigma, amplitude : float + mode : str + xspace : str + plot : bool + Whether to generate plots. + + Returns + ------- + results : dict + """ + if mode not in PERTURBATION_MODES: + raise ValueError( + f"Unknown mode '{mode}'. Choose from {PERTURBATION_MODES}." + ) + if xspace not in PERTURBATION_XSPACES: + raise ValueError( + f"Unknown xspace '{xspace}'. Choose from {PERTURBATION_XSPACES}." + ) + + basis_name = "flavor" if self.basis == 'flavor' else "evolution" + print(f"Perturbation basis : {basis_name}") + print(f"Perturbation mode : {mode}") + print(f"Perturbation xspace: {xspace}") + print(f"Sum rules : {'ON' if self.enforce_sumrules else 'OFF'}") + + # Build value function and run ExactShapley + v = self.build_value_function(mu, sigma, amplitude, mode, xspace) + + solver = ExactShapley( + n_players=self.n_flavors, + value_function=v, + player_labels=self.flavor_labels, + player_short=self.flavor_short, + ) + + results = solver.compute(verbose=True) + + # Add NNPDF-specific metadata + results["baseline_chi2"] = results["baseline"] + results["mode"] = mode + results["xspace"] = xspace + results["enforce_sumrules"] = self.enforce_sumrules + results["basis"] = self.basis + results["flavor_labels"] = self.flavor_labels + results["flavor_short"] = self.flavor_short + + # Plot + fig_pdfs = None + fig_bar = None + if plot: + fig_pdfs = self.plot_pdfs( + amplitude=amplitude, mu=mu, sigma=sigma, + mode=mode, xspace=xspace, + ) + fig_bar = plot_shapley_bar( + results["shapley_values"], + self.flavor_short, + title=( + f"PDF Flavour Importance ({basis_name}) " + f"mu={mu}, sigma={sigma}, A={amplitude}, " + f"mode={mode}, xspace={xspace}" + ), + ylabel="Shapley Value (delta chi2/N)", + ) + plt.show() + + results["fig_pdfs"] = fig_pdfs + results["fig_bar"] = fig_bar + + return results + + # -- Plotting ----------------------------------------------------------- + + def plot_pdfs(self, amplitude=0.08, mu=0.02, sigma=0.1, + mode='additive', xspace='linear', x_points=200): + """Plot reference vs perturbed PDFs for all Shapley-player flavours.""" + x_plot = np.logspace(-5, -0.001, x_points) + Q0 = self.observables[0].Q0 + + if self.basis == 'flavor': + pdg_codes = [int(ALL_FLAVOURS[i]) for i in self.flavor_indices] + gv_ref = _lhapdf_grid_values( + self.pdf, pdg_codes, x_plot, [Q0] + ).squeeze(-1) + else: + gv_func = functools.partial(evol_basis.grid_values, self.pdf) + all_names = FK_FLAVOURS[self.flavor_indices] + gv_ref = gv_func( + qmat=[Q0], vmat=all_names, xmat=x_plot + ).squeeze(-1) + + if self.n_replicas is not None: + gv_ref = gv_ref[1: self.n_replicas + 1] + + gauss = gaussian_profile(x_plot, mu, sigma, amplitude, xspace) + gv_pert = gv_ref.copy() + if mode == 'additive': + for i in range(gv_pert.shape[1]): + gv_pert[:, i, :] += gauss[np.newaxis, :] + else: + for i in range(gv_pert.shape[1]): + gv_pert[:, i, :] *= (1.0 + gauss[np.newaxis, :]) + + n = len(self.flavor_short) + ncols = min(3, n) + nrows = int(np.ceil(n / ncols)) + fig, axes = plt.subplots(nrows, ncols, figsize=(6 * ncols, 4 * nrows)) + axes = np.atleast_1d(axes).ravel() + + for i in range(n): + ax = axes[i] + ref_mean = np.mean(gv_ref[:, i, :], axis=0) + ref_std = np.std(gv_ref[:, i, :], axis=0) + pert_mean = np.mean(gv_pert[:, i, :], axis=0) + + ax.plot(x_plot, ref_mean, "b-", lw=1.5, label="Reference") + ax.fill_between( + x_plot, ref_mean - ref_std, ref_mean + ref_std, + alpha=0.25, color="blue" + ) + ax.plot(x_plot, pert_mean, "r--", lw=1.5, label="Perturbed") + ax.set_xscale("log") + ax.set_title(self.flavor_labels[i]) + ax.set_xlabel("x") + ax.set_ylabel("xf(x)") + ax.legend(fontsize=8) + ax.grid(True, alpha=0.3, ls="--") + + for j in range(n, len(axes)): + axes[j].axis("off") + + basis_name = "Flavor" if self.basis == 'flavor' else "Evolution" + fig.suptitle( + f"{basis_name}-basis PDFs: A={amplitude}, mu={mu}, " + f"sigma={sigma}, mode={mode}, xspace={xspace}", + fontsize=14, fontweight="bold", y=1.01, + ) + plt.tight_layout() + plt.show() + return fig + + def plot_predictions(self): + """Plot theory predictions vs experimental data.""" + n_obs = len(self.observables) + ncols = min(3, n_obs) + nrows = int(np.ceil(n_obs / ncols)) + fig, axes = plt.subplots(nrows, ncols, figsize=(6 * ncols, 4 * nrows)) + axes = np.atleast_1d(axes).ravel() + + for i, obs in enumerate(self.observables): + ax = axes[i] + gv_list = self._get_gv_list(obs) + preds = obs.convolve(gv_list) + pred_mean = preds.mean(axis=1) + pred_std = preds.std(axis=1) + idx = np.arange(obs.ndata) + + ax.scatter(idx, obs.data_central, s=12, c="blue", alpha=0.7, + label="Data", zorder=3, edgecolors="darkblue", lw=0.3) + ax.errorbar(idx, pred_mean, yerr=pred_std, fmt="x", color="red", + capsize=2, ms=4, lw=1, label="Prediction", alpha=0.8) + ax.set_title(obs.name, fontsize=8, fontweight="bold") + ax.set_xlabel("Data point") + ax.set_ylabel("Observable") + ax.legend(fontsize=7) + ax.grid(True, alpha=0.3, ls="--") + + for j in range(n_obs, len(axes)): + axes[j].axis("off") + + fig.suptitle("Predictions vs Data", + fontsize=13, fontweight="bold") + plt.tight_layout() + plt.show() + return fig diff --git a/validphys2/src/validphys/shapley/perturbation.py b/validphys2/src/validphys/shapley/perturbation.py new file mode 100644 index 0000000000..d430b4cdc7 --- /dev/null +++ b/validphys2/src/validphys/shapley/perturbation.py @@ -0,0 +1,90 @@ +"""Gaussian perturbation of PDF grid values. + +Provides tools for perturbing selected flavour channels with a Gaussian +bump. Two independent parameters control the perturbation: + - mode: 'additive' or 'multiplicative' + - xspace: 'linear' or 'logx' +""" + +import numpy as np + +# Valid perturbation parameter choices +PERTURBATION_MODES = ('additive', 'multiplicative') +PERTURBATION_XSPACES = ('linear', 'logx') + + +def gaussian_profile(xgrid, mu, sigma, amplitude, xspace='linear'): + """Build the perturbation profile G(x) for a given x-space. + + Returns an array of shape (nx,). + + Parameters + ---------- + xgrid : array-like + x values. + mu : float + Centre of the Gaussian. + sigma : float + Width. For xspace='logx', sigma is in decades of log10(x). + amplitude : float + Peak height of the Gaussian. + xspace : str + 'linear': G(x) = A * exp(-0.5 * ((x - mu) / sigma)^2) + 'logx': G(x) = A * exp(-0.5 * ((log10(x) - log10(mu)) / sigma)^2) + """ + x = np.asarray(xgrid) + if xspace == 'logx': + log_x = np.log10(np.clip(x, 1e-30, None)) + log_mu = np.log10(max(mu, 1e-30)) + return amplitude * np.exp(-0.5 * ((log_x - log_mu) / sigma) ** 2) + else: + return amplitude * np.exp(-0.5 * ((x - mu) / sigma) ** 2) + + +def apply_gaussian_perturbation(gv, local_flavor_idx, mu, sigma, amplitude, + xgrid, mode='additive', xspace='linear'): + """Perturb selected flavour channels with a Gaussian bump. + + Parameters + ---------- + gv : np.ndarray, shape (nrep, nfl, nx) + Grid values to perturb. + local_flavor_idx : list of int + Indices into the flavour axis to perturb. + mu, sigma, amplitude : float + Gaussian parameters. + xgrid : array-like + x values corresponding to the last axis of gv. + mode : str + 'additive': f -> f + A * G(x) + 'multiplicative': f -> f * (1 + A * G(x)) + xspace : str + 'linear' or 'logx' + + Returns + ------- + gv_pert : np.ndarray + Perturbed copy of gv. + """ + if len(local_flavor_idx) == 0: + return gv + if mode not in PERTURBATION_MODES: + raise ValueError( + f"Unknown perturbation mode '{mode}'. " + f"Choose from {PERTURBATION_MODES}." + ) + if xspace not in PERTURBATION_XSPACES: + raise ValueError( + f"Unknown perturbation xspace '{xspace}'. " + f"Choose from {PERTURBATION_XSPACES}." + ) + gv_pert = gv.copy() + gauss = gaussian_profile(xgrid, mu, sigma, amplitude, xspace) + + if mode == 'additive': + for fi in local_flavor_idx: + gv_pert[:, fi, :] += gauss[np.newaxis, :] + else: # multiplicative + for fi in local_flavor_idx: + gv_pert[:, fi, :] *= (1.0 + gauss[np.newaxis, :]) + return gv_pert diff --git a/validphys2/src/validphys/shapley/runcards/sv_dis_hera.yaml b/validphys2/src/validphys/shapley/runcards/sv_dis_hera.yaml new file mode 100644 index 0000000000..72aeba1547 --- /dev/null +++ b/validphys2/src/validphys/shapley/runcards/sv_dis_hera.yaml @@ -0,0 +1,29 @@ +# Shapley value runcard - HERA DIS only + +pdf_name: NNPDF40_nnlo_as_01180 +theory_id: 708 +use_cuts: internal +n_replicas: 100 + +basis: + - evolution + - flavor + +perturbation: + mu: 0.02 + sigma: 0.1 + amplitude: 0.08 + mode: multiplicative + +enforce_sumrules: true + +datasets: + - HERA_NC_318GEV_EP-SIGMARED + - HERA_NC_318GEV_EM-SIGMARED + - HERA_NC_300GEV_EP-SIGMARED + - HERA_NC_251GEV_EP-SIGMARED + - HERA_NC_225GEV_EP-SIGMARED + - HERA_CC_318GEV_EP-SIGMARED + - HERA_CC_318GEV_EM-SIGMARED + - HERA_NC_318GEV_EAVG_CHARM-SIGMARED + - HERA_NC_318GEV_EAVG_BOTTOM-SIGMARED diff --git a/validphys2/src/validphys/shapley/runcards/sv_dy_lhc.yaml b/validphys2/src/validphys/shapley/runcards/sv_dy_lhc.yaml new file mode 100644 index 0000000000..0433d401f4 --- /dev/null +++ b/validphys2/src/validphys/shapley/runcards/sv_dy_lhc.yaml @@ -0,0 +1,35 @@ +# Shapley value runcard Drell-Yan focus (ATLAS + CMS + LHCb) +# Hadronic-only datasets, both bases for comparison. + +pdf_name: NNPDF40_nnlo_as_01180 +theory_id: 708 +use_cuts: internal +n_replicas: 100 + +basis: + - evolution + - flavor + +perturbation: + mu: 0.02 + sigma: 0.1 + amplitude: 0.30 + +datasets: + # ATLAS DY + - ATLAS_Z0_7TEV_49FB_HIMASS + - ATLAS_Z0_7TEV_46FB_CC-Y + - ATLAS_WPWM_7TEV_46FB_CC-ETA + - ATLAS_Z0J_8TEV_PT-M + - ATLAS_Z0_8TEV_ZMASS_LL + # CMS DY + - CMS_Z0_7TEV_DIMUON_2D + - CMS_WPWM_7TEV_ELECTRON_ASY + - CMS_WPWM_8TEV_MUON_Y + - CMS_Z0J_8TEV_PT-Y + # LHCb DY + - LHCB_Z0_7TEV_DIELECTRON_Y + - LHCB_WPWM_7TEV_MUON_Y + - LHCB_Z0_8TEV_DIELECTRON_Y + - LHCB_WPWM_8TEV_MUON_Y + - LHCB_Z0_13TEV_DIMUON-Y diff --git a/validphys2/src/validphys/shapley/runcards/sv_global.yaml b/validphys2/src/validphys/shapley/runcards/sv_global.yaml new file mode 100644 index 0000000000..b1c90ab59d --- /dev/null +++ b/validphys2/src/validphys/shapley/runcards/sv_global.yaml @@ -0,0 +1,73 @@ +# Shapley value runcard - full NNPDF4.0-like global fit +# 46 datasets (DIS + DY + jets + single top), both bases. + + +pdf_name: NNPDF40_nnlo_as_01180 +theory_id: 708 +use_cuts: internal +n_replicas: 100 + +basis: + - evolution + - flavor + +perturbation: + mu: 0.02 + sigma: 0.1 + amplitude: 0.30 + +datasets: + # DIS: HERA combined + - HERA_NC_318GEV_EP-SIGMARED + - HERA_NC_318GEV_EM-SIGMARED + - HERA_NC_300GEV_EP-SIGMARED + - HERA_NC_251GEV_EP-SIGMARED + - HERA_NC_225GEV_EP-SIGMARED + - HERA_CC_318GEV_EP-SIGMARED + - HERA_CC_318GEV_EM-SIGMARED + - HERA_NC_318GEV_EAVG_CHARM-SIGMARED + - HERA_NC_318GEV_EAVG_BOTTOM-SIGMARED + # DY: Fixed-target + - DYE605_Z0_38P8GEV_DW_PXSEC + - DYE866_Z0_800GEV_PXSEC + # DY: Tevatron + - CDF_Z0_1P96TEV_ZRAP + - D0_Z0_1P96TEV_ZRAP + - D0_WPWM_1P96TEV_ASY + # DY: ATLAS + - ATLAS_Z0_7TEV_49FB_HIMASS + - ATLAS_Z0_7TEV_46FB_CC-Y + - ATLAS_Z0_7TEV_46FB_CF-Y + - ATLAS_WPWM_7TEV_46FB_CC-ETA + - ATLAS_WPWM_7TEV_36PB_ETA + - ATLAS_Z0J_8TEV_PT-M + - ATLAS_Z0J_8TEV_PT-Y + - ATLAS_Z0_8TEV_ZMASS_LL + - ATLAS_Z0_8TEV_LOWMASS_M-Y + - ATLAS_Z0_8TEV_HIMASS_M-Y + - ATLAS_Z0_13TEV_TOT + - ATLAS_WPWM_13TEV_TOT + # DY: CMS + - CMS_Z0_7TEV_DIMUON_2D + - CMS_WPWM_7TEV_ELECTRON_ASY + - CMS_WPWM_7TEV_MUON_ASY + - CMS_WPWM_8TEV_MUON_Y + - CMS_Z0J_8TEV_PT-Y + # DY: LHCb + - LHCB_Z0_7TEV_DIELECTRON_Y + - LHCB_Z0_7TEV_MUON_Y + - LHCB_Z0_8TEV_DIELECTRON_Y + - LHCB_Z0_8TEV_MUON_Y + - LHCB_WPWM_7TEV_MUON_Y + - LHCB_WPWM_8TEV_MUON_Y + - LHCB_DY_7TEV_MUON_Y + - LHCB_DY_8TEV_MUON_Y + - LHCB_Z0_13TEV_DIMUON-Y + - LHCB_Z0_13TEV_DIELECTRON-Y + # Jets + - CMS_1JET_8TEV_PTY + - CMS_2JET_7TEV_M12Y + # Single top + - CMS_SINGLETOP_7TEV_TCHANNEL-XSEC + - ATLAS_SINGLETOP_7TEV_T-Y-NORM + - ATLAS_SINGLETOP_7TEV_TBAR-Y-NORM diff --git a/validphys2/src/validphys/shapley/scripts/__init__.py b/validphys2/src/validphys/shapley/scripts/__init__.py new file mode 100644 index 0000000000..e69de29bb2 diff --git a/validphys2/src/validphys/shapley/scripts/vp_shapley.py b/validphys2/src/validphys/shapley/scripts/vp_shapley.py new file mode 100644 index 0000000000..5e89e2ce39 --- /dev/null +++ b/validphys2/src/validphys/shapley/scripts/vp_shapley.py @@ -0,0 +1,185 @@ +#!/usr/bin/env python3 +"""Run NNPDF Shapley value analysis from a YAML runcard. + +Usage +----- + vp-shapley runcards/sv_dis_hera.yaml + vp-shapley runcards/sv_global.yaml --output results/sv +""" + +import argparse +import json +import sys +import time +from datetime import datetime +from pathlib import Path + +import matplotlib +matplotlib.use('Agg') +import numpy as np +import yaml + +from validphys.shapley.setup import setup_observables +from validphys.shapley.analyzer import NNPDFShapleyAnalyzer +from shapley_values import save_results + + +def load_runcard(path): + """Load and validate a YAML runcard.""" + with open(path) as f: + cfg = yaml.safe_load(f) + + required = ["pdf_name", "datasets", "perturbation"] + for key in required: + if key not in cfg: + raise KeyError(f"Missing required key '{key}' in runcard") + + pert = cfg["perturbation"] + for key in ["mu", "sigma", "amplitude"]: + if key not in pert: + raise KeyError(f"Missing perturbation.{key} in runcard") + + return cfg + + +def run_analysis(cfg, output_dir): + """Execute the full Shapley value pipeline from a parsed runcard.""" + pdf, observables, flavor_info, flavor_basis_info = setup_observables( + pdf_name=cfg["pdf_name"], + datasets=cfg["datasets"], + theory_id=cfg.get("theory_id", 708), + use_cuts=cfg.get("use_cuts", "internal"), + variant=cfg.get("variant", None), + ) + + n_replicas = cfg.get("n_replicas", 100) + bases = cfg.get("basis", ["evolution"]) + if isinstance(bases, str): + bases = [bases] + + pert = cfg["perturbation"] + mu = pert["mu"] + sigma = pert["sigma"] + amplitude = pert["amplitude"] + mode = pert.get("mode", "additive") + xspace = pert.get("xspace", "linear") + enforce_sumrules = cfg.get("enforce_sumrules", False) + + output_dir.mkdir(parents=True, exist_ok=True) + all_results = {} + + for basis in bases: + print(f"\n{'=' * 60}") + print(f" Basis: {basis}") + print(f"{'=' * 60}\n") + + if basis == "flavor": + fi = { + "indices": [2, 3, 4, 5, 6, 7, 8, 9, 10], + "pdg_codes": [-4, -3, -2, -1, 21, 1, 2, 3, 4], + "names": ["cbar", "sbar", "ubar", "dbar", + "g", "d", "u", "s", "c"], + "n_flavors": 9, + } + else: + fi = flavor_info + + analyzer = NNPDFShapleyAnalyzer( + pdf, observables, fi, + n_replicas=n_replicas, + basis=basis, + enforce_sumrules=enforce_sumrules, + ) + + t0 = time.time() + results = analyzer.exact_shap( + mu=mu, sigma=sigma, amplitude=amplitude, + mode=mode, xspace=xspace, plot=True, + ) + elapsed = time.time() - t0 + print(f"\nElapsed: {elapsed:.1f}s") + + # Save plots + if results.get("fig_pdfs") is not None: + pdf_fig_path = output_dir / f"pdfs_{basis}.png" + results["fig_pdfs"].savefig( + pdf_fig_path, dpi=150, bbox_inches="tight" + ) + print(f"Saved: {pdf_fig_path}") + if results.get("fig_bar") is not None: + bar_fig_path = output_dir / f"shapley_bar_{basis}.png" + results["fig_bar"].savefig( + bar_fig_path, dpi=150, bbox_inches="tight" + ) + print(f"Saved: {bar_fig_path}") + + # Save CSV + sv = results["shapley_values"] + labels = results["flavor_short"] + csv_path = output_dir / f"shapley_values_{basis}.csv" + with open(csv_path, "w") as f: + f.write("flavour,shapley_value\n") + for lbl, val in zip(labels, sv): + f.write(f"{lbl},{val:.8f}\n") + print(f"Saved: {csv_path}") + + all_results[basis] = { + "shapley_values": {l: float(v) for l, v in zip(labels, sv)}, + "baseline_chi2": float(results["baseline_chi2"]), + "coalitions_evaluated": results["coalitions_evaluated"], + "elapsed_seconds": round(elapsed, 1), + } + + # Save combined JSON using shapley_values.save_results + meta = { + "runcard": str(cfg.get("_source", "unknown")), + "pdf_name": cfg["pdf_name"], + "theory_id": cfg.get("theory_id", 708), + "n_datasets": len(cfg["datasets"]), + "n_replicas": n_replicas, + "perturbation": { + "mu": mu, "sigma": sigma, "amplitude": amplitude, + "mode": mode, "xspace": xspace, + }, + "enforce_sumrules": enforce_sumrules, + } + combined = {"results_by_basis": all_results} + json_path = str(output_dir / "results.json") + save_results(combined, json_path, metadata=meta) + print(f"\nSaved combined results: {json_path}") + + return all_results + + +def main(): + parser = argparse.ArgumentParser( + description="NNPDF Shapley value analysis from a YAML runcard." + ) + parser.add_argument( + "runcard", type=str, + help="Path to YAML runcard." + ) + parser.add_argument( + "--output", "-o", type=str, default=None, + help="Output directory. Default: sv_results/_." + ) + args = parser.parse_args() + + cfg = load_runcard(args.runcard) + cfg["_source"] = args.runcard + + if args.output: + output_dir = Path(args.output) + else: + stem = Path(args.runcard).stem + ts = datetime.now().strftime("%Y%m%d_%H%M%S") + output_dir = Path("sv_results") / f"{ts}_{stem}" + + print(f"Runcard : {args.runcard}") + print(f"Output : {output_dir}\n") + + run_analysis(cfg, output_dir) + + +if __name__ == "__main__": + main() diff --git a/validphys2/src/validphys/shapley/setup.py b/validphys2/src/validphys/shapley/setup.py new file mode 100644 index 0000000000..5aa1922225 --- /dev/null +++ b/validphys2/src/validphys/shapley/setup.py @@ -0,0 +1,471 @@ +"""Dataset loading, FK convolution, and chi2 for Shapley analysis. + +Loads datasets via validphys, builds dense FK tensors for fast convolution, +and provides chi2 computation. Supports multi-FK datasets with operations +(NULL, ASY, RATIO, ADD). + +Why not use validphys.convolution directly? + 1. Dense tensors: validphys keeps FK tables as sparse DataFrames and + re-indexes via groupby each call. We pre-densify once for fast + numpy einsum/matmul over O(N * 2^N) evaluations. + 2. Decoupled interface: validphys.convolution.predictions() is coupled + to LHAPDF PDF objects. We need to inject perturbed numpy arrays. + 3. Flavor rotation: validphys has no flavor-to-evolution rotation + (it always starts from evolution basis). We add it for flavor-basis + Shapley analysis. + +The underlying math (convolution, chi2, multi-FK operations) is identical +to validphys. +""" + +import functools +from typing import List, Optional + +import numpy as np +import pandas as pd +from scipy.linalg import cholesky, solve_triangular + +from validphys.loader import Loader +from validphys.fkparser import load_fktable +from validphys.convolution import FK_FLAVOURS, NFK +from validphys.pdfbases import evolution as evol_basis, ALL_FLAVOURS +from validphys.covmats import construct_covmat +from validphys.gridvalues import grid_values as _lhapdf_grid_values + +# PDG code to human-readable label +FLAVOR_PDG_NAMES = { + -6: "tbar", -5: "bbar", -4: "cbar", -3: "sbar", + -2: "ubar", -1: "dbar", 21: "g", + 1: "d", 2: "u", 3: "s", 4: "c", 5: "b", 6: "t", 22: "photon", +} + + +# --------------------------------------------------------------------------- +# Single FK table with precomputed dense tensor +# --------------------------------------------------------------------------- + +class FKEntry: + """One FK table with precomputed dense tensor and convolution methods. + + NNPDFObservable holds one or more of these and combines their + predictions via the dataset operation. + + Converts the validphys sparse DataFrame (fk.sigma) into dense numpy + arrays at construction time. Also precomputes the flavor-to-evolution + rotation matrix. + """ + + def __init__(self, sigma, flavor_indices, xgrid, Q0, ndata, hadronic): + self.flavor_indices = flavor_indices + self.xgrid = xgrid + self.Q0 = Q0 + self.ndata = ndata + self.hadronic = hadronic + self._build_rotation() + self._build_dense_tensor(sigma) + + def _build_rotation(self): + """Build flavor-to-evolution rotation matrix for this FK table. + + Uses evol_basis.from_flavour_mat from validphys.pdfbases. + """ + if self.hadronic: + evol_row_inds = evol_basis._to_indexes(FK_FLAVOURS) + else: + evol_row_inds = evol_basis._to_indexes( + FK_FLAVOURS[self.flavor_indices] + ) + fl_col_mask = evol_basis._flmask_from_base_indexes(evol_row_inds) + self.fl_col_inds = np.where(fl_col_mask)[0] + self.transform_mat = evol_basis.from_flavour_mat[ + np.ix_(evol_row_inds, self.fl_col_inds) + ] + + def _build_dense_tensor(self, sigma): + """Convert sparse sigma DataFrame into dense numpy arrays. + + DIS: _W_dis shape (ndata, nfl, nx) + Hadronic: _W_had_flat shape (ndata, npairs*nx*nx) + plus pair-index arrays _fl1, _fl2. + """ + fm = sigma.columns + nx = len(self.xgrid) + + if not self.hadronic: + nfl = len(fm) + W = np.zeros((self.ndata, nfl, nx), dtype=np.float64) + data_idx = sigma.index.get_level_values(0) + x_idx = sigma.index.get_level_values(1) + vals = sigma.values + unique_data = data_idx.unique() + data_map = {d: i for i, d in enumerate(unique_data)} + d_mapped = np.array([data_map[d] for d in data_idx]) + for fi in range(nfl): + W[d_mapped, fi, x_idx] = vals[:, fi] + self._W_dis = W + else: + npairs = len(fm) + W = np.zeros((self.ndata, npairs, nx, nx), dtype=np.float64) + data_idx = sigma.index.get_level_values(0) + x1_idx = sigma.index.get_level_values(1) + x2_idx = sigma.index.get_level_values(2) + vals = sigma.values + unique_data = data_idx.unique() + data_map = {d: i for i, d in enumerate(unique_data)} + d_mapped = np.array([data_map[d] for d in data_idx]) + for pi in range(npairs): + W[d_mapped, pi, x1_idx, x2_idx] = vals[:, pi] + self._W_had_flat = W.reshape(self.ndata, -1) + all_fl1, all_fl2 = np.indices((NFK, NFK)) + self._fl1 = all_fl1.ravel()[fm] + self._fl2 = all_fl2.ravel()[fm] + + # -- Convolution -------------------------------------------------------- + + def convolve(self, gv): + """FK convolution: DIS (einsum) or hadronic (matmul). + + Returns predictions with shape (ndata, nrep). + """ + if self.hadronic: + return self._convolve_hadronic(gv) + return self._convolve_dis(gv) + + def _convolve_dis(self, gv): + return np.einsum('dfx,rfx->dr', self._W_dis, gv) + + def _convolve_hadronic(self, gv): + nrep = gv.shape[0] + gv1 = gv[:, self._fl1, :] + gv2 = gv[:, self._fl2, :] + lumi_flat = ( + gv1[:, :, :, np.newaxis] * gv2[:, :, np.newaxis, :] + ).reshape(nrep, -1) + return self._W_had_flat @ lumi_flat.T + + # -- Rotation ----------------------------------------------------------- + + def rotate_to_evolution(self, gv_flav): + """Rotate physical flavor-basis to the evolution subset. + + Input: (nrep, 14, nx) in PDG flavour order. + Output: (nrep, nfl_used, nx) in the evolution columns this FK + table actually needs. + """ + gv_sub = gv_flav[:, self.fl_col_inds, :] + return np.einsum('ef,rfx->rex', self.transform_mat, gv_sub) + + +# --------------------------------------------------------------------------- +# Dataset container with multi-FK support +# --------------------------------------------------------------------------- + +class NNPDFObservable: + """Container for one dataset: FK tables, data, covariance, chi2. + + Supports multi-FK datasets with operations: NULL, ASY, RATIO, ADD. + """ + + def __init__(self, name, fk_entries, operation, data_central, + sqrt_covmat, ndata): + self.name = name + self.fk_entries = fk_entries + self.operation = operation + self.data_central = data_central + self.sqrt_covmat = sqrt_covmat + self.ndata = ndata + self._precompute_inv_covmat() + + # -- Properties (delegate to first FK entry) ---------------------------- + + @property + def xgrid(self): + return self.fk_entries[0].xgrid + + @property + def Q0(self): + return self.fk_entries[0].Q0 + + @property + def hadronic(self): + return self.fk_entries[0].hadronic + + @property + def flavor_indices(self): + return self.fk_entries[0].flavor_indices + + @property + def fl_col_inds(self): + return self.fk_entries[0].fl_col_inds + + @property + def transform_mat(self): + return self.fk_entries[0].transform_mat + + @property + def n_fk(self): + return len(self.fk_entries) + + def _precompute_inv_covmat(self): + """Precompute L_inv = inv(cholesky(covmat)) once.""" + n = self.sqrt_covmat.shape[0] + self._L_inv = solve_triangular( + self.sqrt_covmat, np.eye(n), lower=True, check_finite=False + ) + + # -- Combining predictions from multiple FK tables ---------------------- + + def _combine_predictions(self, pred_list): + """Apply the FK operation to combine predictions.""" + if self.operation == 'NULL': + return pred_list[0] + elif self.operation == 'ASY': + return (pred_list[0] - pred_list[1]) / (pred_list[0] + pred_list[1]) + elif self.operation == 'RATIO': + return pred_list[0] / pred_list[1] + elif self.operation == 'ADD': + return pred_list[0] + pred_list[1] + else: + raise ValueError(f"Unknown operation: {self.operation}") + + # -- FK convolution ----------------------------------------------------- + + def convolve(self, gv_list): + """FK convolution with operation combination. + + Parameters + ---------- + gv_list : np.ndarray or list of np.ndarray + """ + if not isinstance(gv_list, list): + gv_list = [gv_list] + pred_list = [ + entry.convolve(gv) + for entry, gv in zip(self.fk_entries, gv_list) + ] + return self._combine_predictions(pred_list) + + # -- Rotation ----------------------------------------------------------- + + def rotate_to_evolution(self, gv_flav_list): + """Rotate flavor-basis grid values to evolution for each FK entry.""" + if not isinstance(gv_flav_list, list): + gv_flav_list = [gv_flav_list] + return [ + entry.rotate_to_evolution(gv) + for entry, gv in zip(self.fk_entries, gv_flav_list) + ] + + def chi2_from_flavor(self, gv_flav_list): + """Chi2 from flavor-basis grid values: rotate, convolve, compare.""" + gv_evol_list = self.rotate_to_evolution(gv_flav_list) + return self.chi2(gv_evol_list) + + # -- Chi2 --------------------------------------------------------------- + + def chi2(self, gv_list): + """Chi2 per replica using precomputed L_inv. + + Returns shape (nrep,). + """ + preds = self.convolve(gv_list) + diffs = preds - self.data_central.reshape(-1, 1) + vec = self._L_inv @ diffs + return np.einsum('ir,ir->r', vec, vec) + + +# --------------------------------------------------------------------------- +# Main setup function +# --------------------------------------------------------------------------- + +def setup_observables( + pdf_name: str, + datasets: List[str], + theory_id: int = 708, + use_cuts: str = "internal", + variant: Optional[str] = None, +): + """Load datasets and build NNPDFObservable containers for SV analysis. + + Parameters + ---------- + pdf_name : str + LHAPDF set name, e.g. 'NNPDF40_nnlo_as_01180'. + datasets : list of str + Dataset names to load. + theory_id : int + NNPDF theory ID (default 708). + use_cuts : str + Cut policy: 'internal', 'nocuts', or 'fromfit'. + variant : str or None + Uncertainty variant, e.g. 'legacy'. + + Returns + ------- + pdf : validphys.core.PDF + observables : list of NNPDFObservable + flavor_info : dict + Evolution-basis flavor metadata. + flavor_basis_info : dict + Physical (PDG) flavor metadata. + """ + loader = Loader() + theoryid = loader.check_theoryID(theory_id) + pdf = loader.check_pdf(pdf_name) + + print(f"PDF set : {pdf_name}") + print(f"Theory ID : {theory_id}") + print(f"Cut policy : {use_cuts}") + print(f"Datasets : {len(datasets)}\n") + + observables = [] + all_flavor_indices = set() + + for ds_name in datasets: + ds_kw = {} + if variant is not None: + ds_kw['variant'] = variant + ds = loader.check_dataset(ds_name, theoryid=theoryid, **ds_kw) + + # Load all FK tables for this dataset + fk_entries = [] + for spec in ds.fkspecs: + fk = load_fktable(spec) + if ds.cuts is not None: + fk = fk.with_cuts(ds.cuts) + + sigma = fk.sigma + fm = sigma.columns + + if fk.hadronic: + for col in fm: + i, j = divmod(col, NFK) + all_flavor_indices.add(i) + all_flavor_indices.add(j) + else: + all_flavor_indices.update(fm.tolist()) + + entry = FKEntry( + sigma=sigma, + flavor_indices=fm, + xgrid=fk.xgrid, + Q0=fk.Q0, + ndata=fk.ndata, + hadronic=fk.hadronic, + ) + fk_entries.append(entry) + + # Experimental data and covariance + loaded_cd = ds.commondata.load() + if ds.cuts is not None: + loaded_cd = loaded_cd.with_cuts(ds.cuts.load()) + + data_central = loaded_cd.central_values.to_numpy() + stat_errors = loaded_cd.stat_errors.to_numpy() + sys_errors = loaded_cd.systematic_errors() + covmat = construct_covmat(stat_errors, sys_errors) + L = cholesky(covmat, lower=True) + + obs = NNPDFObservable( + name=ds_name, + fk_entries=fk_entries, + operation=ds.op, + data_central=data_central, + sqrt_covmat=L, + ndata=loaded_cd.ndata, + ) + observables.append(obs) + + # Print summary + fk0 = fk_entries[0] + tag = "hadronic" if fk0.hadronic else "DIS" + op_str = f" op={ds.op}" if ds.op != 'NULL' else "" + nfk_str = f" #FK={len(fk_entries)}" if len(fk_entries) > 1 else "" + if fk0.hadronic: + print(f" {ds_name:45s} ndata={obs.ndata:4d} " + f"nx={len(fk0.xgrid):3d} [{tag}]{op_str}{nfk_str}") + else: + flavour_names = FK_FLAVOURS[fk0.flavor_indices].tolist() + print(f" {ds_name:45s} ndata={obs.ndata:4d} " + f"nx={len(fk0.xgrid):3d} [{tag}]{op_str}{nfk_str} " + f"fl={flavour_names}") + + # Evolution-basis flavor metadata + sorted_fi = sorted(all_flavor_indices) + flavor_info = { + "indices": sorted_fi, + "names": FK_FLAVOURS[sorted_fi].tolist(), + "n_flavors": len(sorted_fi), + } + + print(f"\nEvolution flavours used ({flavor_info['n_flavors']}):") + for idx, name in zip(sorted_fi, flavor_info["names"]): + print(f" [{idx:2d}] {name}") + + # Physical flavor-basis metadata + all_fl_col_inds = set() + for obs in observables: + for entry in obs.fk_entries: + all_fl_col_inds.update(entry.fl_col_inds.tolist()) + sorted_fl = sorted(all_fl_col_inds) + + flavor_basis_info = { + "indices": sorted_fl, + "pdg_codes": [int(ALL_FLAVOURS[i]) for i in sorted_fl], + "names": [FLAVOR_PDG_NAMES[int(ALL_FLAVOURS[i])] for i in sorted_fl], + "n_flavors": len(sorted_fl), + } + + print(f"\nPhysical flavours contributing ({flavor_basis_info['n_flavors']}):\n") + for idx, name, pdg in zip( + sorted_fl, flavor_basis_info["names"], flavor_basis_info["pdg_codes"] + ): + print(f" [{idx:2d}] PDG {pdg:+3d} {name}") + + return pdf, observables, flavor_info, flavor_basis_info + + +# --------------------------------------------------------------------------- +# Grid-value evaluation +# --------------------------------------------------------------------------- + +def get_pdf_grid_values(pdf, target, n_replicas=None): + """Evaluate PDF in evolution basis (FK-subset flavours only). + + Returns shape (nrep, nfl_used, nx). + """ + gv_func = functools.partial(evol_basis.grid_values, pdf) + flavour_names = FK_FLAVOURS[target.flavor_indices] + gv = gv_func( + qmat=[target.Q0], vmat=flavour_names, xmat=target.xgrid + ).squeeze(-1) + if n_replicas is not None: + gv = gv[1: n_replicas + 1] + return gv + + +def get_pdf_flavor_grid_values(pdf, target, n_replicas=None): + """Evaluate PDF in physical flavor basis (all 14 PDG codes). + + Returns shape (nrep, 14, nx). + """ + pdg_codes = list(ALL_FLAVOURS) + gv = _lhapdf_grid_values( + pdf, pdg_codes, target.xgrid, [target.Q0] + ).squeeze(-1) + if n_replicas is not None: + gv = gv[1: n_replicas + 1] + return gv + + +def get_pdf_grid_values_all14(pdf, target, n_replicas=None): + """Evaluate PDF in all 14 evolution-basis flavours. + + Returns shape (nrep, 14, nx). + """ + gv = evol_basis.grid_values( + pdf, qmat=[target.Q0], vmat=FK_FLAVOURS, xmat=target.xgrid + ).squeeze(-1) + if n_replicas is not None: + gv = gv[1: n_replicas + 1] + return gv diff --git a/validphys2/src/validphys/shapley/sumrules.py b/validphys2/src/validphys/shapley/sumrules.py new file mode 100644 index 0000000000..6389f5ed09 --- /dev/null +++ b/validphys2/src/validphys/shapley/sumrules.py @@ -0,0 +1,97 @@ +"""MSR + VSR sum rule enforcement for perturbed PDFs. + +Reproduces the normalization logic of n3fit.layers.msr_normalization +in pure numpy. Sum rules are always applied in the evolution basis. + +FK_FLAVOURS ordering: + 0=photon, 1=Sigma, 2=g, 3=V, 4=V3, 5=V8, + 6=V15, 7=V24, 8=V35, 9=T3, 10=T8, 11=T15, 12=T24, 13=T35 + +Momentum sum rule (MSR): + int_0^1 dx x [g(x,Q) + Sigma(x,Q)] = 1 + Since the grid stores xf(x): int xf(x) dx = momentum fraction. + +Valence sum rules (VSR): + int_0^1 dx V(x,Q) = int_0^1 dx V8(x,Q) = 3 + int_0^1 dx V3(x,Q) = 1 + int_0^1 dx V15(x,Q) = 3 + Since the grid stores xf(x): int xf(x)/x dx = int f(x) dx = number. +""" + +import numpy as np + + +def gen_integration_input(nx=2000): + """Generate x-grid and trapezoidal weights for sum rule integrals. + + Same grid as n3fit.msr.gen_integration_input: nx/2 log-spaced points + from 1e-9 to 0.1, then nx/2 linearly-spaced from 0.1 to 1. + + Parameters + ---------- + nx : int + Total number of grid points (default 2000). + + Returns + ------- + xgrid : np.ndarray, shape (nx,) + weights : np.ndarray, shape (nx,) + """ + lognx = nx // 2 + linnx = nx - lognx + xgrid_log = np.logspace(-9, -1, lognx + 1) + xgrid_lin = np.linspace(0.1, 1, linnx) + xgrid = np.concatenate([xgrid_log[:-1], xgrid_lin]) + # Trapezoidal weights + spacing = np.zeros(nx + 1) + for i in range(1, nx): + spacing[i] = abs(xgrid[i - 1] - xgrid[i]) + weights = np.array([(spacing[i] + spacing[i + 1]) / 2.0 + for i in range(nx)]) + return xgrid, weights + + +def compute_sumrule_normalization(gv_evol14, xgrid, weights): + """Compute MSR + VSR normalization constants from evolution-basis PDF. + + Parameters + ---------- + gv_evol14 : np.ndarray, shape (nrep, 14, nx) + PDF xf(x) on the integration grid, in FK_FLAVOURS order. + xgrid : np.ndarray, shape (nx,) + weights : np.ndarray, shape (nx,) + + Returns + ------- + norm : np.ndarray, shape (nrep, 14) + Multiplicative normalization constant per replica per flavour. + Non-constrained channels get 1.0. + """ + nrep = gv_evol14.shape[0] + norm = np.ones((nrep, 14)) + + # Momentum integrals: int xf(x) dx (grid stores xf(x)) + mom = np.einsum('rfx,x->rf', gv_evol14, weights) # (nrep, 14) + + # Number integrals: int xf(x)/x dx = int f(x) dx (for valence) + inv_x = 1.0 / np.clip(xgrid, 1e-30, None) + num = np.einsum('rfx,x,x->rf', gv_evol14, inv_x, weights) # (nrep, 14) + + # MSR: gluon normalised so photon + Sigma + g momentum = 1 + sigma_mom = mom[:, 1] # Sigma + photon_mom = mom[:, 0] # photon + gluon_mom = mom[:, 2] # g + norm[:, 2] = (1.0 - sigma_mom - photon_mom) / np.clip( + np.abs(gluon_mom), 1e-30, None + ) + + # VSR: valence channels normalised to quark number targets + v_num = num[:, 3] # V integral + norm[:, 3] = 3.0 / np.clip(np.abs(v_num), 1e-30, None) # V + norm[:, 4] = 1.0 / np.clip(np.abs(num[:, 4]), 1e-30, None) # V3 + norm[:, 5] = 3.0 / np.clip(np.abs(num[:, 5]), 1e-30, None) # V8 + norm[:, 6] = 3.0 / np.clip(np.abs(num[:, 6]), 1e-30, None) # V15 + norm[:, 7] = 3.0 / np.clip(np.abs(v_num), 1e-30, None) # V24 (same as V) + norm[:, 8] = 3.0 / np.clip(np.abs(v_num), 1e-30, None) # V35 (same as V) + + return norm From cf0fff6201ee5f1924a1c9bce3de7068ed0a73c9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Rapha=C3=ABl=20Bonnet=20Guerrini?= <81559347+rbonnetguerrini@users.noreply.github.com> Date: Wed, 25 Feb 2026 20:29:10 +0100 Subject: [PATCH 02/21] linking to shapley-values repo --- pyproject.toml | 2 +- validphys2/src/validphys/shapley/__init__.py | 7 +++---- 2 files changed, 4 insertions(+), 5 deletions(-) diff --git a/pyproject.toml b/pyproject.toml index 1bafa9607d..a591232a33 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -60,7 +60,7 @@ vp-shapley = "validphys.shapley.scripts.vp_shapley:main" [tool.poetry.dependencies] # Generic dependencies (i.e., validphys) python = ">=3.9" -shapley-values = "*" +shapley-values = {git = "https://github.com/rbonnetguerrini/shapley-values.git", branch = "main"} matplotlib = "^3.9" pineappl = "^1.0.0" # TODO: make the code compatible with pandas 3 diff --git a/validphys2/src/validphys/shapley/__init__.py b/validphys2/src/validphys/shapley/__init__.py index c6139fcb62..e88b83bdfd 100644 --- a/validphys2/src/validphys/shapley/__init__.py +++ b/validphys2/src/validphys/shapley/__init__.py @@ -1,10 +1,9 @@ """Shapley value analysis for NNPDF PDF flavour importance. -Subpackage of validphys that provides tools for computing exact Shapley -values to quantify the importance of individual PDF flavours in -constraining experimental observables. +Subpackage of validphys that provides tools for computing exact Shapley values to quantify the importance of individual PDF flavours in constraining experimental observables. + +Uses the external ``shapley_values`` package for the problem-agnostic available at https://github.com/rbonnetguerrini -Uses the external ``shapley_values`` package for the problem-agnostic Shapley computation, and wraps NNPDF-specific components: - Dense FK tensor convolution for fast repeated chi2 evaluation - Gaussian perturbation of PDF grid values From 9079a7c069ea9172bdfeb08836af503c297603a8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Rapha=C3=ABl=20Bonnet=20Guerrini?= <81559347+rbonnetguerrini@users.noreply.github.com> Date: Wed, 25 Feb 2026 20:32:28 +0100 Subject: [PATCH 03/21] fixing commenting --- validphys2/src/validphys/shapley/analyzer.py | 12 ++++-------- validphys2/src/validphys/shapley/perturbation.py | 3 +-- .../src/validphys/shapley/scripts/vp_shapley.py | 2 +- validphys2/src/validphys/shapley/setup.py | 15 ++++----------- validphys2/src/validphys/shapley/sumrules.py | 9 +++------ 5 files changed, 13 insertions(+), 28 deletions(-) diff --git a/validphys2/src/validphys/shapley/analyzer.py b/validphys2/src/validphys/shapley/analyzer.py index 6df66fa6f4..afaeffa9c2 100644 --- a/validphys2/src/validphys/shapley/analyzer.py +++ b/validphys2/src/validphys/shapley/analyzer.py @@ -44,7 +44,7 @@ class NNPDFShapleyAnalyzer: Supports two perturbation bases: - evolution : players are evolution-basis flavours (Sigma, g, V, T3, ...). - - flavor : players are physical quarks/gluon; rotated before convolution. + - flavor : players are physical quarks/gluon rotated before convolution, Warning: if sumrule_enforced=true, the perturbation will be modify in the evolution basis for normalized sumrules. Parameters ---------- @@ -89,7 +89,7 @@ def __init__(self, pdf, observables, flavor_info, n_replicas=None, self._gv_cache: dict = {} - # Sum rule integration grid (lazily initialised) + # Sum rule integration grid (lazily initialized) self._sr_xgrid = None self._sr_weights = None self._sr_gv_evol = None @@ -297,13 +297,9 @@ def _evaluate_chi2(self, flavor_subset, mu, sigma, amplitude, perturb_idx = self._local_flavor_indices_for_entry( entry, flavor_subset ) - gv_pert = apply_gaussian_perturbation( - gv, perturb_idx, mu, sigma, amplitude, - entry.xgrid, mode=mode, xspace=xspace - ) + gv_pert = apply_gaussian_perturbation(gv, perturb_idx, mu, sigma, amplitude, entry.xgrid, mode=mode, xspace=xspace) if sr_norm is not None: - fi = (range(14) if entry.hadronic - else entry.flavor_indices) + fi = (range(14) if entry.hadronic else entry.flavor_indices) gv_pert = self._apply_norm_to_gv( gv_pert, sr_norm, fi ) diff --git a/validphys2/src/validphys/shapley/perturbation.py b/validphys2/src/validphys/shapley/perturbation.py index d430b4cdc7..ff1e6b8374 100644 --- a/validphys2/src/validphys/shapley/perturbation.py +++ b/validphys2/src/validphys/shapley/perturbation.py @@ -1,7 +1,6 @@ """Gaussian perturbation of PDF grid values. -Provides tools for perturbing selected flavour channels with a Gaussian -bump. Two independent parameters control the perturbation: +Provides tools for perturbing selected flavour channels with a Gaussian bump. Two independent parameters control the perturbation: - mode: 'additive' or 'multiplicative' - xspace: 'linear' or 'logx' """ diff --git a/validphys2/src/validphys/shapley/scripts/vp_shapley.py b/validphys2/src/validphys/shapley/scripts/vp_shapley.py index 5e89e2ce39..2786f26549 100644 --- a/validphys2/src/validphys/shapley/scripts/vp_shapley.py +++ b/validphys2/src/validphys/shapley/scripts/vp_shapley.py @@ -37,7 +37,7 @@ def load_runcard(path): pert = cfg["perturbation"] for key in ["mu", "sigma", "amplitude"]: if key not in pert: - raise KeyError(f"Missing perturbation.{key} in runcard") + raise KeyError(f"Missing {key} in perturbation in runcard") return cfg diff --git a/validphys2/src/validphys/shapley/setup.py b/validphys2/src/validphys/shapley/setup.py index 5aa1922225..faf228110e 100644 --- a/validphys2/src/validphys/shapley/setup.py +++ b/validphys2/src/validphys/shapley/setup.py @@ -1,18 +1,11 @@ """Dataset loading, FK convolution, and chi2 for Shapley analysis. -Loads datasets via validphys, builds dense FK tensors for fast convolution, -and provides chi2 computation. Supports multi-FK datasets with operations -(NULL, ASY, RATIO, ADD). +Loads datasets via validphys, builds dense FK tensors for fast convolution, and provides chi2 computation. Supports multi-FK datasets with operations (NULL, ASY, RATIO, ADD, COM, SMN, SMT). Why not use validphys.convolution directly? - 1. Dense tensors: validphys keeps FK tables as sparse DataFrames and - re-indexes via groupby each call. We pre-densify once for fast - numpy einsum/matmul over O(N * 2^N) evaluations. - 2. Decoupled interface: validphys.convolution.predictions() is coupled - to LHAPDF PDF objects. We need to inject perturbed numpy arrays. - 3. Flavor rotation: validphys has no flavor-to-evolution rotation - (it always starts from evolution basis). We add it for flavor-basis - Shapley analysis. + 1. Dense tensors: validphys keeps FK tables as sparse DataFrames and re-indexes via groupby each call. We pre-densify once for fast numpy einsum/matmul over O(N * 2^N) evaluations. + 2. Decoupled interface: validphys.convolution.predictions() is coupled to LHAPDF PDF objects. We need to inject perturbed numpy arrays. + 3. Flavor rotation: validphys has no flavor-to-evolution rotation (it always starts from evolution basis). We add it for flavor-basis perturbation. The underlying math (convolution, chi2, multi-FK operations) is identical to validphys. diff --git a/validphys2/src/validphys/shapley/sumrules.py b/validphys2/src/validphys/shapley/sumrules.py index 6389f5ed09..fac9c09ea3 100644 --- a/validphys2/src/validphys/shapley/sumrules.py +++ b/validphys2/src/validphys/shapley/sumrules.py @@ -1,11 +1,9 @@ """MSR + VSR sum rule enforcement for perturbed PDFs. -Reproduces the normalization logic of n3fit.layers.msr_normalization -in pure numpy. Sum rules are always applied in the evolution basis. +Reproduces the normalization logic of n3fit.layers.msr_normalization in pure numpy for applying to perturbated PDF sets. Sum rules are always applied in the evolution basis. FK_FLAVOURS ordering: - 0=photon, 1=Sigma, 2=g, 3=V, 4=V3, 5=V8, - 6=V15, 7=V24, 8=V35, 9=T3, 10=T8, 11=T15, 12=T24, 13=T35 + 0=photon, 1=Sigma, 2=g, 3=V, 4=V3, 5=V8, 6=V15, 7=V24, 8=V35, 9=T3, 10=T8, 11=T15, 12=T24, 13=T35 Momentum sum rule (MSR): int_0^1 dx x [g(x,Q) + Sigma(x,Q)] = 1 @@ -24,8 +22,7 @@ def gen_integration_input(nx=2000): """Generate x-grid and trapezoidal weights for sum rule integrals. - Same grid as n3fit.msr.gen_integration_input: nx/2 log-spaced points - from 1e-9 to 0.1, then nx/2 linearly-spaced from 0.1 to 1. + Same grid as n3fit.msr.gen_integration_input: nx/2 log-spaced points from 1e-9 to 0.1, then nx/2 linearly-spaced from 0.1 to 1. Parameters ---------- From 3ee96e2bc3f17f0a794b799970d0c528ce75fd4f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Rapha=C3=ABl=20Bonnet=20Guerrini?= <81559347+rbonnetguerrini@users.noreply.github.com> Date: Wed, 25 Feb 2026 20:33:53 +0100 Subject: [PATCH 04/21] adapting for all dataset type + includes variants and cfac in the loading --- .../validphys/shapley/runcards/sv_global.yaml | 124 ++++++++++++------ validphys2/src/validphys/shapley/setup.py | 62 +++++++-- 2 files changed, 134 insertions(+), 52 deletions(-) diff --git a/validphys2/src/validphys/shapley/runcards/sv_global.yaml b/validphys2/src/validphys/shapley/runcards/sv_global.yaml index b1c90ab59d..254c3e3c6f 100644 --- a/validphys2/src/validphys/shapley/runcards/sv_global.yaml +++ b/validphys2/src/validphys/shapley/runcards/sv_global.yaml @@ -1,5 +1,5 @@ # Shapley value runcard - full NNPDF4.0-like global fit -# 46 datasets (DIS + DY + jets + single top), both bases. +# 82 datasets, both bases. Matches n3fit/runcards/examples/nnpdf40-like.yml pdf_name: NNPDF40_nnlo_as_01180 @@ -17,57 +17,97 @@ perturbation: amplitude: 0.30 datasets: + # DIS: Fixed-target + - {dataset: NMC_NC_NOTFIXED_EM-F2, variant: legacy_dw} + - {dataset: NMC_NC_NOTFIXED_P_EM-SIGMARED, variant: legacy} + - {dataset: SLAC_NC_NOTFIXED_P_EM-F2, variant: legacy_dw} + - {dataset: SLAC_NC_NOTFIXED_D_EM-F2, variant: legacy_dw} + - {dataset: BCDMS_NC_NOTFIXED_P_EM-F2, variant: legacy_dw} + - {dataset: BCDMS_NC_NOTFIXED_D_EM-F2, variant: legacy_dw} + - {dataset: CHORUS_CC_NOTFIXED_PB_NU-SIGMARED, variant: legacy_dw} + - {dataset: CHORUS_CC_NOTFIXED_PB_NB-SIGMARED, variant: legacy_dw} + - {dataset: NUTEV_CC_NOTFIXED_FE_NU-SIGMARED, cfac: [MAS], variant: legacy_dw} + - {dataset: NUTEV_CC_NOTFIXED_FE_NB-SIGMARED, cfac: [MAS], variant: legacy_dw} # DIS: HERA combined - - HERA_NC_318GEV_EP-SIGMARED - - HERA_NC_318GEV_EM-SIGMARED - - HERA_NC_300GEV_EP-SIGMARED - - HERA_NC_251GEV_EP-SIGMARED - - HERA_NC_225GEV_EP-SIGMARED - - HERA_CC_318GEV_EP-SIGMARED - - HERA_CC_318GEV_EM-SIGMARED - - HERA_NC_318GEV_EAVG_CHARM-SIGMARED - - HERA_NC_318GEV_EAVG_BOTTOM-SIGMARED + - {dataset: HERA_NC_318GEV_EM-SIGMARED, variant: legacy} + - {dataset: HERA_NC_225GEV_EP-SIGMARED, variant: legacy} + - {dataset: HERA_NC_251GEV_EP-SIGMARED, variant: legacy} + - {dataset: HERA_NC_300GEV_EP-SIGMARED, variant: legacy} + - {dataset: HERA_NC_318GEV_EP-SIGMARED, variant: legacy} + - {dataset: HERA_CC_318GEV_EM-SIGMARED, variant: legacy} + - {dataset: HERA_CC_318GEV_EP-SIGMARED, variant: legacy} + - {dataset: HERA_NC_318GEV_EAVG_CHARM-SIGMARED, variant: legacy} + - {dataset: HERA_NC_318GEV_EAVG_BOTTOM-SIGMARED, variant: legacy} # DY: Fixed-target - - DYE605_Z0_38P8GEV_DW_PXSEC - - DYE866_Z0_800GEV_PXSEC + - {dataset: DYE866_Z0_800GEV_DW_RATIO_PDXSECRATIO, variant: legacy} + - {dataset: DYE866_Z0_800GEV_PXSEC, variant: legacy} + - {dataset: DYE605_Z0_38P8GEV_DW_PXSEC, variant: legacy} + - {dataset: DYE906_Z0_120GEV_DW_PDXSECRATIO, cfac: [ACC], variant: legacy} # DY: Tevatron - - CDF_Z0_1P96TEV_ZRAP - - D0_Z0_1P96TEV_ZRAP - - D0_WPWM_1P96TEV_ASY + - {dataset: CDF_Z0_1P96TEV_ZRAP, variant: legacy} + - {dataset: D0_Z0_1P96TEV_ZRAP, variant: legacy} + - {dataset: D0_WPWM_1P96TEV_ASY, variant: legacy} # DY: ATLAS - - ATLAS_Z0_7TEV_49FB_HIMASS - - ATLAS_Z0_7TEV_46FB_CC-Y - - ATLAS_Z0_7TEV_46FB_CF-Y - - ATLAS_WPWM_7TEV_46FB_CC-ETA - - ATLAS_WPWM_7TEV_36PB_ETA - - ATLAS_Z0J_8TEV_PT-M - - ATLAS_Z0J_8TEV_PT-Y - - ATLAS_Z0_8TEV_ZMASS_LL - - ATLAS_Z0_8TEV_LOWMASS_M-Y - - ATLAS_Z0_8TEV_HIMASS_M-Y - - ATLAS_Z0_13TEV_TOT - - ATLAS_WPWM_13TEV_TOT + - {dataset: ATLAS_WPWM_7TEV_36PB_ETA, variant: legacy} + - {dataset: ATLAS_Z0_7TEV_36PB_ETA, variant: legacy} + - {dataset: ATLAS_Z0_7TEV_49FB_HIMASS, variant: legacy} + - {dataset: ATLAS_Z0_7TEV_LOMASS_M, variant: legacy} + - {dataset: ATLAS_WPWM_7TEV_46FB_CC-ETA, variant: legacy} + - {dataset: ATLAS_Z0_7TEV_46FB_CC-Y, variant: legacy} + - {dataset: ATLAS_Z0_7TEV_46FB_CF-Y, variant: legacy} + - {dataset: ATLAS_Z0_8TEV_HIMASS_M-Y, variant: legacy} + - {dataset: ATLAS_Z0_8TEV_LOWMASS_M-Y, variant: legacy} + - {dataset: ATLAS_Z0_13TEV_TOT, cfac: [NRM], variant: legacy} + - {dataset: ATLAS_WPWM_13TEV_TOT, cfac: [NRM], variant: legacy} + - {dataset: ATLAS_WJ_8TEV_WP-PT, variant: legacy} + - {dataset: ATLAS_WJ_8TEV_WM-PT, variant: legacy} + - {dataset: ATLAS_Z0J_8TEV_PT-M, variant: legacy_10} + - {dataset: ATLAS_Z0J_8TEV_PT-Y, variant: legacy_10} # DY: CMS - - CMS_Z0_7TEV_DIMUON_2D - CMS_WPWM_7TEV_ELECTRON_ASY - - CMS_WPWM_7TEV_MUON_ASY - - CMS_WPWM_8TEV_MUON_Y - - CMS_Z0J_8TEV_PT-Y + - {dataset: CMS_WPWM_7TEV_MUON_ASY, variant: legacy} + - CMS_Z0_7TEV_DIMUON_2D + - {dataset: CMS_WPWM_8TEV_MUON_Y, variant: legacy} + - {dataset: CMS_Z0J_8TEV_PT-Y, cfac: [NRM], variant: legacy_10} # DY: LHCb - LHCB_Z0_7TEV_DIELECTRON_Y - - LHCB_Z0_7TEV_MUON_Y - LHCB_Z0_8TEV_DIELECTRON_Y - - LHCB_Z0_8TEV_MUON_Y - - LHCB_WPWM_7TEV_MUON_Y - - LHCB_WPWM_8TEV_MUON_Y - - LHCB_DY_7TEV_MUON_Y - - LHCB_DY_8TEV_MUON_Y + - {dataset: LHCB_WPWM_7TEV_MUON_Y, cfac: [NRM]} + - {dataset: LHCB_Z0_7TEV_MUON_Y, cfac: [NRM]} + - {dataset: LHCB_WPWM_8TEV_MUON_Y, cfac: [NRM]} + - {dataset: LHCB_Z0_8TEV_MUON_Y, cfac: [NRM]} - LHCB_Z0_13TEV_DIMUON-Y - LHCB_Z0_13TEV_DIELECTRON-Y + # Top: ttbar total cross-sections + - {dataset: ATLAS_TTBAR_7TEV_TOT_X-SEC, variant: legacy} + - {dataset: ATLAS_TTBAR_8TEV_TOT_X-SEC, variant: legacy} + - {dataset: ATLAS_TTBAR_13TEV_TOT_X-SEC, variant: legacy} + - {dataset: CMS_TTBAR_7TEV_TOT_X-SEC, variant: legacy} + - {dataset: CMS_TTBAR_8TEV_TOT_X-SEC, variant: legacy} + - {dataset: CMS_TTBAR_13TEV_TOT_X-SEC, variant: legacy} + - {dataset: CMS_TTBAR_5TEV_TOT_X-SEC, variant: legacy} + # Top: ttbar differential + - {dataset: ATLAS_TTBAR_8TEV_LJ_DIF_YT-NORM, variant: legacy} + - {dataset: ATLAS_TTBAR_8TEV_LJ_DIF_YTTBAR-NORM, variant: legacy} + - {dataset: ATLAS_TTBAR_8TEV_2L_DIF_YTTBAR-NORM, variant: legacy} + - {dataset: CMS_TTBAR_8TEV_LJ_DIF_YTTBAR-NORM, variant: legacy} + - {dataset: CMS_TTBAR_8TEV_2L_DIF_MTTBAR-YT-NORM, variant: legacy} + - {dataset: CMS_TTBAR_13TEV_2L_DIF_YT, variant: legacy} + - {dataset: CMS_TTBAR_13TEV_LJ_2016_DIF_YT, variant: legacy} # Jets - - CMS_1JET_8TEV_PTY - - CMS_2JET_7TEV_M12Y + - {dataset: ATLAS_1JET_8TEV_R06_PTY, variant: legacy_decorrelated} + - {dataset: ATLAS_2JET_7TEV_R06_M12Y, variant: legacy} + - {dataset: CMS_2JET_7TEV_M12-Y, variant: legacy} + - {dataset: CMS_1JET_8TEV_PTY, variant: legacy} + # Prompt photon + - {dataset: ATLAS_PH_13TEV_XSEC, cfac: [EWK], variant: legacy} # Single top - - CMS_SINGLETOP_7TEV_TCHANNEL-XSEC - - ATLAS_SINGLETOP_7TEV_T-Y-NORM - - ATLAS_SINGLETOP_7TEV_TBAR-Y-NORM + - {dataset: ATLAS_SINGLETOP_7TEV_TCHANNEL-XSEC, variant: legacy} + - {dataset: ATLAS_SINGLETOP_13TEV_TCHANNEL-XSEC, variant: legacy} + - {dataset: ATLAS_SINGLETOP_7TEV_T-Y-NORM, variant: legacy} + - {dataset: ATLAS_SINGLETOP_7TEV_TBAR-Y-NORM, variant: legacy} + - {dataset: ATLAS_SINGLETOP_8TEV_T-RAP-NORM, variant: legacy} + - {dataset: ATLAS_SINGLETOP_8TEV_TBAR-RAP-NORM, variant: legacy} + - {dataset: CMS_SINGLETOP_7TEV_TCHANNEL-XSEC, variant: legacy} + - {dataset: CMS_SINGLETOP_8TEV_TCHANNEL-XSEC, variant: legacy} + - {dataset: CMS_SINGLETOP_13TEV_TCHANNEL-XSEC, variant: legacy} diff --git a/validphys2/src/validphys/shapley/setup.py b/validphys2/src/validphys/shapley/setup.py index faf228110e..d6c783c993 100644 --- a/validphys2/src/validphys/shapley/setup.py +++ b/validphys2/src/validphys/shapley/setup.py @@ -156,7 +156,7 @@ def rotate_to_evolution(self, gv_flav): class NNPDFObservable: """Container for one dataset: FK tables, data, covariance, chi2. - Supports multi-FK datasets with operations: NULL, ASY, RATIO, ADD. + Supports multi-FK datasets with operations: NULL, ASY, RATIO, ADD, COM, SMN, SMT. """ def __init__(self, name, fk_entries, operation, data_central, @@ -209,7 +209,11 @@ def _precompute_inv_covmat(self): # -- Combining predictions from multiple FK tables ---------------------- def _combine_predictions(self, pred_list): - """Apply the FK operation to combine predictions.""" + """Apply the FK operation to combine predictions. + + Supports NULL, ASY, RATIO, ADD, COM, SMN, SMT operations + matching validphys.convolution.OP. + """ if self.operation == 'NULL': return pred_list[0] elif self.operation == 'ASY': @@ -218,6 +222,18 @@ def _combine_predictions(self, pred_list): return pred_list[0] / pred_list[1] elif self.operation == 'ADD': return pred_list[0] + pred_list[1] + elif self.operation == 'SMN': + # (a + b) / (c + d) + return (pred_list[0] + pred_list[1]) / (pred_list[2] + pred_list[3]) + elif self.operation == 'COM': + # (sum of first 10) / (sum of last 10) + n = len(pred_list) // 2 + num = sum(pred_list[:n]) + den = sum(pred_list[n:]) + return num / den + elif self.operation == 'SMT': + # sum of all (up to 10) + return sum(pred_list) else: raise ValueError(f"Unknown operation: {self.operation}") @@ -271,9 +287,28 @@ def chi2(self, gv_list): # Main setup function # --------------------------------------------------------------------------- +def _parse_dataset_entry(entry): + """Parse a dataset entry from the runcard. Useful for handling the variant of the dataset. + + Accepts either a plain string or a dict with keys: + dataset (str), variant (str, optional), cfac (list, optional) + + Returns (name, variant, cfac) tuple. + """ + if isinstance(entry, str): + return entry, None, () + elif isinstance(entry, dict): + name = entry["dataset"] + variant = entry.get("variant", None) + cfac = tuple(entry.get("cfac", [])) + return name, variant, cfac + else: + raise TypeError(f"Dataset entry must be str or dict, got {type(entry)}") + + def setup_observables( pdf_name: str, - datasets: List[str], + datasets: list, theory_id: int = 708, use_cuts: str = "internal", variant: Optional[str] = None, @@ -284,14 +319,16 @@ def setup_observables( ---------- pdf_name : str LHAPDF set name, e.g. 'NNPDF40_nnlo_as_01180'. - datasets : list of str - Dataset names to load. + datasets : list + Dataset entries. Each can be a plain string (dataset name) or a dict + with keys 'dataset', 'variant' (optional), 'cfac' (optional). theory_id : int NNPDF theory ID (default 708). use_cuts : str Cut policy: 'internal', 'nocuts', or 'fromfit'. variant : str or None - Uncertainty variant, e.g. 'legacy'. + Global uncertainty variant fallback, e.g. 'legacy'. + Per-dataset variants override this. Returns ------- @@ -314,11 +351,16 @@ def setup_observables( observables = [] all_flavor_indices = set() - for ds_name in datasets: + for entry in datasets: + ds_name, ds_variant, ds_cfac = _parse_dataset_entry(entry) + # Per-dataset variant overrides global variant + effective_variant = ds_variant if ds_variant is not None else variant ds_kw = {} - if variant is not None: - ds_kw['variant'] = variant - ds = loader.check_dataset(ds_name, theoryid=theoryid, **ds_kw) + if effective_variant is not None: + ds_kw['variant'] = effective_variant + if ds_cfac: + ds_kw['cfac'] = ds_cfac + ds = loader.check_dataset(ds_name, theoryid=theoryid, cuts=use_cuts, **ds_kw) # Load all FK tables for this dataset fk_entries = [] From ef2d808a8da8e7d5482b2fa0cf3ce93b76a2ec91 Mon Sep 17 00:00:00 2001 From: Raphael Cesar Bonnet-Guerrini Date: Thu, 26 Feb 2026 18:47:33 +0100 Subject: [PATCH 05/21] adding a progress tracker for the nbr of inference --- validphys2/src/validphys/shapley/analyzer.py | 44 ++++++++++++++++++- .../validphys/shapley/runcards/sv_global.yaml | 10 +++-- 2 files changed, 49 insertions(+), 5 deletions(-) diff --git a/validphys2/src/validphys/shapley/analyzer.py b/validphys2/src/validphys/shapley/analyzer.py index afaeffa9c2..573c01d72d 100644 --- a/validphys2/src/validphys/shapley/analyzer.py +++ b/validphys2/src/validphys/shapley/analyzer.py @@ -317,6 +317,8 @@ def build_value_function(self, mu, sigma, amplitude, mode='additive', xspace='linear'): """Return a callable v(coalition) -> float for ExactShapley. + The wrapper tracks progress: coalition count, elapsed time, and estimated time remaining (ETA). + Parameters ---------- mu, sigma, amplitude : float @@ -329,11 +331,51 @@ def build_value_function(self, mu, sigma, amplitude, value_function : callable f(List[int]) -> float """ + import time + import sys + + total_coalitions = 2 ** self.n_flavors + state = {"count": 0, "t_start": None, "last_player_line": False} + def v(coalition): - return self._evaluate_chi2( + if state["t_start"] is None: + state["t_start"] = time.time() + + result = self._evaluate_chi2( coalition, mu, sigma, amplitude, mode=mode, xspace=xspace, ) + + state["count"] += 1 + n = state["count"] + elapsed = time.time() - state["t_start"] + + if n == 1: + msg = ( + f" [{n}/{total_coalitions}] " + f"elapsed {elapsed:.0f}s ..." + ) + else: + rate = elapsed / n + remaining = rate * (total_coalitions - n) + mins, secs = divmod(int(remaining), 60) + msg = ( + f" [{n}/{total_coalitions}] " + f"elapsed {elapsed:.0f}s | " + f"~{rate:.1f}s/eval | " + f"ETA {mins}m{secs:02d}s " + ) + + # Use \r to overwrite the progress line in-place + sys.stderr.write(f"\r{msg}") + sys.stderr.flush() + + if n == total_coalitions: + sys.stderr.write("\n") + sys.stderr.flush() + + return result + return v # -- Convenience: run full Shapley analysis ----------------------------- diff --git a/validphys2/src/validphys/shapley/runcards/sv_global.yaml b/validphys2/src/validphys/shapley/runcards/sv_global.yaml index 254c3e3c6f..3559eec19c 100644 --- a/validphys2/src/validphys/shapley/runcards/sv_global.yaml +++ b/validphys2/src/validphys/shapley/runcards/sv_global.yaml @@ -9,12 +9,14 @@ n_replicas: 100 basis: - evolution - - flavor + +enforce_sumrules: true perturbation: - mu: 0.02 - sigma: 0.1 - amplitude: 0.30 + mu: 0.002 + sigma: 0.001 + amplitude: 0.5 + mode: multiplicative datasets: # DIS: Fixed-target From dfc0133fa0aaa56a7fa0a512ddfdf72c00d01408 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Rapha=C3=ABl=20Bonnet=20Guerrini?= <81559347+rbonnetguerrini@users.noreply.github.com> Date: Thu, 26 Feb 2026 18:58:43 +0100 Subject: [PATCH 06/21] test identity on cluster From 3cbcfe0dd3b52aa213f459b6bb52e7fbfde8da64 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Rapha=C3=ABl=20Bonnet=20Guerrini?= <81559347+rbonnetguerrini@users.noreply.github.com> Date: Thu, 26 Feb 2026 19:22:15 +0100 Subject: [PATCH 07/21] example notebook for shapley values --- .../validphys/shapley/notebook_example.ipynb | 716 ++++++++++++++++++ 1 file changed, 716 insertions(+) create mode 100644 validphys2/src/validphys/shapley/notebook_example.ipynb diff --git a/validphys2/src/validphys/shapley/notebook_example.ipynb b/validphys2/src/validphys/shapley/notebook_example.ipynb new file mode 100644 index 0000000000..e4af9c9d61 --- /dev/null +++ b/validphys2/src/validphys/shapley/notebook_example.ipynb @@ -0,0 +1,716 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "7eaa3087", + "metadata": {}, + "source": [ + "# Shapley Value Analysis \n", + "\n", + "Demonstrates Shapley value analysis of PDF flavours using the local `validphys.shapley` module.\n", + "Uses a small dataset mix (DIS + DY) for quick iteration.\n", + "For full-scale runs, use `scripts/run_shapley.py` with a YAML runcard.\n", + "\n", + "Two perturbation bases are supported:\n", + "- **Evolution basis**: players are Sigma, g, V, T3, etc.\n", + "- **Flavor basis**: players are physical quarks/gluon, rotated before convolution." + ] + }, + { + "cell_type": "markdown", + "id": "7484db00", + "metadata": {}, + "source": [ + "## 1. Imports" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "a945b4a7", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Available perturbation modes : ('additive', 'multiplicative')\n", + "Available perturbation xspaces: ('linear', 'logx')\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "from validphys.shapley import (\n", + " setup_observables,\n", + " get_pdf_grid_values,\n", + " get_pdf_grid_values_all14,\n", + " gaussian_profile,\n", + " apply_gaussian_perturbation,\n", + " PERTURBATION_MODES,\n", + " PERTURBATION_XSPACES,\n", + ")\n", + "from validphys.shapley.analyzer import NNPDFShapleyAnalyzer\n", + "\n", + "print(f\"Available perturbation modes : {PERTURBATION_MODES}\")\n", + "print(f\"Available perturbation xspaces: {PERTURBATION_XSPACES}\")\n", + "\n", + "%matplotlib inline\n", + "plt.rcParams.update({'figure.dpi': 120})" + ] + }, + { + "cell_type": "markdown", + "id": "dee3ba5f", + "metadata": {}, + "source": [ + "## 2. Load datasets\n", + "\n", + "Small mix: 3 HERA DIS + 3 hadronic DY for a quick demo." + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "af8d414c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "PDF set : NNPDF40_nnlo_as_01180\n", + "Theory ID : 708\n", + "Cut policy : internal\n", + "Datasets : 6\n", + "\n", + " HERA_NC_318GEV_EP-SIGMARED ndata= 377 nx= 50 [DIS] fl=['\\\\Sigma', 'g', 'V', 'V3', 'V8', 'V15', 'T3', 'T8', 'T15']\n", + " HERA_NC_318GEV_EM-SIGMARED ndata= 159 nx= 38 [DIS] fl=['\\\\Sigma', 'g', 'V', 'V3', 'V8', 'V15', 'T3', 'T8', 'T15']\n", + " HERA_CC_318GEV_EP-SIGMARED ndata= 39 nx= 32 [DIS] fl=['\\\\Sigma', 'g', 'V', 'V3', 'V8', 'V15', 'T3', 'T8', 'T15']\n", + " CDF_Z0_1P96TEV_ZRAP ndata= 28 nx= 34 [hadronic]\n", + " ATLAS_Z0_7TEV_46FB_CC-Y ndata= 24 nx= 37 [hadronic]\n", + " LHCB_Z0_7TEV_DIELECTRON_Y ndata= 9 nx= 41 [hadronic]\n", + "\n", + "Evolution flavours used (9):\n", + " [ 1] \\Sigma\n", + " [ 2] g\n", + " [ 3] V\n", + " [ 4] V3\n", + " [ 5] V8\n", + " [ 6] V15\n", + " [ 9] T3\n", + " [10] T8\n", + " [11] T15\n", + "\n", + "Physical flavours contributing (14):\n", + "\n", + " [ 0] PDG -6 tbar\n", + " [ 1] PDG -5 bbar\n", + " [ 2] PDG -4 cbar\n", + " [ 3] PDG -3 sbar\n", + " [ 4] PDG -2 ubar\n", + " [ 5] PDG -1 dbar\n", + " [ 6] PDG +21 g\n", + " [ 7] PDG +1 d\n", + " [ 8] PDG +2 u\n", + " [ 9] PDG +3 s\n", + " [10] PDG +4 c\n", + " [11] PDG +5 b\n", + " [12] PDG +6 t\n", + " [13] PDG +22 photon\n" + ] + } + ], + "source": [ + "datasets = [\n", + " # DIS\n", + " \"HERA_NC_318GEV_EP-SIGMARED\",\n", + " \"HERA_NC_318GEV_EM-SIGMARED\",\n", + " \"HERA_CC_318GEV_EP-SIGMARED\",\n", + " # DY\n", + " \"CDF_Z0_1P96TEV_ZRAP\",\n", + " \"ATLAS_Z0_7TEV_46FB_CC-Y\",\n", + " \"LHCB_Z0_7TEV_DIELECTRON_Y\",\n", + "]\n", + "\n", + "pdf, observables, flavor_info, flavor_basis_info = setup_observables(\n", + " pdf_name='NNPDF40_nnlo_as_01180',\n", + " datasets=datasets,\n", + " theory_id=708,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "821f883c", + "metadata": {}, + "source": [ + "## 3. Inspect loaded data" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "e2d3c58d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "DIS datasets : 3 (575 pts)\n", + "Hadronic : 3 (61 pts)\n", + "Total : 6 datasets, 636 pts\n", + "\n", + "Evolution flavours: ['\\\\Sigma', 'g', 'V', 'V3', 'V8', 'V15', 'T3', 'T8', 'T15']\n", + "Physical flavours : ['tbar', 'bbar', 'cbar', 'sbar', 'ubar', 'dbar', 'g', 'd', 'u', 's', 'c', 'b', 't', 'photon']\n" + ] + } + ], + "source": [ + "n_dis = sum(1 for o in observables if not o.hadronic)\n", + "n_had = sum(1 for o in observables if o.hadronic)\n", + "pts_dis = sum(o.ndata for o in observables if not o.hadronic)\n", + "pts_had = sum(o.ndata for o in observables if o.hadronic)\n", + "\n", + "print(f\"DIS datasets : {n_dis} ({pts_dis} pts)\")\n", + "print(f\"Hadronic : {n_had} ({pts_had} pts)\")\n", + "print(f\"Total : {n_dis + n_had} datasets, {pts_dis + pts_had} pts\\n\")\n", + "print(f\"Evolution flavours: {flavor_info['names']}\")\n", + "print(f\"Physical flavours : {flavor_basis_info['names']}\")" + ] + }, + { + "cell_type": "markdown", + "id": "54edfedc", + "metadata": {}, + "source": [ + "## 4. Predictions vs data" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "id": "26f366f5", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axes = plt.subplots(2, 3, figsize=(15, 8))\n", + "axes = axes.ravel()\n", + "\n", + "for i, obs in enumerate(observables):\n", + " ax = axes[i]\n", + " if obs.hadronic:\n", + " gv = get_pdf_grid_values_all14(pdf, obs, n_replicas=100)\n", + " else:\n", + " gv = get_pdf_grid_values(pdf, obs, n_replicas=100)\n", + " preds = obs.convolve(gv)\n", + " pred_mean = preds.mean(axis=1)\n", + " pred_std = preds.std(axis=1)\n", + " idx = np.arange(obs.ndata)\n", + "\n", + " ax.scatter(idx, obs.data_central, s=8, c='blue', alpha=0.7, label='Data')\n", + " ax.errorbar(idx, pred_mean, yerr=pred_std, fmt='x', color='red',\n", + " capsize=1, ms=3, lw=0.8, label='NNPDF pred')\n", + " chi2 = obs.chi2([gv])\n", + " ax.set_title(f\"{obs.name}\\nchi2/N={np.mean(chi2)/obs.ndata:.2f}\", fontsize=7)\n", + " ax.set_xlabel('Data point', fontsize=7)\n", + " ax.tick_params(labelsize=6)\n", + " ax.grid(True, alpha=0.3, ls='--')\n", + " ax.legend(fontsize=6)\n", + "\n", + "plt.suptitle('Predictions vs Data', fontsize=12, fontweight='bold')\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "5760d285", + "metadata": {}, + "source": [ + "## 5. Single-flavour perturbation check" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "id": "47b63c5b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Baseline chi2/N = 1.3794\n", + "\n", + " Sigma (singlet) delta = +0.0744\n", + " g (gluon) delta = -0.0036\n", + " V (valence) delta = +0.2965\n", + " V3 delta = +0.5776\n", + " V8 delta = +0.1191\n", + " V15 delta = +0.0371\n", + " T3 delta = +0.0028\n", + " T8 delta = -0.0100\n", + " T15 delta = +0.0342\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "mu_pert, sig_pert, amp_pert = 0.02, 0.1, 0.08\n", + "\n", + "analyzer = NNPDFShapleyAnalyzer(\n", + " pdf, observables, flavor_info, n_replicas=100, enforce_sumrules=True\n", + ")\n", + "\n", + "chi2_base = analyzer._evaluate_chi2([], mu_pert, sig_pert, amp_pert)\n", + "print(f\"Baseline chi2/N = {chi2_base:.4f}\\n\")\n", + "\n", + "deltas = []\n", + "for i in range(analyzer.n_flavors):\n", + " chi2_i = analyzer._evaluate_chi2([i], mu_pert, sig_pert, amp_pert)\n", + " d = chi2_i - chi2_base\n", + " deltas.append(d)\n", + " print(f\" {analyzer.flavor_labels[i]:20s} delta = {d:+.4f}\")\n", + "\n", + "fig, ax = plt.subplots(figsize=(10, 4))\n", + "bars = ax.bar(analyzer.flavor_short, deltas)\n", + "for bar, d in zip(bars, deltas):\n", + " bar.set_color('green' if d > 0 else 'red')\n", + " bar.set_alpha(0.7)\n", + "ax.axhline(0, color='black', lw=0.5)\n", + "ax.set_ylabel('delta chi2/N')\n", + "ax.set_title('Single-flavour perturbation effect (evolution basis)')\n", + "ax.grid(axis='y', ls='--', alpha=0.5)\n", + "plt.xticks(rotation=45)\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "4a7fcec7", + "metadata": {}, + "source": [ + "## 6. Exact Shapley values - evolution basis\n", + "\n", + "9 players --> 512 coalitions." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ab06b943", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Perturbation basis : evolution\n", + "Perturbation mode : multiplicative\n", + "Perturbation xspace: linear\n", + "Sum rules : ON\n", + "Computing exact Shapley values for 9 players (512 coalitions)...\n", + "Baseline (empty coalition) = 1.379422\n", + "\n", + " Player 0: Sigma (singlet)" + ] + } + ], + "source": [ + "mu_pert, sig_pert, amp_pert = 0.002, 0.001, 0.8\n", + "\n", + "results = analyzer.exact_shap(mu=mu_pert, sigma=sig_pert, amplitude=amp_pert, mode='multiplicative')" + ] + }, + { + "cell_type": "markdown", + "id": "468b5660", + "metadata": {}, + "source": [ + "## 7. Evolution-basis results" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "ab36e9cd", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Shapley Values (evolution basis):\n", + "--------------------------------------------------\n", + " V3 SV = +0.77472 (well-constrained)\n", + " V SV = +0.49735 (well-constrained)\n", + " V15 SV = -0.33182 (poorly-constrained)\n", + " V8 SV = +0.31175 (well-constrained)\n", + " Sigma SV = +0.16443 (well-constrained)\n", + " T3 SV = +0.07680 (well-constrained)\n", + " T8 SV = +0.02934 (well-constrained)\n", + " T15 SV = -0.01794 (poorly-constrained)\n", + " g SV = -0.00035 (poorly-constrained)\n", + "--------------------------------------------------\n", + " Baseline chi2/N = 1.3794\n", + " Sum |SV| = 2.20448\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sv = results['shapley_values']\n", + "labels = results['flavor_short']\n", + "\n", + "print(\"Shapley Values (evolution basis):\")\n", + "print(\"-\" * 50)\n", + "for lbl, val in sorted(zip(labels, sv), key=lambda x: -abs(x[1])):\n", + " tag = 'well-constrained' if val > 0 else 'poorly-constrained'\n", + " print(f\" {lbl:6s} SV = {val:+.5f} ({tag})\")\n", + "print(\"-\" * 50)\n", + "print(f\" Baseline chi2/N = {results['baseline_chi2']:.4f}\")\n", + "print(f\" Sum |SV| = {np.sum(np.abs(sv)):.5f}\")\n", + "\n", + "# Bar + pie\n", + "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(14, 5))\n", + "colors = ['green' if v > 0 else 'red' for v in sv]\n", + "ax1.bar(labels, sv, color=colors, alpha=0.7)\n", + "ax1.axhline(0, color='black', lw=0.5)\n", + "ax1.set_ylabel('Shapley Value')\n", + "ax1.set_title('Evolution Basis')\n", + "ax1.grid(axis='y', ls='--', alpha=0.5)\n", + "ax1.tick_params(axis='x', rotation=45)\n", + "\n", + "ax2.pie(np.abs(sv), labels=labels, autopct='%1.1f%%',\n", + " colors=plt.cm.Set3(np.linspace(0, 1, len(labels))))\n", + "ax2.set_title('Relative Importance (|SV|)')\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "508f99d1", + "metadata": {}, + "source": [ + "## 8. Exact Shapley values - flavor basis\n", + "\n", + "Same datasets, but perturbations applied to physical quark flavours." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2b848a74", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Perturbation basis : flavor\n", + "Perturbation mode : additive\n", + "Perturbation xspace: linear\n", + "Sum rules : OFF\n", + "Computing exact Shapley values for 9 players (512 coalitions)...\n", + "Baseline (empty coalition) = 1.379422\n", + "\n", + " Player 0: cbar -> SV = +0.868417\n", + " Player 1: sbar -> SV = +0.200529\n", + " Player 2: ubar -> SV = +0.825427\n", + " Player 3: dbar -> SV = +0.220234\n", + " Player 4: g -> SV = +0.010229\n", + " Player 5: d -> SV = +0.204352\n", + " Player 6: u -> SV = +0.786576\n", + " Player 7: s -> SV = +0.199024\n", + " Player 8: c -> SV = +0.868040\n", + "\n", + "------------------------------------------------------------\n", + "Baseline : 1.379422\n", + "Max |SV| : 0.868417\n", + "Mean |SV| : 0.464759\n", + "Sum SV : 4.182827\n", + "Sum |SV| : 4.182827\n", + "Elapsed : 141.9s\n", + "------------------------------------------------------------\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "flavor_9_info = {\n", + " 'indices': [2, 3, 4, 5, 6, 7, 8, 9, 10],\n", + " 'pdg_codes': [-4, -3, -2, -1, 21, 1, 2, 3, 4],\n", + " 'names': ['cbar', 'sbar', 'ubar', 'dbar', 'g', 'd', 'u', 's', 'c'],\n", + " 'n_flavors': 9,\n", + "}\n", + "\n", + "analyzer_flav = NNPDFShapleyAnalyzer(\n", + " pdf, observables, flavor_9_info,\n", + " n_replicas=100, basis='flavor', enforce_sumrules=False\n", + ")\n", + "\n", + "results_flav = analyzer_flav.exact_shap(mu=0.001, sigma=0.001, amplitude=amp_pert, mode='multiplicative')" + ] + }, + { + "cell_type": "markdown", + "id": "f19806c9", + "metadata": {}, + "source": [ + "## 9. Comparison: evolution vs flavor basis" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "ff1eb3bb", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Evolution sum SV = 1.50428\n", + "Flavor sum SV = 4.18283\n" + ] + } + ], + "source": [ + "sv_flav = results_flav['shapley_values']\n", + "labels_flav = results_flav['flavor_short']\n", + "\n", + "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(14, 5))\n", + "\n", + "colors_ev = ['green' if v > 0 else 'red' for v in sv]\n", + "ax1.bar(labels, sv, color=colors_ev, alpha=0.7)\n", + "ax1.axhline(0, color='black', lw=0.5)\n", + "ax1.set_ylabel('Shapley Value')\n", + "ax1.set_title('Evolution Basis', fontweight='bold')\n", + "ax1.grid(axis='y', ls='--', alpha=0.5)\n", + "ax1.tick_params(axis='x', rotation=45)\n", + "\n", + "colors_fl = ['green' if v > 0 else 'red' for v in sv_flav]\n", + "ax2.bar(labels_flav, sv_flav, color=colors_fl, alpha=0.7)\n", + "ax2.axhline(0, color='black', lw=0.5)\n", + "ax2.set_ylabel('Shapley Value')\n", + "ax2.set_title('Flavor Basis', fontweight='bold')\n", + "ax2.grid(axis='y', ls='--', alpha=0.5)\n", + "ax2.tick_params(axis='x', rotation=45)\n", + "\n", + "plt.suptitle('Shapley Value Comparison (DIS + DY demo)',\n", + " fontsize=13, fontweight='bold')\n", + "plt.tight_layout()\n", + "plt.show()\n", + "\n", + "print(f\"Evolution sum SV = {np.sum(sv):.5f}\")\n", + "print(f\"Flavor sum SV = {np.sum(sv_flav):.5f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "b67a7424", + "metadata": {}, + "source": [ + "## 10. Perturbation options\n", + "\n", + "Perturbations are controlled by two independent parameters: mode and xspace" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "7981f5cb", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Relative perturbation at peak x-value:\n", + "------------------------------------------------------------\n", + " additive linear g : 29.5% (at x=2.0e-02)\n", + " additive linear Sigma : 47.7% (at x=2.0e-02)\n", + " additive logx g : 29.5% (at x=2.0e-02)\n", + " additive logx Sigma : 47.7% (at x=2.0e-02)\n", + " multiplicative linear g : 80.0% (at x=2.0e-02)\n", + " multiplicative linear Sigma : 80.0% (at x=2.0e-02)\n", + " multiplicative logx g : 80.0% (at x=2.0e-02)\n", + " multiplicative logx Sigma : 80.0% (at x=2.0e-02)\n", + "------------------------------------------------------------\n" + ] + } + ], + "source": [ + "import functools\n", + "from validphys.shapley.perturbation import gaussian_profile as _gaussian_profile\n", + "from validphys.pdfbases import evolution as evol_basis\n", + "from validphys.convolution import FK_FLAVOURS\n", + "\n", + "# x grid and reference PDFs\n", + "x = np.logspace(-5, -0.001, 500)\n", + "Q0 = observables[0].Q0\n", + "gv_func = functools.partial(evol_basis.grid_values, pdf)\n", + "evol_names = FK_FLAVOURS[flavor_info['indices']]\n", + "gv_ref = gv_func(qmat=[Q0], vmat=evol_names, xmat=x).squeeze(-1)\n", + "gv_ref = gv_ref[1:101] # 100 replicas\n", + "\n", + "# 4 combinations of mode x xspace\n", + "combos = [\n", + " ('additive', 'linear', dict(mu=0.02, sigma=0.1, amplitude=0.8)),\n", + " ('additive', 'logx', dict(mu=0.02, sigma=1.5, amplitude=0.8)),\n", + " ('multiplicative', 'linear', dict(mu=0.02, sigma=0.1, amplitude=0.8)),\n", + " ('multiplicative', 'logx', dict(mu=0.02, sigma=1.5, amplitude=0.8)),\n", + "]\n", + "\n", + "# Show gluon (idx 1) and Sigma (idx 0)\n", + "flavs_to_show = {'g': 1, 'Sigma': 0}\n", + "\n", + "fig, axes = plt.subplots(2, 4, figsize=(20, 8), sharex=True)\n", + "\n", + "for col, (mode, xspace, params) in enumerate(combos):\n", + " gauss = _gaussian_profile(x, params['mu'], params['sigma'],\n", + " params['amplitude'], xspace)\n", + " for row, (flav_label, flav_idx) in enumerate(flavs_to_show.items()):\n", + " ax = axes[row, col]\n", + " ref_mean = gv_ref[:, flav_idx, :].mean(axis=0)\n", + " ref_std = gv_ref[:, flav_idx, :].std(axis=0)\n", + "\n", + " if mode == 'additive':\n", + " pert_mean = ref_mean + gauss\n", + " else:\n", + " pert_mean = ref_mean * (1.0 + gauss)\n", + "\n", + " ax.plot(x, ref_mean, 'b-', lw=1.5, label='Reference')\n", + " ax.fill_between(x, ref_mean - ref_std, ref_mean + ref_std,\n", + " alpha=0.2, color='blue')\n", + " ax.plot(x, pert_mean, 'r--', lw=1.5, label='Perturbed')\n", + " ax.set_xscale('log')\n", + " ax.set_title(f'{flav_label} - {mode} / {xspace}', fontsize=9,\n", + " fontweight='bold')\n", + " ax.grid(True, alpha=0.3, ls='--')\n", + " ax.legend(fontsize=7)\n", + " if row == 1:\n", + " ax.set_xlabel('x')\n", + " ax.set_ylabel('xf(x)')\n", + "\n", + "fig.suptitle('Perturbation options: mode x xspace (amplitude=0.8)',\n", + " fontsize=13, fontweight='bold')\n", + "plt.tight_layout()\n", + "plt.show()\n", + "\n", + "# Relative perturbation at peak for each combination\n", + "print(\"\\nRelative perturbation at peak x-value:\")\n", + "print(\"-\" * 60)\n", + "for mode, xspace, params in combos:\n", + " gauss = _gaussian_profile(x, params['mu'], params['sigma'],\n", + " params['amplitude'], xspace)\n", + " peak_x_idx = np.argmax(gauss)\n", + " for flav_label, flav_idx in flavs_to_show.items():\n", + " ref_val = gv_ref[:, flav_idx, peak_x_idx].mean()\n", + " if mode == 'additive':\n", + " rel = gauss[peak_x_idx] / abs(ref_val) * 100\n", + " else:\n", + " rel = gauss[peak_x_idx] * 100\n", + " print(f\" {mode:15s} {xspace:7s} {flav_label:6s}: \"\n", + " f\"{rel:.1f}% (at x={x[peak_x_idx]:.1e})\")\n", + "print(\"-\" * 60)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "environment_nnpdf", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From d83d0fa2b58de6f00d80945f6494da3d854bcf95 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Rapha=C3=ABl=20Bonnet=20Guerrini?= <81559347+rbonnetguerrini@users.noreply.github.com> Date: Fri, 27 Feb 2026 15:00:04 +0100 Subject: [PATCH 08/21] integration of the parallele computing from https://github.com/rbonnetguerrini/shapley-values --- validphys2/src/validphys/shapley/analyzer.py | 251 +++++++++++++++--- .../validphys/shapley/notebook_example.ipynb | 2 +- .../validphys/shapley/scripts/vp_shapley.py | 15 +- 3 files changed, 234 insertions(+), 34 deletions(-) diff --git a/validphys2/src/validphys/shapley/analyzer.py b/validphys2/src/validphys/shapley/analyzer.py index 573c01d72d..1ebf0da55b 100644 --- a/validphys2/src/validphys/shapley/analyzer.py +++ b/validphys2/src/validphys/shapley/analyzer.py @@ -9,7 +9,12 @@ """ import functools +import math +import sys +import threading import time +from concurrent.futures import ThreadPoolExecutor, as_completed +from itertools import combinations import numpy as np import matplotlib.pyplot as plt @@ -88,6 +93,8 @@ def __init__(self, pdf, observables, flavor_info, n_replicas=None, self.enforce_sumrules = enforce_sumrules self._gv_cache: dict = {} + self._gv_cache_lock = threading.Lock() + self._sumrule_lock = threading.Lock() # Sum rule integration grid (lazily initialized) self._sr_xgrid = None @@ -121,30 +128,65 @@ def __init__(self, pdf, observables, flavor_info, n_replicas=None, def _setup_sumrule_grid(self): """Lazily initialise the integration grid for sum rules.""" - self._sr_xgrid, self._sr_weights = gen_integration_input(2000) + sr_xgrid, sr_weights = gen_integration_input(2000) Q0 = self.observables[0].Q0 - self._sr_gv_evol = evol_basis.grid_values( - self.pdf, qmat=[Q0], vmat=FK_FLAVOURS, xmat=self._sr_xgrid + sr_gv_evol = evol_basis.grid_values( + self.pdf, qmat=[Q0], vmat=FK_FLAVOURS, xmat=sr_xgrid ).squeeze(-1) if self.n_replicas is not None: - self._sr_gv_evol = self._sr_gv_evol[1: self.n_replicas + 1] + sr_gv_evol = sr_gv_evol[1: self.n_replicas + 1] + + sr_gv_flav = None + sr_rotation = None if self.basis == 'flavor': - self._sr_gv_flav = _lhapdf_grid_values( - self.pdf, list(ALL_FLAVOURS), self._sr_xgrid, [Q0] + sr_gv_flav = _lhapdf_grid_values( + self.pdf, list(ALL_FLAVOURS), sr_xgrid, [Q0] ).squeeze(-1) if self.n_replicas is not None: - self._sr_gv_flav = self._sr_gv_flav[1: self.n_replicas + 1] + sr_gv_flav = sr_gv_flav[1: self.n_replicas + 1] evol_row_inds = evol_basis._to_indexes(FK_FLAVOURS) - self._sr_rotation = evol_basis.from_flavour_mat[evol_row_inds, :] + sr_rotation = evol_basis.from_flavour_mat[evol_row_inds, :] + + self._sr_xgrid = sr_xgrid + self._sr_weights = sr_weights + self._sr_gv_evol = sr_gv_evol + self._sr_gv_flav = sr_gv_flav + self._sr_rotation = sr_rotation def _compute_sumrule_norm(self, flavor_subset, mu, sigma, amplitude, mode, xspace): """Compute normalization constants for a perturbed coalition.""" - if self._sr_xgrid is None: - self._setup_sumrule_grid() + ready = ( + self._sr_xgrid is not None + and self._sr_weights is not None + and self._sr_gv_evol is not None + and ( + self.basis != 'flavor' + or ( + self._sr_gv_flav is not None + and self._sr_rotation is not None + ) + ) + ) + if not ready: + with self._sumrule_lock: + ready = ( + self._sr_xgrid is not None + and self._sr_weights is not None + and self._sr_gv_evol is not None + and ( + self.basis != 'flavor' + or ( + self._sr_gv_flav is not None + and self._sr_rotation is not None + ) + ) + ) + if not ready: + self._setup_sumrule_grid() if self.basis == 'evolution': gv = self._sr_gv_evol.copy() @@ -184,30 +226,36 @@ def _get_gv_for_entry(self, obs, entry_idx): """Cached evolution-basis grid values (FK-subset flavours).""" key = (obs.name, entry_idx, 'evol') if key not in self._gv_cache: - entry = obs.fk_entries[entry_idx] - self._gv_cache[key] = get_pdf_grid_values( - self.pdf, entry, n_replicas=self.n_replicas - ) + with self._gv_cache_lock: + if key not in self._gv_cache: + entry = obs.fk_entries[entry_idx] + self._gv_cache[key] = get_pdf_grid_values( + self.pdf, entry, n_replicas=self.n_replicas + ) return self._gv_cache[key] def _get_flavor_gv_for_entry(self, obs, entry_idx): """Cached physical flavor-basis grid values.""" key = (obs.name, entry_idx, 'flavor') if key not in self._gv_cache: - entry = obs.fk_entries[entry_idx] - self._gv_cache[key] = get_pdf_flavor_grid_values( - self.pdf, entry, n_replicas=self.n_replicas - ) + with self._gv_cache_lock: + if key not in self._gv_cache: + entry = obs.fk_entries[entry_idx] + self._gv_cache[key] = get_pdf_flavor_grid_values( + self.pdf, entry, n_replicas=self.n_replicas + ) return self._gv_cache[key] def _get_gv_all14_for_entry(self, obs, entry_idx): """Cached full 14-flavour evolution-basis grid values.""" key = (obs.name, entry_idx, 'evol_all14') if key not in self._gv_cache: - entry = obs.fk_entries[entry_idx] - self._gv_cache[key] = get_pdf_grid_values_all14( - self.pdf, entry, n_replicas=self.n_replicas - ) + with self._gv_cache_lock: + if key not in self._gv_cache: + entry = obs.fk_entries[entry_idx] + self._gv_cache[key] = get_pdf_grid_values_all14( + self.pdf, entry, n_replicas=self.n_replicas + ) return self._gv_cache[key] def _get_gv_list(self, obs): @@ -336,6 +384,8 @@ def build_value_function(self, mu, sigma, amplitude, total_coalitions = 2 ** self.n_flavors state = {"count": 0, "t_start": None, "last_player_line": False} + interactive_stderr = sys.stderr.isatty() + log_every = max(1, total_coalitions // 100) def v(coalition): if state["t_start"] is None: @@ -366,9 +416,16 @@ def v(coalition): f"ETA {mins}m{secs:02d}s " ) - # Use \r to overwrite the progress line in-place - sys.stderr.write(f"\r{msg}") - sys.stderr.flush() + if interactive_stderr: + sys.stderr.write(f"\r{msg}") + sys.stderr.flush() + elif ( + n == 1 + or n == total_coalitions + or n % log_every == 0 + ): + sys.stderr.write(f"{msg}\n") + sys.stderr.flush() if n == total_coalitions: sys.stderr.write("\n") @@ -380,8 +437,138 @@ def v(coalition): # -- Convenience: run full Shapley analysis ----------------------------- + def _iter_all_coalitions(self): + """Yield all coalition tuples in deterministic order.""" + players = tuple(range(self.n_flavors)) + for size in range(self.n_flavors + 1): + for coalition in combinations(players, size): + yield coalition + + @staticmethod + def _coalition_with_player(coalition, player): + """Return sorted coalition tuple with one extra player.""" + return tuple(sorted(coalition + (player,))) + + def _compute_exact_shap_parallel(self, mu, sigma, amplitude, mode, xspace, + n_jobs, verbose=True): + """Compute exact Shapley values from a parallel coalition cache.""" + n = self.n_flavors + factorial = [math.factorial(k) for k in range(n + 1)] + factorial_n = factorial[n] + all_coalitions = list(self._iter_all_coalitions()) + total_coalitions = len(all_coalitions) + value_cache = {} + + if verbose: + print( + f"Computing exact Shapley values for {n} players " + f"({total_coalitions} coalitions) with {n_jobs} worker(s)..." + ) + + t0 = time.time() + progress_start = t0 + interactive_stderr = sys.stderr.isatty() + log_every = max(1, total_coalitions // 100) + + def _evaluate_one(coalition): + value = self._evaluate_chi2( + coalition, mu, sigma, amplitude, mode=mode, xspace=xspace + ) + return coalition, value + + with ThreadPoolExecutor(max_workers=n_jobs) as executor: + future_map = { + executor.submit(_evaluate_one, coalition): coalition + for coalition in all_coalitions + } + completed = 0 + for future in as_completed(future_map): + coalition, value = future.result() + value_cache[coalition] = value + completed += 1 + + if verbose: + elapsed = time.time() - progress_start + if completed == 1: + msg = ( + f" [{completed}/{total_coalitions}] " + f"elapsed {elapsed:.0f}s ..." + ) + else: + rate = elapsed / completed + remaining = rate * (total_coalitions - completed) + mins, secs = divmod(int(remaining), 60) + msg = ( + f" [{completed}/{total_coalitions}] " + f"elapsed {elapsed:.0f}s | " + f"~{rate:.1f}s/eval | ETA {mins}m{secs:02d}s " + ) + if interactive_stderr: + sys.stderr.write(f"\r{msg}") + sys.stderr.flush() + elif ( + completed == 1 + or completed == total_coalitions + or completed % log_every == 0 + ): + sys.stderr.write(f"{msg}\n") + sys.stderr.flush() + + if verbose: + sys.stderr.write("\n") + sys.stderr.flush() + + baseline = value_cache[tuple()] + shapley_vals = np.zeros(n, dtype=float) + + for player in range(n): + if verbose: + print(f" Player {player}: {self.flavor_labels[player]}", end="", + flush=True) + + for coalition in all_coalitions: + if player in coalition: + continue + + s = len(coalition) + weight = ( + factorial[s] * factorial[n - s - 1] + ) / factorial_n + coalition_with_player = self._coalition_with_player( + coalition, player + ) + v_with = value_cache[coalition_with_player] + v_without = value_cache[coalition] + shapley_vals[player] += weight * (v_with - v_without) + + if verbose: + print(f" -> SV = {shapley_vals[player]:+.6f}") + + elapsed = time.time() - t0 + + if verbose: + print(f"Baseline : {baseline:.6f}") + print(f"Max |SV| : {np.max(np.abs(shapley_vals)):.6f}") + print(f"Mean |SV| : {np.mean(np.abs(shapley_vals)):.6f}") + print(f"Sum SV : {np.sum(shapley_vals):.6f}") + print(f"Sum |SV| : {np.sum(np.abs(shapley_vals)):.6f}") + print(f"Elapsed : {elapsed:.1f}s") + + return { + "shapley_values": shapley_vals, + "baseline": baseline, + "player_labels": self.flavor_labels, + "player_short": self.flavor_short, + "coalitions_evaluated": len(value_cache), + "total_coalitions": total_coalitions, + "elapsed_seconds": elapsed, + "value_cache": { + str(k): v for k, v in value_cache.items() + }, + } + def exact_shap(self, mu, sigma, amplitude, mode='additive', - xspace='linear', plot=True): + xspace='linear', plot=True, n_jobs=1): """Compute exact Shapley values for all flavour players. Uses the ``shapley_values.ExactShapley`` solver with the NNPDF @@ -394,6 +581,9 @@ def exact_shap(self, mu, sigma, amplitude, mode='additive', xspace : str plot : bool Whether to generate plots. + n_jobs : int + Number of worker threads for coalition evaluation. + If n_jobs=1, use the serial ExactShapley solver. Returns ------- @@ -407,24 +597,24 @@ def exact_shap(self, mu, sigma, amplitude, mode='additive', raise ValueError( f"Unknown xspace '{xspace}'. Choose from {PERTURBATION_XSPACES}." ) + if int(n_jobs) < 1: + raise ValueError(f"n_jobs must be >= 1, got {n_jobs}") basis_name = "flavor" if self.basis == 'flavor' else "evolution" print(f"Perturbation basis : {basis_name}") print(f"Perturbation mode : {mode}") print(f"Perturbation xspace: {xspace}") print(f"Sum rules : {'ON' if self.enforce_sumrules else 'OFF'}") + print(f"Parallel workers : {int(n_jobs)}") - # Build value function and run ExactShapley v = self.build_value_function(mu, sigma, amplitude, mode, xspace) - solver = ExactShapley( n_players=self.n_flavors, value_function=v, player_labels=self.flavor_labels, player_short=self.flavor_short, ) - - results = solver.compute(verbose=True) + results = solver.compute(verbose=True, n_jobs=int(n_jobs)) # Add NNPDF-specific metadata results["baseline_chi2"] = results["baseline"] @@ -434,6 +624,7 @@ def exact_shap(self, mu, sigma, amplitude, mode='additive', results["basis"] = self.basis results["flavor_labels"] = self.flavor_labels results["flavor_short"] = self.flavor_short + results["n_jobs"] = int(n_jobs) # Plot fig_pdfs = None diff --git a/validphys2/src/validphys/shapley/notebook_example.ipynb b/validphys2/src/validphys/shapley/notebook_example.ipynb index e4af9c9d61..81d04ddbab 100644 --- a/validphys2/src/validphys/shapley/notebook_example.ipynb +++ b/validphys2/src/validphys/shapley/notebook_example.ipynb @@ -708,7 +708,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.12.10" + "version": "3.12.12" } }, "nbformat": 4, diff --git a/validphys2/src/validphys/shapley/scripts/vp_shapley.py b/validphys2/src/validphys/shapley/scripts/vp_shapley.py index 2786f26549..5994d2c3ac 100644 --- a/validphys2/src/validphys/shapley/scripts/vp_shapley.py +++ b/validphys2/src/validphys/shapley/scripts/vp_shapley.py @@ -42,7 +42,7 @@ def load_runcard(path): return cfg -def run_analysis(cfg, output_dir): +def run_analysis(cfg, output_dir, n_jobs_override=None): """Execute the full Shapley value pipeline from a parsed runcard.""" pdf, observables, flavor_info, flavor_basis_info = setup_observables( pdf_name=cfg["pdf_name"], @@ -64,6 +64,9 @@ def run_analysis(cfg, output_dir): mode = pert.get("mode", "additive") xspace = pert.get("xspace", "linear") enforce_sumrules = cfg.get("enforce_sumrules", False) + n_jobs = int(cfg.get("n_jobs", 1)) + if n_jobs_override is not None: + n_jobs = int(n_jobs_override) output_dir.mkdir(parents=True, exist_ok=True) all_results = {} @@ -94,7 +97,7 @@ def run_analysis(cfg, output_dir): t0 = time.time() results = analyzer.exact_shap( mu=mu, sigma=sigma, amplitude=amplitude, - mode=mode, xspace=xspace, plot=True, + mode=mode, xspace=xspace, plot=True, n_jobs=n_jobs, ) elapsed = time.time() - t0 print(f"\nElapsed: {elapsed:.1f}s") @@ -128,6 +131,7 @@ def run_analysis(cfg, output_dir): "baseline_chi2": float(results["baseline_chi2"]), "coalitions_evaluated": results["coalitions_evaluated"], "elapsed_seconds": round(elapsed, 1), + "n_jobs": int(results.get("n_jobs", n_jobs)), } # Save combined JSON using shapley_values.save_results @@ -142,6 +146,7 @@ def run_analysis(cfg, output_dir): "mode": mode, "xspace": xspace, }, "enforce_sumrules": enforce_sumrules, + "n_jobs": int(n_jobs), } combined = {"results_by_basis": all_results} json_path = str(output_dir / "results.json") @@ -163,6 +168,10 @@ def main(): "--output", "-o", type=str, default=None, help="Output directory. Default: sv_results/_." ) + parser.add_argument( + "--n-jobs", type=int, default=None, + help="Number of worker threads for coalition evaluation." + ) args = parser.parse_args() cfg = load_runcard(args.runcard) @@ -178,7 +187,7 @@ def main(): print(f"Runcard : {args.runcard}") print(f"Output : {output_dir}\n") - run_analysis(cfg, output_dir) + run_analysis(cfg, output_dir, n_jobs_override=args.n_jobs) if __name__ == "__main__": From d373ef1bebf1c31e072b3ef4e1941898f21934c9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Rapha=C3=ABl=20Bonnet=20Guerrini?= <81559347+rbonnetguerrini@users.noreply.github.com> Date: Mon, 2 Mar 2026 19:42:31 +0100 Subject: [PATCH 09/21] Several experiment per job, new perturbation types, ablation and calibrated --- validphys2/src/validphys/shapley/analyzer.py | 47 ++-- .../src/validphys/shapley/perturbation.py | 65 +++++- .../shapley/runcards/sv_dis_hera.yaml | 29 --- .../validphys/shapley/scripts/vp_shapley.py | 218 +++++++++++++++--- .../shapley/slurm/run_vp_shapley.slurm | 150 ++++++++++++ 5 files changed, 429 insertions(+), 80 deletions(-) delete mode 100644 validphys2/src/validphys/shapley/runcards/sv_dis_hera.yaml create mode 100644 validphys2/src/validphys/shapley/slurm/run_vp_shapley.slurm diff --git a/validphys2/src/validphys/shapley/analyzer.py b/validphys2/src/validphys/shapley/analyzer.py index 1ebf0da55b..f715950bf8 100644 --- a/validphys2/src/validphys/shapley/analyzer.py +++ b/validphys2/src/validphys/shapley/analyzer.py @@ -33,7 +33,6 @@ FLAVOR_PDG_NAMES, ) from .perturbation import ( - gaussian_profile, apply_gaussian_perturbation, PERTURBATION_MODES, PERTURBATION_XSPACES, @@ -634,14 +633,27 @@ def exact_shap(self, mu, sigma, amplitude, mode='additive', amplitude=amplitude, mu=mu, sigma=sigma, mode=mode, xspace=xspace, ) - fig_bar = plot_shapley_bar( - results["shapley_values"], - self.flavor_short, - title=( + if mode == 'ablation': + bar_title = ( + f"PDF Flavour Importance ({basis_name}) " + f"mode={mode}, xspace={xspace}" + ) + elif mode == 'calibrated': + bar_title = ( + f"PDF Flavour Importance ({basis_name}) " + f"mu={mu}, sigma={sigma}, A={amplitude}\u03c3_rep, " + f"mode={mode}, xspace={xspace}" + ) + else: + bar_title = ( f"PDF Flavour Importance ({basis_name}) " f"mu={mu}, sigma={sigma}, A={amplitude}, " f"mode={mode}, xspace={xspace}" - ), + ) + fig_bar = plot_shapley_bar( + results["shapley_values"], + self.flavor_short, + title=bar_title, ylabel="Shapley Value (delta chi2/N)", ) plt.show() @@ -657,6 +669,7 @@ def plot_pdfs(self, amplitude=0.08, mu=0.02, sigma=0.1, mode='additive', xspace='linear', x_points=200): """Plot reference vs perturbed PDFs for all Shapley-player flavours.""" x_plot = np.logspace(-5, -0.001, x_points) + x_axis_scale = "linear" if float(mu) > 0.1 else "log" Q0 = self.observables[0].Q0 if self.basis == 'flavor': @@ -674,14 +687,16 @@ def plot_pdfs(self, amplitude=0.08, mu=0.02, sigma=0.1, if self.n_replicas is not None: gv_ref = gv_ref[1: self.n_replicas + 1] - gauss = gaussian_profile(x_plot, mu, sigma, amplitude, xspace) - gv_pert = gv_ref.copy() - if mode == 'additive': - for i in range(gv_pert.shape[1]): - gv_pert[:, i, :] += gauss[np.newaxis, :] - else: - for i in range(gv_pert.shape[1]): - gv_pert[:, i, :] *= (1.0 + gauss[np.newaxis, :]) + gv_pert = apply_gaussian_perturbation( + gv_ref, + local_flavor_idx=list(range(gv_ref.shape[1])), + mu=mu, + sigma=sigma, + amplitude=amplitude, + xgrid=x_plot, + mode=mode, + xspace=xspace, + ) n = len(self.flavor_short) ncols = min(3, n) @@ -701,7 +716,7 @@ def plot_pdfs(self, amplitude=0.08, mu=0.02, sigma=0.1, alpha=0.25, color="blue" ) ax.plot(x_plot, pert_mean, "r--", lw=1.5, label="Perturbed") - ax.set_xscale("log") + ax.set_xscale(x_axis_scale) ax.set_title(self.flavor_labels[i]) ax.set_xlabel("x") ax.set_ylabel("xf(x)") @@ -714,7 +729,7 @@ def plot_pdfs(self, amplitude=0.08, mu=0.02, sigma=0.1, basis_name = "Flavor" if self.basis == 'flavor' else "Evolution" fig.suptitle( f"{basis_name}-basis PDFs: A={amplitude}, mu={mu}, " - f"sigma={sigma}, mode={mode}, xspace={xspace}", + f"sigma={sigma}, mode={mode}, xspace={xspace}, x-axis={x_axis_scale}", fontsize=14, fontweight="bold", y=1.01, ) plt.tight_layout() diff --git a/validphys2/src/validphys/shapley/perturbation.py b/validphys2/src/validphys/shapley/perturbation.py index ff1e6b8374..ae36dd6612 100644 --- a/validphys2/src/validphys/shapley/perturbation.py +++ b/validphys2/src/validphys/shapley/perturbation.py @@ -1,14 +1,35 @@ """Gaussian perturbation of PDF grid values. Provides tools for perturbing selected flavour channels with a Gaussian bump. Two independent parameters control the perturbation: - - mode: 'additive' or 'multiplicative' + - mode: 'additive', 'multiplicative', 'calibrated', or 'ablation' - xspace: 'linear' or 'logx' + +Calibrated mode +--------------- +In 'calibrated' mode the Gaussian amplitude is not a global constant but is +scaled per-flavor by the replica standard deviation evaluated at x ~ mu: + + amplitude_j = alpha * std_rep[ f_j(x_mu) ] + +so the perturbation probes a shift of *alpha* times what the fit itself is +uncertain about at that x value. The Gaussian shape is preserved; only its +peak height varies by flavor. This removes the bias of both additive (gluon +is much larger than sea quarks) and multiplicative (gluon is much more +tightly constrained in relative terms) approaches. + +Ablation mode +------------- +In 'ablation' mode the selected flavour channels are set to zero over the +entire x grid: + + xf_j^pert(x) = 0 for all x + """ import numpy as np # Valid perturbation parameter choices -PERTURBATION_MODES = ('additive', 'multiplicative') +PERTURBATION_MODES = ('additive', 'multiplicative', 'calibrated', 'ablation') PERTURBATION_XSPACES = ('linear', 'logx') @@ -55,15 +76,25 @@ def apply_gaussian_perturbation(gv, local_flavor_idx, mu, sigma, amplitude, xgrid : array-like x values corresponding to the last axis of gv. mode : str - 'additive': f -> f + A * G(x) - 'multiplicative': f -> f * (1 + A * G(x)) + 'additive': f_j -> f_j + A * G(x) + 'multiplicative': f_j -> f_j * (1 + A * G(x)) + 'calibrated': f_j -> f_j + (A * sigma_rep_j) * G(x) + where sigma_rep_j = std of replicas at x closest to mu. + A acts as a dimensionless scaling factor (alpha). + 'ablation': f_j -> 0 for all x. + mu, sigma, amplitude are ignored. xspace : str - 'linear' or 'logx' + 'linear' or 'logx' (ignored for mode='ablation') Returns ------- gv_pert : np.ndarray Perturbed copy of gv. + + Notes + ----- + Positivity is always enforced on perturbed flavour channels: + values that would become negative after perturbation are clipped to 0. """ if len(local_flavor_idx) == 0: return gv @@ -78,12 +109,32 @@ def apply_gaussian_perturbation(gv, local_flavor_idx, mu, sigma, amplitude, f"Choose from {PERTURBATION_XSPACES}." ) gv_pert = gv.copy() - gauss = gaussian_profile(xgrid, mu, sigma, amplitude, xspace) - if mode == 'additive': + if mode == 'ablation': + # Zero out the selected flavour channels entirely over all x. + # mu/sigma/amplitude are not used. + for fi in local_flavor_idx: + gv_pert[:, fi, :] = 0.0 + return gv_pert # positivity trivially satisfied; skip clipping + elif mode == 'calibrated': + # Per-flavor amplitude: alpha * replica std at x closest to mu. + xgrid_arr = np.asarray(xgrid) + idx_mu = int(np.argmin(np.abs(xgrid_arr - mu))) + for fi in local_flavor_idx: + sigma_rep = float(gv[:, fi, idx_mu].std()) + gauss = gaussian_profile(xgrid, mu, sigma, amplitude * sigma_rep, xspace) + gv_pert[:, fi, :] += gauss[np.newaxis, :] + elif mode == 'additive': + gauss = gaussian_profile(xgrid, mu, sigma, amplitude, xspace) for fi in local_flavor_idx: gv_pert[:, fi, :] += gauss[np.newaxis, :] else: # multiplicative + gauss = gaussian_profile(xgrid, mu, sigma, amplitude, xspace) for fi in local_flavor_idx: gv_pert[:, fi, :] *= (1.0 + gauss[np.newaxis, :]) + + # Enforce positivity only on perturbed channels and only when the perturbation would drive a previously non-negative point below zero. + for fi in local_flavor_idx: + became_negative = (gv[:, fi, :] >= 0.0) & (gv_pert[:, fi, :] < 0.0) + gv_pert[:, fi, :] = np.where(became_negative, 0.0, gv_pert[:, fi, :]) return gv_pert diff --git a/validphys2/src/validphys/shapley/runcards/sv_dis_hera.yaml b/validphys2/src/validphys/shapley/runcards/sv_dis_hera.yaml deleted file mode 100644 index 72aeba1547..0000000000 --- a/validphys2/src/validphys/shapley/runcards/sv_dis_hera.yaml +++ /dev/null @@ -1,29 +0,0 @@ -# Shapley value runcard - HERA DIS only - -pdf_name: NNPDF40_nnlo_as_01180 -theory_id: 708 -use_cuts: internal -n_replicas: 100 - -basis: - - evolution - - flavor - -perturbation: - mu: 0.02 - sigma: 0.1 - amplitude: 0.08 - mode: multiplicative - -enforce_sumrules: true - -datasets: - - HERA_NC_318GEV_EP-SIGMARED - - HERA_NC_318GEV_EM-SIGMARED - - HERA_NC_300GEV_EP-SIGMARED - - HERA_NC_251GEV_EP-SIGMARED - - HERA_NC_225GEV_EP-SIGMARED - - HERA_CC_318GEV_EP-SIGMARED - - HERA_CC_318GEV_EM-SIGMARED - - HERA_NC_318GEV_EAVG_CHARM-SIGMARED - - HERA_NC_318GEV_EAVG_BOTTOM-SIGMARED diff --git a/validphys2/src/validphys/shapley/scripts/vp_shapley.py b/validphys2/src/validphys/shapley/scripts/vp_shapley.py index 5994d2c3ac..50466167d3 100644 --- a/validphys2/src/validphys/shapley/scripts/vp_shapley.py +++ b/validphys2/src/validphys/shapley/scripts/vp_shapley.py @@ -9,19 +9,20 @@ import argparse import json -import sys import time from datetime import datetime from pathlib import Path +import re import matplotlib matplotlib.use('Agg') +import matplotlib.pyplot as plt import numpy as np import yaml from validphys.shapley.setup import setup_observables from validphys.shapley.analyzer import NNPDFShapleyAnalyzer -from shapley_values import save_results +from shapley_values import save_results, plot_shapley_comparison def load_runcard(path): @@ -29,28 +30,173 @@ def load_runcard(path): with open(path) as f: cfg = yaml.safe_load(f) - required = ["pdf_name", "datasets", "perturbation"] + required = ["pdf_name", "datasets", "experiments"] for key in required: if key not in cfg: raise KeyError(f"Missing required key '{key}' in runcard") - pert = cfg["perturbation"] - for key in ["mu", "sigma", "amplitude"]: - if key not in pert: - raise KeyError(f"Missing {key} in perturbation in runcard") + if not isinstance(cfg["experiments"], (list, dict)): + raise TypeError("'experiments' must be a list or a mapping") return cfg -def run_analysis(cfg, output_dir, n_jobs_override=None): - """Execute the full Shapley value pipeline from a parsed runcard.""" - pdf, observables, flavor_info, flavor_basis_info = setup_observables( +def _safe_token(value): + """Build filesystem-safe tokens for output naming.""" + token = str(value).strip().replace(".", "p") + token = re.sub(r"[^A-Za-z0-9_-]+", "_", token) + return token.strip("_") + + +def _resolve_output_dir(cfg, runcard_path, cli_output): + """Resolve output directory with precedence: CLI > runcard > default.""" + shapley_root = Path(__file__).resolve().parent.parent + ts = datetime.now().strftime("%Y%m%d_%H%M%S") + + if cli_output: + out = Path(cli_output) + return out if out.is_absolute() else (shapley_root / out) + + if cfg.get("output_dir"): + out = Path(cfg["output_dir"]) + return out if out.is_absolute() else (shapley_root / out) + + output_root_cfg = cfg.get("output_root", str(shapley_root / "sv_results")) + output_root = Path(output_root_cfg) + if not output_root.is_absolute(): + output_root = shapley_root / output_root + + run_name = cfg.get("run_name") + label = _safe_token(run_name) if run_name else _safe_token(Path(runcard_path).stem) + return output_root / f"{ts}_{label}" + + +def _normalize_experiments(cfg): + """Normalize experiments into a list of (name, config) tuples.""" + experiments = cfg["experiments"] + if isinstance(experiments, dict): + items = [] + for name, exp_cfg in experiments.items(): + merged = dict(exp_cfg or {}) + merged["name"] = merged.get("name", name) + items.append(merged) + else: + items = experiments + + normalized = [] + for i, exp in enumerate(items, start=1): + if not isinstance(exp, dict): + raise TypeError(f"Experiment #{i} must be a mapping") + + exp_name = str(exp.get("name", f"exp_{i:02d}")) + pert = exp.get("perturbation") + if pert is None: + raise KeyError(f"Missing 'perturbation' in experiment '{exp_name}'") + for key in ["mu", "sigma", "amplitude"]: + if key not in pert: + raise KeyError(f"Missing {key} in perturbation for experiment '{exp_name}'") + + exp_cfg = dict(cfg) + exp_cfg["perturbation"] = pert + for key in ["basis", "n_jobs", "enforce_sumrules", "n_replicas", "run_name"]: + if key in exp: + exp_cfg[key] = exp[key] + + normalized.append((exp_name, exp_cfg)) + + return normalized + + +def _build_setup_context(cfg): + """Load PDF and observables once for all experiments in a runcard.""" + pdf, observables, flavor_info, _ = setup_observables( pdf_name=cfg["pdf_name"], datasets=cfg["datasets"], theory_id=cfg.get("theory_id", 708), use_cuts=cfg.get("use_cuts", "internal"), variant=cfg.get("variant", None), ) + return { + "pdf": pdf, + "observables": observables, + "flavor_info": flavor_info, + } + + +def _format_experiment_title(exp_name, exp_meta): + """Build concise comparison subplot title including perturbation params.""" + pert = (exp_meta or {}).get("perturbation", {}) + amp = pert.get("amplitude", "na") + mu = pert.get("mu", "na") + sigma = pert.get("sigma", "na") + mode = pert.get("mode", "additive") + xspace = pert.get("xspace") + if mode == "ablation": + title = f"{exp_name} | {mode}" + elif mode == "calibrated": + title = f"{exp_name} | A={amp}\u03c3_rep, mu={mu}, sigma={sigma}, {mode}" + else: + title = f"{exp_name} | A={amp}, mu={mu}, sigma={sigma}, {mode}" + if xspace is not None: + title += f", {xspace}" + return title + + +def _save_comparison_plots(all_experiment_results, output_dir, experiment_meta): + """Save per-basis comparison plots across experiments.""" + if len(all_experiment_results) < 2: + return + + basis_names = sorted( + { + basis + for exp_results in all_experiment_results.values() + for basis in exp_results.keys() + } + ) + exp_names = list(all_experiment_results.keys()) + + for basis in basis_names: + labels = None + for exp_name in exp_names: + if basis in all_experiment_results[exp_name]: + labels = list(all_experiment_results[exp_name][basis]["shapley_values"].keys()) + break + if labels is None: + continue + + matrix = [] + for exp_name in exp_names: + basis_results = all_experiment_results[exp_name].get(basis, {}) + sv_map = basis_results.get("shapley_values", {}) + matrix.append([float(sv_map.get(lbl, 0.0)) for lbl in labels]) + matrix = np.asarray(matrix, dtype=float) + + results_list = [] + for i, exp_name in enumerate(exp_names): + results_list.append( + { + "shapley_values": matrix[i], + "player_short": labels, + } + ) + titles = [ + _format_experiment_title(exp_name, experiment_meta.get(exp_name, {})) + for exp_name in exp_names + ] + fig = plot_shapley_comparison(results_list, titles=titles) + + out_path = output_dir / f"shapley_comparison_{basis}.png" + fig.savefig(out_path, dpi=150, bbox_inches="tight") + plt.close(fig) + print(f"Saved comparison plot: {out_path}") + + +def run_analysis(cfg, output_dir, setup_context, n_jobs_override=None): + """Execute the full Shapley value pipeline from one experiment config.""" + pdf = setup_context["pdf"] + observables = setup_context["observables"] + flavor_info = setup_context["flavor_info"] n_replicas = cfg.get("n_replicas", 100) bases = cfg.get("basis", ["evolution"]) @@ -80,8 +226,7 @@ def run_analysis(cfg, output_dir, n_jobs_override=None): fi = { "indices": [2, 3, 4, 5, 6, 7, 8, 9, 10], "pdg_codes": [-4, -3, -2, -1, 21, 1, 2, 3, 4], - "names": ["cbar", "sbar", "ubar", "dbar", - "g", "d", "u", "s", "c"], + "names": ["cbar", "sbar", "ubar", "dbar", "g", "d", "u", "s", "c"], "n_flavors": 9, } else: @@ -102,21 +247,15 @@ def run_analysis(cfg, output_dir, n_jobs_override=None): elapsed = time.time() - t0 print(f"\nElapsed: {elapsed:.1f}s") - # Save plots if results.get("fig_pdfs") is not None: pdf_fig_path = output_dir / f"pdfs_{basis}.png" - results["fig_pdfs"].savefig( - pdf_fig_path, dpi=150, bbox_inches="tight" - ) + results["fig_pdfs"].savefig(pdf_fig_path, dpi=150, bbox_inches="tight") print(f"Saved: {pdf_fig_path}") if results.get("fig_bar") is not None: bar_fig_path = output_dir / f"shapley_bar_{basis}.png" - results["fig_bar"].savefig( - bar_fig_path, dpi=150, bbox_inches="tight" - ) + results["fig_bar"].savefig(bar_fig_path, dpi=150, bbox_inches="tight") print(f"Saved: {bar_fig_path}") - # Save CSV sv = results["shapley_values"] labels = results["flavor_short"] csv_path = output_dir / f"shapley_values_{basis}.csv" @@ -134,7 +273,6 @@ def run_analysis(cfg, output_dir, n_jobs_override=None): "n_jobs": int(results.get("n_jobs", n_jobs)), } - # Save combined JSON using shapley_values.save_results meta = { "runcard": str(cfg.get("_source", "unknown")), "pdf_name": cfg["pdf_name"], @@ -177,17 +315,41 @@ def main(): cfg = load_runcard(args.runcard) cfg["_source"] = args.runcard - if args.output: - output_dir = Path(args.output) - else: - stem = Path(args.runcard).stem - ts = datetime.now().strftime("%Y%m%d_%H%M%S") - output_dir = Path("sv_results") / f"{ts}_{stem}" + output_dir = _resolve_output_dir(cfg, args.runcard, args.output) print(f"Runcard : {args.runcard}") print(f"Output : {output_dir}\n") - run_analysis(cfg, output_dir, n_jobs_override=args.n_jobs) + experiments = _normalize_experiments(cfg) + output_dir.mkdir(parents=True, exist_ok=True) + + setup_context = _build_setup_context(cfg) + + summary = {} + all_experiment_results = {} + for exp_name, exp_cfg in experiments: + exp_token = _safe_token(exp_name) or "exp" + exp_output_dir = output_dir / exp_token + print(f"\nRunning experiment '{exp_name}'") + print(f"Output : {exp_output_dir}\n") + experiment_results = run_analysis( + exp_cfg, + exp_output_dir, + setup_context, + n_jobs_override=args.n_jobs, + ) + all_experiment_results[exp_name] = experiment_results + summary[exp_name] = { + "output_dir": str(exp_output_dir), + "perturbation": exp_cfg["perturbation"], + } + + _save_comparison_plots(all_experiment_results, output_dir, summary) + + summary_path = output_dir / "experiments_summary.json" + with open(summary_path, "w") as f: + json.dump(summary, f, indent=2) + print(f"\nSaved multi-experiment summary: {summary_path}") if __name__ == "__main__": diff --git a/validphys2/src/validphys/shapley/slurm/run_vp_shapley.slurm b/validphys2/src/validphys/shapley/slurm/run_vp_shapley.slurm new file mode 100644 index 0000000000..09c896902e --- /dev/null +++ b/validphys2/src/validphys/shapley/slurm/run_vp_shapley.slurm @@ -0,0 +1,150 @@ +#!/bin/bash +#SBATCH --job-name=vp_shapley +#SBATCH --account=inf26_pml4hep_0 +#SBATCH --partition=dcgp_usr_prod +#SBATCH --time=02:00:00 +#SBATCH --output=/leonardo/home/userexternal/rbonnetg/projects/nnpdf/validphys2/src/validphys/shapley/slurm/slurm-%j.out +#SBATCH --error=/leonardo/home/userexternal/rbonnetg/projects/nnpdf/validphys2/src/validphys/shapley/slurm/slurm-%j.err + +set -euo pipefail + +RUNCARD_ARG="${1:-${RUNCARD:-}}" +if [[ -z "${RUNCARD_ARG}" ]]; then + echo "ERROR: Missing runcard path." >&2 + echo "Usage: sbatch ... run_vp_shapley.slurm /abs/path/to/runcard.yaml" >&2 + exit 1 +fi + +if [[ "${RUNCARD_ARG}" = /* && -f "${RUNCARD_ARG}" ]]; then + RUNCARD_PATH="${RUNCARD_ARG}" +elif [[ -n "${SLURM_SUBMIT_DIR:-}" && -f "${SLURM_SUBMIT_DIR}/${RUNCARD_ARG}" ]]; then + RUNCARD_PATH="${SLURM_SUBMIT_DIR}/${RUNCARD_ARG}" +elif [[ -f "${PWD}/${RUNCARD_ARG}" ]]; then + RUNCARD_PATH="${PWD}/${RUNCARD_ARG}" +else + echo "ERROR: runcard not found: ${RUNCARD_ARG}" >&2 + if [[ -n "${SLURM_SUBMIT_DIR:-}" ]]; then + echo "Tried: ${SLURM_SUBMIT_DIR}/${RUNCARD_ARG}" >&2 + fi + echo "Tried: ${PWD}/${RUNCARD_ARG}" >&2 + exit 1 +fi + +if [[ ! -f "${RUNCARD_PATH}" ]]; then + echo "ERROR: runcard not found: ${RUNCARD_PATH}" >&2 + exit 1 +fi + +RUNCARD_PATH="$(cd "$(dirname "${RUNCARD_PATH}")" && pwd)/$(basename "${RUNCARD_PATH}")" +if [[ "${RUNCARD_PATH}" != *"/shapley/runcards/"* ]]; then + echo "ERROR: Runcard path must be under .../validphys/shapley/runcards/..." >&2 + echo "Got: ${RUNCARD_PATH}" >&2 + exit 1 +fi + +SHAPLEY_DIR="${RUNCARD_PATH%/runcards/*}" + +extract_yaml_key() { + local key="$1" + sed -nE "s/^[[:space:]]*${key}:[[:space:]]*([^#]+).*/\\1/p" "${RUNCARD_PATH}" | head -n 1 | xargs +} + +RUN_LABEL="$(extract_yaml_key run_name)" +LOG_ROOT="$(extract_yaml_key log_root)" +OUTPUT_DIR_CFG="$(extract_yaml_key output_dir)" +OUTPUT_ROOT_CFG="$(extract_yaml_key output_root)" + +if [[ -z "${RUN_LABEL}" ]]; then + echo "ERROR: Missing required top-level key 'run_name' in ${RUNCARD_PATH}" >&2 + exit 1 +fi +if [[ -z "${LOG_ROOT}" ]]; then + echo "ERROR: Missing required top-level key 'log_root' in ${RUNCARD_PATH}" >&2 + exit 1 +fi +if [[ -z "${OUTPUT_DIR_CFG}" && -z "${OUTPUT_ROOT_CFG}" ]]; then + echo "ERROR: Missing required top-level key 'output_root' or 'output_dir' in ${RUNCARD_PATH}" >&2 + exit 1 +fi + +safe_token() { + echo "$1" | sed -E 's/\./p/g; s/[^A-Za-z0-9_-]+/_/g; s/^_+//; s/_+$//' +} + +RUNCARD_FILE="$(basename "${RUNCARD_PATH}")" +RUNCARD_STEM="$(safe_token "${RUNCARD_FILE%.*}")" + +if [[ "${LOG_ROOT}" = /* ]]; then + LOG_DIR="${LOG_ROOT}/$(safe_token "${RUN_LABEL}")" +else + LOG_DIR="${SHAPLEY_DIR}/${LOG_ROOT}/$(safe_token "${RUN_LABEL}")" +fi + +if [[ -n "${OUTPUT_DIR_CFG}" ]]; then + if [[ "${OUTPUT_DIR_CFG}" = /* ]]; then + RESULTS_BASE_DIR="${OUTPUT_DIR_CFG}" + else + RESULTS_BASE_DIR="${SHAPLEY_DIR}/${OUTPUT_DIR_CFG}" + fi +else + if [[ "${OUTPUT_ROOT_CFG}" = /* ]]; then + RESULTS_BASE_DIR="${OUTPUT_ROOT_CFG}" + else + RESULTS_BASE_DIR="${SHAPLEY_DIR}/${OUTPUT_ROOT_CFG}" + fi +fi + +REPO_DIR="$(cd "${SHAPLEY_DIR}/../../../../" && pwd)" + +# Ensure the runtime environment provides vp-shapley on compute nodes. +CONDA_HOME="${CONDA_HOME:-/leonardo/home/userexternal/rbonnetg/miniconda3}" +CONDA_ENV="${CONDA_ENV:-environment_nnpdf}" +if [[ ! -f "${CONDA_HOME}/etc/profile.d/conda.sh" ]]; then + echo "ERROR: conda.sh not found at ${CONDA_HOME}/etc/profile.d/conda.sh" >&2 + exit 1 +fi +source "${CONDA_HOME}/etc/profile.d/conda.sh" +conda activate "${CONDA_ENV}" + +mkdir -p "${LOG_DIR}" "${RESULTS_BASE_DIR}" + +TS="$(date +%Y%m%d_%H%M%S)" +LOG_OUT="${LOG_DIR}/${TS}_${RUNCARD_STEM}_job${SLURM_JOB_ID:-manual}.out.log" +LOG_ERR="${LOG_DIR}/${TS}_${RUNCARD_STEM}_job${SLURM_JOB_ID:-manual}.err.log" +exec > >(tee -a "${LOG_OUT}") +exec 2> >(tee -a "${LOG_ERR}" >&2) + +echo "Repository : ${REPO_DIR}" +echo "Shapley dir : ${SHAPLEY_DIR}" +echo "Runcard : ${RUNCARD_PATH}" +echo "Run label : ${RUN_LABEL}" +echo "Results base dir: ${RESULTS_BASE_DIR}" +echo "Log out : ${LOG_OUT}" +echo "Log err : ${LOG_ERR}" +echo "Conda env : ${CONDA_ENV}" + +cd "${REPO_DIR}" + +CMD=(vp-shapley "${RUNCARD_PATH}") +if [[ -n "${OUTPUT_DIR:-}" ]]; then + if [[ "${OUTPUT_DIR}" = /* ]]; then + EFFECTIVE_OUTPUT_DIR="${OUTPUT_DIR}" + else + EFFECTIVE_OUTPUT_DIR="${SHAPLEY_DIR}/${OUTPUT_DIR}" + fi + mkdir -p "${EFFECTIVE_OUTPUT_DIR}" + CMD+=(--output "${EFFECTIVE_OUTPUT_DIR}") +fi +if [[ -n "${N_JOBS:-}" ]]; then + CMD+=(--n-jobs "${N_JOBS}") +fi +if [[ $# -gt 1 ]]; then + CMD+=("${@:2}") +fi + +echo "Running : ${CMD[*]}" +if [[ "${DRY_RUN:-0}" = "1" ]]; then + echo "DRY_RUN=1 -> stopping before vp-shapley execution." + exit 0 +fi +"${CMD[@]}" From 370d067f5b525fb113c434bb784038e71ca4d78b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Rapha=C3=ABl=20Bonnet=20Guerrini?= <81559347+rbonnetguerrini@users.noreply.github.com> Date: Thu, 5 Mar 2026 16:02:39 +0100 Subject: [PATCH 10/21] making Shapley Values UQ + Fixing extreme SV outlier --- validphys2/src/validphys/shapley/analyzer.py | 427 ++++++++++- .../src/validphys/shapley/perturbation.py | 29 +- .../validphys/shapley/runcards/sv_dy_lhc.yaml | 13 +- .../validphys/shapley/runcards/sv_global.yaml | 19 +- .../validphys/shapley/scripts/vp_shapley.py | 669 +++++++++++++++++- .../shapley/slurm/run_vp_shapley.slurm | 2 +- 6 files changed, 1085 insertions(+), 74 deletions(-) diff --git a/validphys2/src/validphys/shapley/analyzer.py b/validphys2/src/validphys/shapley/analyzer.py index f715950bf8..70ffb0dee4 100644 --- a/validphys2/src/validphys/shapley/analyzer.py +++ b/validphys2/src/validphys/shapley/analyzer.py @@ -280,8 +280,9 @@ def _local_flavor_indices_for_entry(self, entry, global_flavor_subset): # -- Chi2 evaluation with perturbation ---------------------------------- def _evaluate_chi2(self, flavor_subset, mu, sigma, amplitude, - mode='additive', xspace='linear'): - """Mean chi2/Ndata across all observables for a given perturbation. + mode='additive', xspace='linear', + per_replica=False, random_sign=False): + """Chi2/Ndata across all observables for a given perturbation. Parameters ---------- @@ -290,10 +291,18 @@ def _evaluate_chi2(self, flavor_subset, mu, sigma, amplitude, mu, sigma, amplitude : float mode : str xspace : str + per_replica : bool + When False (default) return the mean over replicas as a float. + When True return the per-replica array of shape (nrep,) so that + Shapley values can be computed independently for every replica. + random_sign : bool + When True the perturbation amplitude is independently randomised + to ±1 for each replica. Forwarded to apply_gaussian_perturbation. Returns ------- - chi2 : float + chi2 : float or np.ndarray + Float when per_replica=False; shape (nrep,) when per_replica=True. """ sr_norm = None if self.enforce_sumrules: @@ -301,7 +310,12 @@ def _evaluate_chi2(self, flavor_subset, mu, sigma, amplitude, flavor_subset, mu, sigma, amplitude, mode, xspace ) - total_chi2 = 0.0 + # Use a single rng per call so all FK entries of one coalition share + # the same random signs (same coalition = same perturbation direction). + rng = np.random.default_rng() if random_sign else None + + total_chi2 = 0.0 # used when per_replica=False + total_chi2_rep = None # used when per_replica=True shape (nrep,) total_ndata = 0 for obs in self.observables: @@ -314,7 +328,8 @@ def _evaluate_chi2(self, flavor_subset, mu, sigma, amplitude, ] gv_pert = apply_gaussian_perturbation( gv_flav, perturb_idx, mu, sigma, amplitude, - entry.xgrid, mode=mode, xspace=xspace + entry.xgrid, mode=mode, xspace=xspace, + random_sign=random_sign, rng=rng, ) gv_pert_list.append(gv_pert) @@ -344,7 +359,11 @@ def _evaluate_chi2(self, flavor_subset, mu, sigma, amplitude, perturb_idx = self._local_flavor_indices_for_entry( entry, flavor_subset ) - gv_pert = apply_gaussian_perturbation(gv, perturb_idx, mu, sigma, amplitude, entry.xgrid, mode=mode, xspace=xspace) + gv_pert = apply_gaussian_perturbation( + gv, perturb_idx, mu, sigma, amplitude, + entry.xgrid, mode=mode, xspace=xspace, + random_sign=random_sign, rng=rng, + ) if sr_norm is not None: fi = (range(14) if entry.hadronic else entry.flavor_indices) gv_pert = self._apply_norm_to_gv( @@ -353,15 +372,25 @@ def _evaluate_chi2(self, flavor_subset, mu, sigma, amplitude, gv_pert_list.append(gv_pert) chi2_arr = obs.chi2(gv_pert_list) - total_chi2 += np.mean(chi2_arr) + if per_replica: + if total_chi2_rep is None: + total_chi2_rep = chi2_arr.copy() + else: + total_chi2_rep += chi2_arr + else: + total_chi2 += np.mean(chi2_arr) total_ndata += obs.ndata + if per_replica: + return total_chi2_rep / total_ndata return total_chi2 / total_ndata # -- Build value function for ExactShapley ------------------------------ def build_value_function(self, mu, sigma, amplitude, - mode='additive', xspace='linear'): + mode='additive', xspace='linear', + _coalition_log=None, + random_sign=False): """Return a callable v(coalition) -> float for ExactShapley. The wrapper tracks progress: coalition count, elapsed time, and estimated time remaining (ETA). @@ -372,6 +401,13 @@ def build_value_function(self, mu, sigma, amplitude, Gaussian perturbation parameters. mode : str xspace : str + _coalition_log : list or None + If provided, every (coalition_tuple, chi2) pair is appended to + this list during evaluation. Use this to build the full + per-coalition chi2 record for diagnostics. + random_sign : bool + Forwarded to _evaluate_chi2. Each call draws fresh signs so + the serial ExactShapley path also benefits. Returns ------- @@ -393,8 +429,13 @@ def v(coalition): result = self._evaluate_chi2( coalition, mu, sigma, amplitude, mode=mode, xspace=xspace, + random_sign=random_sign, ) + # Record coalition -> chi2 for diagnostics if requested. + if _coalition_log is not None: + _coalition_log.append((tuple(sorted(coalition)), result)) + state["count"] += 1 n = state["count"] elapsed = time.time() - state["t_start"] @@ -434,6 +475,124 @@ def v(coalition): return v + # -- Coalition diagnostics ---------------------------------------------- + + def _compute_diagnostics(self, coalition_log, outlier_n_sigma=3.0): + """Compute per-coalition chi2 statistics and marginal contribution stats. + + Parameters + ---------- + coalition_log : list of (coalition_tuple, chi2) + Raw log produced by build_value_function when _coalition_log is set. + outlier_n_sigma : float + Flag a coalition as an outlier when its chi2 exceeds + mean + outlier_n_sigma * std. Default is 3.0. + + Returns + ------- + diag : dict + chi2_stats, outliers, per_player_marginals, marginal_contributions. + """ + if not coalition_log: + return {} + + # Build O(1) lookup dict (coalitions are already sorted tuples). + chi2_dict = {c: v for c, v in coalition_log} + coalitions = list(chi2_dict.keys()) + chi2_arr = np.array([chi2_dict[c] for c in coalitions]) + + mean_chi2 = float(np.mean(chi2_arr)) + std_chi2 = float(np.std(chi2_arr)) + threshold = mean_chi2 + outlier_n_sigma * std_chi2 + + outlier_coalitions = [ + { + "coalition": list(c), + "coalition_labels": [self.flavor_short[i] for i in c], + "size": len(c), + "chi2": float(chi2_dict[c]), + "z_score": float((chi2_dict[c] - mean_chi2) / std_chi2) + if std_chi2 > 0 else 0.0, + } + for c in coalitions + if chi2_dict[c] > threshold + ] + outlier_coalitions.sort(key=lambda x: -x["chi2"]) + + # Per-player marginal contribution analysis: + # delta_v(i, S) = v(S ∪ {i}) - v(S) for all S not containing i. + per_player_marginals = {} + all_marginals = [] # flat list used for the contributions CSV + + for player_idx in range(self.n_flavors): + label = self.flavor_short[player_idx] + deltas = [] + for coalition in coalitions: + if player_idx not in coalition: + coal_with = tuple(sorted(coalition + (player_idx,))) + if coal_with in chi2_dict: + v_without = chi2_dict[coalition] + v_with = chi2_dict[coal_with] + delta = v_with - v_without + deltas.append(delta) + all_marginals.append({ + "player_idx": player_idx, + "player": label, + "coalition_without": list(coalition), + "v_without": float(v_without), + "v_with": float(v_with), + "delta_v": float(delta), + }) + + if deltas: + deltas_arr = np.array(deltas) + mean_d = float(np.mean(deltas_arr)) + std_d = float(np.std(deltas_arr)) + thr_d = mean_d + outlier_n_sigma * std_d + thr_d_low = mean_d - outlier_n_sigma * std_d + per_player_marginals[label] = { + "n_marginals": len(deltas), + "mean": mean_d, + "std": std_d, + "min": float(np.min(deltas_arr)), + "max": float(np.max(deltas_arr)), + "p05": float(np.percentile(deltas_arr, 5)), + "p95": float(np.percentile(deltas_arr, 95)), + "n_outliers_high": int(np.sum(deltas_arr > thr_d)), + "n_outliers_low": int(np.sum(deltas_arr < thr_d_low)), + } + + # Flag outlier marginals in the flat list. + for entry in all_marginals: + lbl = entry["player"] + stats = per_player_marginals.get(lbl, {}) + mean_d = stats.get("mean", 0.0) + std_d = stats.get("std", 0.0) + thr_hi = mean_d + outlier_n_sigma * std_d + thr_lo = mean_d - outlier_n_sigma * std_d + dv = entry["delta_v"] + entry["is_outlier"] = int(dv > thr_hi or dv < thr_lo) + + diag = { + "outlier_n_sigma": float(outlier_n_sigma), + "chi2_stats": { + "n_coalitions": len(chi2_arr), + "mean": mean_chi2, + "std": std_chi2, + "min": float(np.min(chi2_arr)), + "max": float(np.max(chi2_arr)), + "median": float(np.median(chi2_arr)), + "p95": float(np.percentile(chi2_arr, 95)), + "p99": float(np.percentile(chi2_arr, 99)), + }, + "outlier_chi2_threshold": float(threshold), + "n_outlier_coalitions": len(outlier_coalitions), + "outlier_coalitions": outlier_coalitions, + "per_player_marginals": per_player_marginals, + "_marginal_contributions": all_marginals, # used internally for CSV + } + return diag + # -- Convenience: run full Shapley analysis ----------------------------- def _iter_all_coalitions(self): @@ -449,8 +608,15 @@ def _coalition_with_player(coalition, player): return tuple(sorted(coalition + (player,))) def _compute_exact_shap_parallel(self, mu, sigma, amplitude, mode, xspace, - n_jobs, verbose=True): - """Compute exact Shapley values from a parallel coalition cache.""" + n_jobs, verbose=True, + per_replica=False, random_sign=False): + """Compute exact Shapley values from a parallel coalition cache. + + When per_replica=True every coalition is evaluated independently for + each replica, yielding a (nrep, n_flavors) Shapley matrix from which + the ensemble mean phi_j = mean_k phi_j^(k) and standard deviation + are derived. + """ n = self.n_flavors factorial = [math.factorial(k) for k in range(n + 1)] factorial_n = factorial[n] @@ -471,7 +637,8 @@ def _compute_exact_shap_parallel(self, mu, sigma, amplitude, mode, xspace, def _evaluate_one(coalition): value = self._evaluate_chi2( - coalition, mu, sigma, amplitude, mode=mode, xspace=xspace + coalition, mu, sigma, amplitude, mode=mode, xspace=xspace, + per_replica=per_replica, random_sign=random_sign, ) return coalition, value @@ -517,7 +684,76 @@ def _evaluate_one(coalition): sys.stderr.write("\n") sys.stderr.flush() - baseline = value_cache[tuple()] + baseline_raw = value_cache[tuple()] + + # per-replica path + if per_replica: + # value_cache values are ndarray(nrep,) + nrep = len(next(iter(value_cache.values()))) + baseline = float(np.mean(baseline_raw)) + + # shapley_per_replica[k, j] = phi_j^(k) + shapley_per_replica = np.zeros((nrep, n), dtype=float) + + for player in range(n): + if verbose: + print(f" Player {player}: {self.flavor_labels[player]}", + end="", flush=True) + + for coalition in all_coalitions: + if player in coalition: + continue + s = len(coalition) + weight = ( + factorial[s] * factorial[n - s - 1] + ) / factorial_n + coalition_with_player = self._coalition_with_player( + coalition, player + ) + v_with = value_cache[coalition_with_player] # (nrep,) + v_without = value_cache[coalition] # (nrep,) + shapley_per_replica[:, player] += weight * (v_with - v_without) + + if verbose: + sv_mean = float(np.mean(shapley_per_replica[:, player])) + sv_std = float(np.std(shapley_per_replica[:, player], ddof=1)) + print(f" -> SV = {sv_mean:+.6f} ± {sv_std:.6f}") + + shapley_vals = shapley_per_replica.mean(axis=0) + shapley_std = shapley_per_replica.std(axis=0, ddof=1) if nrep > 1 \ + else np.zeros(n, dtype=float) + shapley_err = shapley_std / np.sqrt(nrep) + + elapsed = time.time() - t0 + + if verbose: + print(f"Baseline (mean) : {baseline:.6f}") + print(f"Max |SV| : {np.max(np.abs(shapley_vals)):.6f}") + print(f"Mean |SV| : {np.mean(np.abs(shapley_vals)):.6f}") + print(f"Max SV std : {np.max(shapley_std):.6f}") + print(f"Elapsed : {elapsed:.1f}s") + + # Serialize per-replica matrix as list-of-lists for JSON + sv_per_rep_serializable = [ + {str(k): v for k, v in value_cache.items()} + ] + return { + "shapley_values": shapley_vals, + "shapley_values_per_replica": shapley_per_replica, + "shapley_std": shapley_std, + "shapley_err": shapley_err, + "baseline": baseline, + "baseline_per_replica": baseline_raw, + "player_labels": self.flavor_labels, + "player_short": self.flavor_short, + "coalitions_evaluated": len(value_cache), + "total_coalitions": total_coalitions, + "elapsed_seconds": elapsed, + "n_replicas": nrep, + } + + # scalar (mean-chi2) path + baseline = float(baseline_raw) shapley_vals = np.zeros(n, dtype=float) for player in range(n): @@ -555,6 +791,9 @@ def _evaluate_one(coalition): return { "shapley_values": shapley_vals, + "shapley_values_per_replica": None, + "shapley_std": None, + "shapley_err": None, "baseline": baseline, "player_labels": self.flavor_labels, "player_short": self.flavor_short, @@ -567,7 +806,9 @@ def _evaluate_one(coalition): } def exact_shap(self, mu, sigma, amplitude, mode='additive', - xspace='linear', plot=True, n_jobs=1): + xspace='linear', plot=True, n_jobs=1, + diagnostic=False, outlier_n_sigma=3.0, + per_replica=False, random_sign=False): """Compute exact Shapley values for all flavour players. Uses the ``shapley_values.ExactShapley`` solver with the NNPDF @@ -582,7 +823,28 @@ def exact_shap(self, mu, sigma, amplitude, mode='additive', Whether to generate plots. n_jobs : int Number of worker threads for coalition evaluation. - If n_jobs=1, use the serial ExactShapley solver. + If n_jobs=1, use the serial ExactShapley solver (scalar path) + or the single-worker parallel path (per_replica=True). + diagnostic : bool + When True, record chi2 for every coalition evaluated and compute + per-coalition and per-player-marginal statistics. The results + dict will contain ``coalition_log`` (raw list of + ``(coalition_tuple, chi2)`` pairs) and ``diagnostic`` (statistics + dict). Useful for spotting extreme coalitions that corrupt the + Shapley values. + outlier_n_sigma : float + Z-score threshold used to flag outlier coalitions/marginals. + Default is 3.0 (mean ± 3σ). + per_replica : bool + When True compute phi_j^(k) for every replica k and return the + full (nrep, n_flavors) matrix together with the ensemble mean, + standard deviation, and standard error. Forces use of the + parallel evaluation path (n_jobs>=1). This implements + Eq. (shapley_replicas) from the paper. + random_sign : bool + When True the perturbation amplitude is independently drawn from + {-1, +1} for each replica at every coalition evaluation, reducing + sensitivity of the Shapley values to the sign of the bump. Returns ------- @@ -605,15 +867,93 @@ def exact_shap(self, mu, sigma, amplitude, mode='additive', print(f"Perturbation xspace: {xspace}") print(f"Sum rules : {'ON' if self.enforce_sumrules else 'OFF'}") print(f"Parallel workers : {int(n_jobs)}") - - v = self.build_value_function(mu, sigma, amplitude, mode, xspace) - solver = ExactShapley( - n_players=self.n_flavors, - value_function=v, - player_labels=self.flavor_labels, - player_short=self.flavor_short, - ) - results = solver.compute(verbose=True, n_jobs=int(n_jobs)) + print(f"Per-replica SVs : {'ON' if per_replica else 'OFF'}") + print(f"Random sign : {'ON' if random_sign else 'OFF'}") + + # per_replica=True requires vector-valued value function; the external + # ExactShapley solver only handles scalars, so always use the parallel + # path (which supports both scalar and vector modes). + if per_replica or int(n_jobs) > 1: + results = self._compute_exact_shap_parallel( + mu, sigma, amplitude, mode, xspace, + n_jobs=int(n_jobs), + per_replica=per_replica, + random_sign=random_sign, + ) + # Build coalition_log for diagnostics from _compute_exact_shap_parallel + # (the parallel path does not produce a coalition_log internally; + # re-run with diagnostics via the scalar path below if requested). + coalition_log = None + if diagnostic: + # Re-evaluate all coalitions through the serial value function + # (scalar, mean-chi2) to collect the log for the diagnostic. + coalition_log = [] + v_diag = self.build_value_function( + mu, sigma, amplitude, mode, xspace, + _coalition_log=coalition_log, + random_sign=random_sign, + ) + for coalition in self._iter_all_coalitions(): + v_diag(list(coalition)) + else: + coalition_log = [] if diagnostic else None + v = self.build_value_function( + mu, sigma, amplitude, mode, xspace, + _coalition_log=coalition_log, + random_sign=random_sign, + ) + solver = ExactShapley( + n_players=self.n_flavors, + value_function=v, + player_labels=self.flavor_labels, + player_short=self.flavor_short, + ) + results = solver.compute(verbose=True, n_jobs=1) + # Ensure keys added by the parallel path are always present. + results.setdefault("shapley_values_per_replica", None) + results.setdefault("shapley_std", None) + results.setdefault("shapley_err", None) + + # Attach coalition log and diagnostics if requested. + if diagnostic and coalition_log is not None: + results["coalition_log"] = coalition_log + results["diagnostic"] = self._compute_diagnostics( + coalition_log, outlier_n_sigma=outlier_n_sigma + ) + diag = results["diagnostic"] + print("\n--- Coalition diagnostics ---") + cs = diag.get("chi2_stats", {}) + print( + f" Coalitions : {cs.get('n_coalitions', '?')} " + f"chi2 mean={cs.get('mean', 0):.4f} " + f"std={cs.get('std', 0):.4f} " + f"min={cs.get('min', 0):.4f} " + f"max={cs.get('max', 0):.4f}" + ) + print( + f" Outlier threshold ({outlier_n_sigma}σ): " + f"{diag.get('outlier_chi2_threshold', 0):.4f} " + f"({diag.get('n_outlier_coalitions', 0)} outlier coalitions)" + ) + if diag.get("outlier_coalitions"): + print(" Top outliers (chi2 > threshold):") + for oc in diag["outlier_coalitions"][:5]: + print( + f" coalition={oc['coalition_labels']} " + f"chi2={oc['chi2']:.4f} z={oc['z_score']:.2f}" + ) + print(" Per-player marginal |max|:") + for lbl, pm in diag.get("per_player_marginals", {}).items(): + print( + f" {lbl:>8s}: mean={pm['mean']:+.4f} " + f"std={pm['std']:.4f} [" + f"{pm['min']:+.4f}, {pm['max']:+.4f}] " + f"outliers: {pm['n_outliers_high']+pm['n_outliers_low']}" + ) + print() + else: + results["coalition_log"] = None + results["diagnostic"] = None # Add NNPDF-specific metadata results["baseline_chi2"] = results["baseline"] @@ -624,6 +964,15 @@ def exact_shap(self, mu, sigma, amplitude, mode='additive', results["flavor_labels"] = self.flavor_labels results["flavor_short"] = self.flavor_short results["n_jobs"] = int(n_jobs) + results["per_replica"] = bool(per_replica) + results["random_sign"] = bool(random_sign) + # Convenience: scalar uncertainty arrays (None when per_replica=False) + # shapley_std[j] = std_k phi_j^(k) (replica-to-replica spread) + # shapley_err[j] = shapley_std[j] / sqrt(nrep) (standard error of mean) + if results.get("shapley_std") is None: + results["shapley_std"] = None + if results.get("shapley_err") is None: + results["shapley_err"] = None # Plot fig_pdfs = None @@ -656,6 +1005,28 @@ def exact_shap(self, mu, sigma, amplitude, mode='additive', title=bar_title, ylabel="Shapley Value (delta chi2/N)", ) + # Overlay error bars when per-replica uncertainties are available. + _sv_std = results.get("shapley_std") + if _sv_std is not None: + from matplotlib.lines import Line2D + _ax = fig_bar.axes[0] + _ax.errorbar( + self.flavor_short, + results["shapley_values"], + yerr=_sv_std, + fmt="none", + ecolor="black", + elinewidth=1.2, + capsize=4, + capthick=1.2, + zorder=5, + ) + _handles, _ = _ax.get_legend_handles_labels() + _handles.append( + Line2D([], [], color="black", linewidth=1.2, label="1\u03c3 std") + ) + _ax.legend(handles=_handles, loc="upper right") + fig_bar.tight_layout() plt.show() results["fig_pdfs"] = fig_pdfs @@ -668,8 +1039,14 @@ def exact_shap(self, mu, sigma, amplitude, mode='additive', def plot_pdfs(self, amplitude=0.08, mu=0.02, sigma=0.1, mode='additive', xspace='linear', x_points=200): """Plot reference vs perturbed PDFs for all Shapley-player flavours.""" - x_plot = np.logspace(-5, -0.001, x_points) - x_axis_scale = "linear" if float(mu) > 0.1 else "log" + x_min = 1e-5 + x_max = 10 ** (-0.001) + if mode == "ablation": + x_plot = np.linspace(x_min, x_max, x_points) + x_axis_scale = "linear" + else: + x_plot = np.logspace(-5, -0.001, x_points) + x_axis_scale = "linear" if float(mu) > 0.1 else "log" Q0 = self.observables[0].Q0 if self.basis == 'flavor': diff --git a/validphys2/src/validphys/shapley/perturbation.py b/validphys2/src/validphys/shapley/perturbation.py index ae36dd6612..88fc08aff1 100644 --- a/validphys2/src/validphys/shapley/perturbation.py +++ b/validphys2/src/validphys/shapley/perturbation.py @@ -62,7 +62,8 @@ def gaussian_profile(xgrid, mu, sigma, amplitude, xspace='linear'): def apply_gaussian_perturbation(gv, local_flavor_idx, mu, sigma, amplitude, - xgrid, mode='additive', xspace='linear'): + xgrid, mode='additive', xspace='linear', + random_sign=False, rng=None): """Perturb selected flavour channels with a Gaussian bump. Parameters @@ -85,6 +86,15 @@ def apply_gaussian_perturbation(gv, local_flavor_idx, mu, sigma, amplitude, mu, sigma, amplitude are ignored. xspace : str 'linear' or 'logx' (ignored for mode='ablation') + random_sign : bool + When True the Gaussian amplitude is independently flipped to +1 or -1 + for each replica (drawn uniformly from {-1, +1}). This decorrelates + the direction of the perturbation across the Monte Carlo ensemble, + reducing sensitivity to the sign convention of the bump. + Ignored for mode='ablation'. + rng : numpy.random.Generator or None + Optional random-number generator for reproducibility. When None a + fresh, non-seeded generator is created per call. Returns ------- @@ -109,6 +119,7 @@ def apply_gaussian_perturbation(gv, local_flavor_idx, mu, sigma, amplitude, f"Choose from {PERTURBATION_XSPACES}." ) gv_pert = gv.copy() + nrep = gv.shape[0] if mode == 'ablation': # Zero out the selected flavour channels entirely over all x. @@ -116,22 +127,30 @@ def apply_gaussian_perturbation(gv, local_flavor_idx, mu, sigma, amplitude, for fi in local_flavor_idx: gv_pert[:, fi, :] = 0.0 return gv_pert # positivity trivially satisfied; skip clipping - elif mode == 'calibrated': + + # Per-replica sign vector: shape (nrep, 1) for broadcasting over nx. + if random_sign: + _rng = rng if rng is not None else np.random.default_rng() + signs = _rng.choice(np.array([-1.0, 1.0]), size=nrep)[:, np.newaxis] + else: + signs = np.ones((nrep, 1), dtype=float) + + if mode == 'calibrated': # Per-flavor amplitude: alpha * replica std at x closest to mu. xgrid_arr = np.asarray(xgrid) idx_mu = int(np.argmin(np.abs(xgrid_arr - mu))) for fi in local_flavor_idx: sigma_rep = float(gv[:, fi, idx_mu].std()) gauss = gaussian_profile(xgrid, mu, sigma, amplitude * sigma_rep, xspace) - gv_pert[:, fi, :] += gauss[np.newaxis, :] + gv_pert[:, fi, :] += signs * gauss[np.newaxis, :] elif mode == 'additive': gauss = gaussian_profile(xgrid, mu, sigma, amplitude, xspace) for fi in local_flavor_idx: - gv_pert[:, fi, :] += gauss[np.newaxis, :] + gv_pert[:, fi, :] += signs * gauss[np.newaxis, :] else: # multiplicative gauss = gaussian_profile(xgrid, mu, sigma, amplitude, xspace) for fi in local_flavor_idx: - gv_pert[:, fi, :] *= (1.0 + gauss[np.newaxis, :]) + gv_pert[:, fi, :] *= (1.0 + signs * gauss[np.newaxis, :]) # Enforce positivity only on perturbed channels and only when the perturbation would drive a previously non-negative point below zero. for fi in local_flavor_idx: diff --git a/validphys2/src/validphys/shapley/runcards/sv_dy_lhc.yaml b/validphys2/src/validphys/shapley/runcards/sv_dy_lhc.yaml index 0433d401f4..192db57858 100644 --- a/validphys2/src/validphys/shapley/runcards/sv_dy_lhc.yaml +++ b/validphys2/src/validphys/shapley/runcards/sv_dy_lhc.yaml @@ -5,15 +5,20 @@ pdf_name: NNPDF40_nnlo_as_01180 theory_id: 708 use_cuts: internal n_replicas: 100 +output_root: sv_results/nnpdf40 +log_root: slurm/logs/nnpdf40 +run_name: sv_dy_lhc basis: - evolution - flavor -perturbation: - mu: 0.02 - sigma: 0.1 - amplitude: 0.30 +experiments: + - name: baseline + perturbation: + mu: 0.02 + sigma: 0.1 + amplitude: 0.30 datasets: # ATLAS DY diff --git a/validphys2/src/validphys/shapley/runcards/sv_global.yaml b/validphys2/src/validphys/shapley/runcards/sv_global.yaml index 3559eec19c..f76b5a4aeb 100644 --- a/validphys2/src/validphys/shapley/runcards/sv_global.yaml +++ b/validphys2/src/validphys/shapley/runcards/sv_global.yaml @@ -6,17 +6,20 @@ pdf_name: NNPDF40_nnlo_as_01180 theory_id: 708 use_cuts: internal n_replicas: 100 +output_root: sv_results/nnpdf40 +log_root: slurm/logs/nnpdf40 +run_name: sv_global basis: - - evolution + - flavor -enforce_sumrules: true - -perturbation: - mu: 0.002 - sigma: 0.001 - amplitude: 0.5 - mode: multiplicative +experiments: + - name: baseline + perturbation: + mu: 0.05 + sigma: 0.1 + amplitude: -10 + mode: additive datasets: # DIS: Fixed-target diff --git a/validphys2/src/validphys/shapley/scripts/vp_shapley.py b/validphys2/src/validphys/shapley/scripts/vp_shapley.py index 50466167d3..0037281804 100644 --- a/validphys2/src/validphys/shapley/scripts/vp_shapley.py +++ b/validphys2/src/validphys/shapley/scripts/vp_shapley.py @@ -22,7 +22,74 @@ from validphys.shapley.setup import setup_observables from validphys.shapley.analyzer import NNPDFShapleyAnalyzer -from shapley_values import save_results, plot_shapley_comparison +from validphys.shapley.perturbation import apply_gaussian_perturbation +import matplotlib.lines as mlines +import matplotlib.patches as mpatches + +from shapley_values import save_results + + +def _plot_sv_bar(sv, labels, title=None, sv_err=None, + ax=None, figsize=(12, 6), + ylabel="Shapley Value (delta chi2/N)", + positive_color="green", negative_color="red", alpha=0.7): + """Bar chart of Shapley values with optional symmetric error bars. + + Parameters + ---------- + sv : array-like, shape (n,) + labels : list of str + title : str, optional + sv_err : array-like, shape (n,) or None + 1-sigma uncertainty per flavour (e.g. replica std or std-error). + When provided, symmetric black error bars are drawn on each bar. + ax : matplotlib Axes, optional + Draw into this axes; otherwise a new figure is created. + figsize, ylabel, positive_color, negative_color, alpha + Forwarded to the underlying bar plot. + """ + sv = np.asarray(sv, dtype=float) + if ax is None: + fig, ax = plt.subplots(figsize=figsize) + else: + fig = ax.figure + + bars = ax.bar(labels, sv) + for bar, val in zip(bars, sv): + bar.set_color(positive_color if val >= 0 else negative_color) + bar.set_alpha(alpha) + + if sv_err is not None: + sv_err = np.asarray(sv_err, dtype=float) + ax.errorbar( + labels, sv, + yerr=sv_err, + fmt="none", + ecolor="black", + elinewidth=1.2, + capsize=4, + capthick=1.2, + zorder=5, + ) + + ax.axhline(0, color="black", lw=0.5) + ax.set_ylabel(ylabel) + ax.grid(axis="y", ls="--", alpha=0.5) + plt.setp(ax.get_xticklabels(), rotation=45, ha="right") + if title: + ax.set_title(title) + + handles = [ + mpatches.Patch(color=positive_color, alpha=alpha, label="SV > 0"), + mpatches.Patch(color=negative_color, alpha=alpha, label="SV < 0"), + ] + if sv_err is not None: + handles.append( + mlines.Line2D([], [], color="black", linewidth=1.2, label="1\u03c3 std") + ) + ax.legend(handles=handles, loc="upper right") + fig.tight_layout() + return fig def load_runcard(path): @@ -98,7 +165,14 @@ def _normalize_experiments(cfg): exp_cfg = dict(cfg) exp_cfg["perturbation"] = pert - for key in ["basis", "n_jobs", "enforce_sumrules", "n_replicas", "run_name"]: + for key in [ + "basis", + "n_jobs", + "enforce_sumrules", + "n_replicas", + "run_name", + "stabilization", + ]: if key in exp: exp_cfg[key] = exp[key] @@ -143,7 +217,7 @@ def _format_experiment_title(exp_name, exp_meta): def _save_comparison_plots(all_experiment_results, output_dir, experiment_meta): - """Save per-basis comparison plots across experiments.""" + """Save per-basis comparison plots across experiments (with error bars when available).""" if len(all_experiment_results) < 2: return @@ -165,35 +239,391 @@ def _save_comparison_plots(all_experiment_results, output_dir, experiment_meta): if labels is None: continue - matrix = [] + sv_rows = [] + std_rows = [] for exp_name in exp_names: basis_results = all_experiment_results[exp_name].get(basis, {}) sv_map = basis_results.get("shapley_values", {}) - matrix.append([float(sv_map.get(lbl, 0.0)) for lbl in labels]) - matrix = np.asarray(matrix, dtype=float) - - results_list = [] - for i, exp_name in enumerate(exp_names): - results_list.append( - { - "shapley_values": matrix[i], - "player_short": labels, - } + std_map = basis_results.get("shapley_std") or {} + sv_rows.append(np.array([float(sv_map.get(lbl, 0.0)) for lbl in labels])) + std_rows.append( + np.array([float(std_map.get(lbl, 0.0)) for lbl in labels]) + if std_map else None ) + titles = [ _format_experiment_title(exp_name, experiment_meta.get(exp_name, {})) for exp_name in exp_names ] - fig = plot_shapley_comparison(results_list, titles=titles) + n = len(exp_names) + ncols = min(n, 3) + nrows = int(np.ceil(n / ncols)) + fig, axes = plt.subplots(nrows, ncols, figsize=(7 * ncols, 5 * nrows)) + axes_flat = np.atleast_1d(axes).ravel() + + for ax, sv_row, std_row, ttl in zip(axes_flat, sv_rows, std_rows, titles): + _plot_sv_bar(sv_row, labels, title=ttl, sv_err=std_row, ax=ax) + + for ax in axes_flat[n:]: + ax.set_visible(False) + + fig.tight_layout() out_path = output_dir / f"shapley_comparison_{basis}.png" fig.savefig(out_path, dpi=150, bbox_inches="tight") plt.close(fig) print(f"Saved comparison plot: {out_path}") -def run_analysis(cfg, output_dir, setup_context, n_jobs_override=None): - """Execute the full Shapley value pipeline from one experiment config.""" +def _save_diagnostic_files(diag, output_dir, basis): + """Write per-coalition chi2 CSV, marginal-contribution CSV, and stats JSON. + + Files produced + -------------- + coalition_chi2_.csv + One row per coalition sorted by chi2 (descending). + Columns: coalition_labels, size, chi2, is_outlier + + marginal_contributions_.csv + One row per (player, coalition-without-player) pair. + Columns: player, coalition_without, v_without, v_with, delta_v, is_outlier + + diagnostic_stats_.json + Summary statistics for chi2 and per-player marginals. + """ + import copy + + # ── coalition_chi2 CSV ───────────────────────────────────────────────── + outlier_threshold = diag.get("outlier_chi2_threshold", float("inf")) + outlier_set = { + tuple(oc["coalition"]) for oc in diag.get("outlier_coalitions", []) + } + # Rebuild from the marginal list to get all coalitions (including empty). + # Also collect the full coalition set from chi2_stats (n_coalitions count). + # We rely on _marginal_contributions for the data. + marginals = diag.get("_marginal_contributions", []) + + # Build dict coalition -> chi2 from marginals (v_without is chi2 of coalition). + chi2_from_marginals = {} + for m in marginals: + coal = tuple(m["coalition_without"]) + chi2_from_marginals[coal] = m["v_without"] + coal_with = tuple(sorted(m["coalition_without"] + [m["player_idx"]])) + chi2_from_marginals[coal_with] = m["v_with"] + + # Sort by chi2 descending. + sorted_coalitions = sorted( + chi2_from_marginals.items(), key=lambda kv: -kv[1] + ) + + # Map player indices -> short labels (for human-readable coalition column). + # We need the flavor_short list; it isn't in diag, so re-derive from marginals. + idx_to_label = {} + for m in marginals: + idx_to_label[m["player_idx"]] = m["player"] + + coalition_csv_path = output_dir / f"coalition_chi2_{basis}.csv" + with open(coalition_csv_path, "w") as f: + f.write("coalition_labels,size,chi2,is_outlier\n") + for coal, chi2 in sorted_coalitions: + labels_str = "|".join(idx_to_label.get(i, str(i)) for i in coal) + is_out = 1 if coal in outlier_set or chi2 > outlier_threshold else 0 + f.write(f"{labels_str},{len(coal)},{chi2:.8f},{is_out}\n") + print(f"Saved: {coalition_csv_path}") + + # ── marginal_contributions CSV ───────────────────────────────────────── + contrib_csv_path = output_dir / f"marginal_contributions_{basis}.csv" + with open(contrib_csv_path, "w") as f: + f.write("player,coalition_without,v_without,v_with,delta_v,is_outlier\n") + for m in sorted(marginals, key=lambda x: -abs(x["delta_v"])): + coal_str = "|".join( + idx_to_label.get(i, str(i)) for i in m["coalition_without"] + ) + f.write( + f"{m['player']},{coal_str}," + f"{m['v_without']:.8f},{m['v_with']:.8f}," + f"{m['delta_v']:.8f},{m.get('is_outlier', 0)}\n" + ) + print(f"Saved: {contrib_csv_path}") + + # ── diagnostic_stats JSON ───────────────────────────────────────────── + # Strip the internal key before serialising. + diag_public = {k: v for k, v in diag.items() if k != "_marginal_contributions"} + stats_path = output_dir / f"diagnostic_stats_{basis}.json" + with open(stats_path, "w") as f: + json.dump(diag_public, f, indent=2) + print(f"Saved: {stats_path}") + + +def _write_shapley_csv(path, labels, values): + """Write Shapley values to CSV with standard schema.""" + with open(path, "w") as f: + f.write("flavour,shapley_value\n") + for lbl, val in zip(labels, values): + f.write(f"{lbl},{float(val):.8f}\n") + + +def _resolve_stabilization_cfg(cfg): + """Resolve stabilization options with safe defaults.""" + stab = cfg.get("stabilization", {}) or {} + if not isinstance(stab, dict): + raise TypeError("'stabilization' must be a mapping if provided") + + action = str(stab.get("action", "exclude_dataset")).strip().lower() + if action not in {"exclude_dataset", "report_only"}: + raise ValueError( + "stabilization.action must be 'exclude_dataset' or 'report_only'" + ) + + threshold = float(stab.get("dataset_delta_chi2_threshold", 1e4)) + if threshold <= 0: + raise ValueError("stabilization.dataset_delta_chi2_threshold must be > 0") + + max_outlier_coalitions = int(stab.get("max_outlier_coalitions", 5)) + if max_outlier_coalitions < 1: + raise ValueError("stabilization.max_outlier_coalitions must be >= 1") + + return { + # Native behavior unless explicitly disabled in the runcard. + "enabled": bool(stab.get("enabled", True)), + "action": action, + "dataset_delta_chi2_threshold": threshold, + "max_outlier_coalitions": max_outlier_coalitions, + "rerun_stable": bool(stab.get("rerun_stable", True)), + } + + +def _dataset_mean_chi2_for_coalition(analyzer, coalition, pert): + """Compute per-dataset mean chi2 for a single coalition.""" + mu = pert["mu"] + sigma = pert["sigma"] + amplitude = pert["amplitude"] + mode = pert.get("mode", "additive") + xspace = pert.get("xspace", "linear") + + sr_norm = None + if analyzer.enforce_sumrules: + sr_norm = analyzer._compute_sumrule_norm( + coalition, mu, sigma, amplitude, mode, xspace + ) + + rows = [] + for obs in analyzer.observables: + if analyzer.basis == "flavor": + gv_pert_list = [] + perturb_idx = [analyzer.flavor_indices[p] for p in coalition] + for idx, entry in enumerate(obs.fk_entries): + gv_flav = analyzer._get_flavor_gv_for_entry(obs, idx) + gv_pert = apply_gaussian_perturbation( + gv_flav, + perturb_idx, + mu, + sigma, + amplitude, + entry.xgrid, + mode=mode, + xspace=xspace, + ) + gv_pert_list.append(gv_pert) + + if sr_norm is not None: + gv_evol_list = obs.rotate_to_evolution(gv_pert_list) + gv_evol_list = [ + analyzer._apply_norm_to_gv( + gv, + sr_norm, + range(14) if entry.hadronic else entry.flavor_indices, + ) + for gv, entry in zip(gv_evol_list, obs.fk_entries) + ] + chi2_arr = obs.chi2(gv_evol_list) + else: + chi2_arr = obs.chi2_from_flavor(gv_pert_list) + else: + gv_pert_list = [] + for idx, entry in enumerate(obs.fk_entries): + if entry.hadronic: + gv = analyzer._get_gv_all14_for_entry(obs, idx) + perturb_idx = [analyzer.flavor_indices[p] for p in coalition] + else: + gv = analyzer._get_gv_for_entry(obs, idx) + perturb_idx = analyzer._local_flavor_indices_for_entry( + entry, coalition + ) + + gv_pert = apply_gaussian_perturbation( + gv, + perturb_idx, + mu, + sigma, + amplitude, + entry.xgrid, + mode=mode, + xspace=xspace, + ) + if sr_norm is not None: + fi = range(14) if entry.hadronic else entry.flavor_indices + gv_pert = analyzer._apply_norm_to_gv(gv_pert, sr_norm, fi) + gv_pert_list.append(gv_pert) + chi2_arr = obs.chi2(gv_pert_list) + + mean_chi2 = float(np.mean(chi2_arr)) + rows.append( + { + "dataset": obs.name, + "ndata": int(obs.ndata), + "operation": str(obs.operation), + "n_fk": int(obs.n_fk), + "hadronic": bool(obs.hadronic), + "mean_chi2": mean_chi2, + "chi2_per_point": mean_chi2 / obs.ndata, + } + ) + return rows + + +def _build_stabilization_report(analyzer, raw_results, pert, stab_cfg): + """Build coalition->dataset outlier report and exclusion list.""" + diag = raw_results.get("diagnostic") or {} + outliers = list(diag.get("outlier_coalitions", [])) + n_selected = min(len(outliers), int(stab_cfg["max_outlier_coalitions"])) + selected = outliers[:n_selected] + + baseline_rows = _dataset_mean_chi2_for_coalition(analyzer, [], pert) + baseline_map = {r["dataset"]: r for r in baseline_rows} + + threshold = float(stab_cfg["dataset_delta_chi2_threshold"]) + coalition_reports = [] + dataset_acc = {} + + for oc in selected: + coalition_idx = list(oc.get("coalition", [])) + coalition_labels = list(oc.get("coalition_labels", [])) + coalition_rows = _dataset_mean_chi2_for_coalition(analyzer, coalition_idx, pert) + + flagged = [] + for crow in coalition_rows: + dname = crow["dataset"] + brow = baseline_map[dname] + delta_mean = float(crow["mean_chi2"] - brow["mean_chi2"]) + if abs(delta_mean) < threshold: + continue + + row = { + "dataset": dname, + "ndata": int(crow["ndata"]), + "operation": crow["operation"], + "n_fk": int(crow["n_fk"]), + "hadronic": bool(crow["hadronic"]), + "baseline_mean_chi2": float(brow["mean_chi2"]), + "coalition_mean_chi2": float(crow["mean_chi2"]), + "delta_mean_chi2": delta_mean, + "baseline_chi2_per_point": float(brow["chi2_per_point"]), + "coalition_chi2_per_point": float(crow["chi2_per_point"]), + "delta_chi2_per_point": float( + crow["chi2_per_point"] - brow["chi2_per_point"] + ), + } + flagged.append(row) + + acc = dataset_acc.setdefault( + dname, + { + "dataset": dname, + "ndata": int(crow["ndata"]), + "operation": crow["operation"], + "n_fk": int(crow["n_fk"]), + "hadronic": bool(crow["hadronic"]), + "max_abs_delta_mean_chi2": 0.0, + "coalitions": [], + }, + ) + acc["max_abs_delta_mean_chi2"] = float( + max(acc["max_abs_delta_mean_chi2"], abs(delta_mean)) + ) + acc["coalitions"].append( + { + "coalition": coalition_idx, + "coalition_labels": coalition_labels, + "delta_mean_chi2": delta_mean, + "coalition_chi2": float(oc.get("chi2", float("nan"))), + } + ) + + flagged.sort(key=lambda x: abs(x["delta_mean_chi2"]), reverse=True) + coalition_reports.append( + { + "coalition": coalition_idx, + "coalition_labels": coalition_labels, + "size": int(oc.get("size", len(coalition_idx))), + "chi2": float(oc.get("chi2", float("nan"))), + "z_score": float(oc.get("z_score", float("nan"))), + "n_flagged_datasets": len(flagged), + "flagged_datasets": flagged, + } + ) + + flagged_datasets = sorted( + dataset_acc.values(), + key=lambda x: abs(x["max_abs_delta_mean_chi2"]), + reverse=True, + ) + excluded = ( + [d["dataset"] for d in flagged_datasets] + if stab_cfg["action"] == "exclude_dataset" + else [] + ) + + return { + "enabled": bool(stab_cfg["enabled"]), + "action": stab_cfg["action"], + "dataset_delta_chi2_threshold": threshold, + "max_outlier_coalitions": int(stab_cfg["max_outlier_coalitions"]), + "n_outlier_coalitions_detected": len(outliers), + "n_outlier_coalitions_analyzed": n_selected, + "coalitions_analyzed": coalition_reports, + "n_flagged_datasets": len(flagged_datasets), + "flagged_datasets": flagged_datasets, + "excluded_datasets": excluded, + } + + +def _save_stabilization_files(report, output_dir, basis): + """Write stabilization report JSON + compact flagged-dataset CSV.""" + json_path = output_dir / f"stabilization_report_{basis}.json" + with open(json_path, "w") as f: + json.dump(report, f, indent=2) + print(f"Saved: {json_path}") + + csv_path = output_dir / f"stabilization_flagged_datasets_{basis}.csv" + with open(csv_path, "w") as f: + f.write( + "dataset,operation,n_fk,ndata,max_abs_delta_mean_chi2," + "n_flagged_coalitions,excluded\n" + ) + excluded = set(report.get("excluded_datasets", [])) + for row in report.get("flagged_datasets", []): + f.write( + f"{row['dataset']},{row['operation']},{row['n_fk']},{row['ndata']}," + f"{row['max_abs_delta_mean_chi2']:.8f},{len(row.get('coalitions', []))}," + f"{1 if row['dataset'] in excluded else 0}\n" + ) + print(f"Saved: {csv_path}") + return json_path, csv_path + + +def run_analysis(cfg, output_dir, setup_context, n_jobs_override=None, + diagnostic=None, outlier_n_sigma=3.0): + """Execute the full Shapley value pipeline from one experiment config. + + Parameters + ---------- + diagnostic : bool or None + When True, record chi2 for every coalition and write diagnostic files. + None (default) reads the ``diagnostic`` key from *cfg*. + outlier_n_sigma : float + Z-score threshold for flagging extreme coalitions / marginals. + """ pdf = setup_context["pdf"] observables = setup_context["observables"] flavor_info = setup_context["flavor_info"] @@ -209,10 +639,34 @@ def run_analysis(cfg, output_dir, setup_context, n_jobs_override=None): amplitude = pert["amplitude"] mode = pert.get("mode", "additive") xspace = pert.get("xspace", "linear") + # Per-replica SVs: compute phi_j^(k) for every replica and report uncertainty. + # Resolved from perturbation block or top-level cfg key. + per_replica = bool( + pert.get("per_replica", cfg.get("per_replica", False)) + ) + # Random sign: flip amplitude sign independently per replica per coalition. + random_sign = bool( + pert.get("random_sign", cfg.get("random_sign", False)) + ) enforce_sumrules = cfg.get("enforce_sumrules", False) n_jobs = int(cfg.get("n_jobs", 1)) if n_jobs_override is not None: n_jobs = int(n_jobs_override) + # Resolve diagnostic flag: CLI/caller override > runcard key > False. + if diagnostic is None: + diagnostic = bool(cfg.get("diagnostic", False)) + diag_sigma = float(cfg.get("outlier_n_sigma", outlier_n_sigma)) + + stabilization = _resolve_stabilization_cfg(cfg) + if stabilization["enabled"]: + print( + "Stabilization : ON " + f"(action={stabilization['action']}, " + f"threshold={stabilization['dataset_delta_chi2_threshold']:.1f}, " + f"max_outlier_coalitions={stabilization['max_outlier_coalitions']})" + ) + else: + print("Stabilization : OFF") output_dir.mkdir(parents=True, exist_ok=True) all_results = {} @@ -240,37 +694,156 @@ def run_analysis(cfg, output_dir, setup_context, n_jobs_override=None): ) t0 = time.time() - results = analyzer.exact_shap( + # Stabilization requires full coalition diagnostics from the raw run. + raw_diagnostic = diagnostic + if stabilization["enabled"]: + if diagnostic is False: + print( + " Note: forcing diagnostics ON for raw run because " + "stabilization is enabled." + ) + raw_diagnostic = True + + results_raw = analyzer.exact_shap( mu=mu, sigma=sigma, amplitude=amplitude, mode=mode, xspace=xspace, plot=True, n_jobs=n_jobs, + diagnostic=raw_diagnostic, outlier_n_sigma=diag_sigma, + per_replica=per_replica, random_sign=random_sign, ) + stabilization_report = None + stabilization_json = None + excluded_datasets = [] + results_final = results_raw + stable_rerun_performed = False + observables_used = observables + + if stabilization["enabled"]: + stabilization_report = _build_stabilization_report( + analyzer, results_raw, pert, stabilization + ) + stabilization_json, _ = _save_stabilization_files( + stabilization_report, output_dir, basis + ) + excluded_datasets = list(stabilization_report.get("excluded_datasets", [])) + + if ( + stabilization["action"] == "exclude_dataset" + and stabilization["rerun_stable"] + and excluded_datasets + ): + kept = [obs for obs in observables if obs.name not in excluded_datasets] + if not kept: + print( + " Stabilization requested exclusion, but all datasets would " + "be removed. Keeping raw result." + ) + else: + print( + f" Excluding {len(excluded_datasets)} dataset(s) and " + f"re-running stable Shapley on {len(kept)} dataset(s)." + ) + stable_analyzer = NNPDFShapleyAnalyzer( + pdf, + kept, + fi, + n_replicas=n_replicas, + basis=basis, + enforce_sumrules=enforce_sumrules, + ) + results_final = stable_analyzer.exact_shap( + mu=mu, sigma=sigma, amplitude=amplitude, + mode=mode, xspace=xspace, plot=True, n_jobs=n_jobs, + diagnostic=diagnostic, outlier_n_sigma=diag_sigma, + per_replica=per_replica, random_sign=random_sign, + ) + stable_rerun_performed = True + observables_used = kept + elapsed = time.time() - t0 print(f"\nElapsed: {elapsed:.1f}s") - if results.get("fig_pdfs") is not None: + # Save plots from the final result (raw or stable rerun). + if results_final.get("fig_pdfs") is not None: pdf_fig_path = output_dir / f"pdfs_{basis}.png" - results["fig_pdfs"].savefig(pdf_fig_path, dpi=150, bbox_inches="tight") + results_final["fig_pdfs"].savefig(pdf_fig_path, dpi=150, bbox_inches="tight") print(f"Saved: {pdf_fig_path}") - if results.get("fig_bar") is not None: + if results_final.get("fig_bar") is not None: bar_fig_path = output_dir / f"shapley_bar_{basis}.png" - results["fig_bar"].savefig(bar_fig_path, dpi=150, bbox_inches="tight") + results_final["fig_bar"].savefig(bar_fig_path, dpi=150, bbox_inches="tight") print(f"Saved: {bar_fig_path}") - sv = results["shapley_values"] - labels = results["flavor_short"] + # Always keep raw reference output when stabilization is enabled. + labels_raw = results_raw["flavor_short"] + sv_raw = results_raw["shapley_values"] + if stabilization["enabled"]: + csv_raw = output_dir / f"shapley_values_{basis}_raw.csv" + _write_shapley_csv(csv_raw, labels_raw, sv_raw) + print(f"Saved: {csv_raw}") + + labels = results_final["flavor_short"] + sv = results_final["shapley_values"] csv_path = output_dir / f"shapley_values_{basis}.csv" - with open(csv_path, "w") as f: - f.write("flavour,shapley_value\n") - for lbl, val in zip(labels, sv): - f.write(f"{lbl},{val:.8f}\n") + _write_shapley_csv(csv_path, labels, sv) print(f"Saved: {csv_path}") + # Per-replica uncertainty CSV. + sv_std = results_final.get("shapley_std") + sv_err = results_final.get("shapley_err") + if per_replica and sv_std is not None: + unc_path = output_dir / f"shapley_uncertainties_{basis}.csv" + with open(unc_path, "w") as f: + f.write("flavour,mean,std,err\n") + for lbl, mean_v, std_v, err_v in zip( + labels, + sv, + sv_std, + sv_err, + ): + f.write( + f"{lbl},{float(mean_v):.8f},{float(std_v):.8f},{float(err_v):.8f}\n" + ) + print(f"Saved: {unc_path}") + + if stable_rerun_performed: + csv_stable = output_dir / f"shapley_values_{basis}_stable.csv" + _write_shapley_csv(csv_stable, labels, sv) + print(f"Saved: {csv_stable}") + + # Diagnostic files. + if stabilization["enabled"] and results_raw.get("diagnostic"): + _save_diagnostic_files(results_raw["diagnostic"], output_dir, f"{basis}_raw") + if results_final.get("diagnostic"): + _save_diagnostic_files(results_final["diagnostic"], output_dir, basis) + all_results[basis] = { "shapley_values": {l: float(v) for l, v in zip(labels, sv)}, - "baseline_chi2": float(results["baseline_chi2"]), - "coalitions_evaluated": results["coalitions_evaluated"], + "shapley_std": ( + {l: float(v) for l, v in zip(labels, sv_std)} + if sv_std is not None else None + ), + "shapley_err": ( + {l: float(v) for l, v in zip(labels, sv_err)} + if sv_err is not None else None + ), + "per_replica": per_replica, + "random_sign": random_sign, + "baseline_chi2": float(results_final["baseline_chi2"]), + "coalitions_evaluated": results_final["coalitions_evaluated"], "elapsed_seconds": round(elapsed, 1), - "n_jobs": int(results.get("n_jobs", n_jobs)), + "n_jobs": int(results_final.get("n_jobs", n_jobs)), + "n_datasets_used": len(observables_used), + "stabilization": { + "enabled": bool(stabilization["enabled"]), + "action": stabilization["action"], + "dataset_delta_chi2_threshold": float( + stabilization["dataset_delta_chi2_threshold"] + ), + "max_outlier_coalitions": int(stabilization["max_outlier_coalitions"]), + "stable_rerun_performed": bool(stable_rerun_performed), + "n_excluded_datasets": int(len(excluded_datasets)), + "excluded_datasets": excluded_datasets, + "report_json": str(stabilization_json) if stabilization_json else None, + }, } meta = { @@ -282,9 +855,20 @@ def run_analysis(cfg, output_dir, setup_context, n_jobs_override=None): "perturbation": { "mu": mu, "sigma": sigma, "amplitude": amplitude, "mode": mode, "xspace": xspace, + "per_replica": per_replica, + "random_sign": random_sign, }, "enforce_sumrules": enforce_sumrules, "n_jobs": int(n_jobs), + "stabilization": { + "enabled": bool(stabilization["enabled"]), + "action": stabilization["action"], + "dataset_delta_chi2_threshold": float( + stabilization["dataset_delta_chi2_threshold"] + ), + "max_outlier_coalitions": int(stabilization["max_outlier_coalitions"]), + "rerun_stable": bool(stabilization["rerun_stable"]), + }, } combined = {"results_by_basis": all_results} json_path = str(output_dir / "results.json") @@ -310,6 +894,27 @@ def main(): "--n-jobs", type=int, default=None, help="Number of worker threads for coalition evaluation." ) + diag_group = parser.add_mutually_exclusive_group() + diag_group.add_argument( + "--diagnostic", action="store_true", default=None, + help=( + "Record chi2 for every coalition and write diagnostic files " + "(coalition_chi2_.csv, marginal_contributions_.csv, " + "diagnostic_stats_.json) into each experiment output directory. " + "Overrides the 'diagnostic' key in the runcard." + ), + ) + diag_group.add_argument( + "--no-diagnostic", dest="diagnostic", action="store_false", + help="Disable diagnostics even if the runcard sets 'diagnostic: true'.", + ) + parser.add_argument( + "--outlier-n-sigma", type=float, default=3.0, + help=( + "Z-score threshold for flagging extreme coalitions and marginal " + "contributions in the diagnostic output (default: 3.0)." + ), + ) args = parser.parse_args() cfg = load_runcard(args.runcard) @@ -337,6 +942,8 @@ def main(): exp_output_dir, setup_context, n_jobs_override=args.n_jobs, + diagnostic=args.diagnostic, + outlier_n_sigma=args.outlier_n_sigma, ) all_experiment_results[exp_name] = experiment_results summary[exp_name] = { diff --git a/validphys2/src/validphys/shapley/slurm/run_vp_shapley.slurm b/validphys2/src/validphys/shapley/slurm/run_vp_shapley.slurm index 09c896902e..2e37dbc1c5 100644 --- a/validphys2/src/validphys/shapley/slurm/run_vp_shapley.slurm +++ b/validphys2/src/validphys/shapley/slurm/run_vp_shapley.slurm @@ -2,7 +2,7 @@ #SBATCH --job-name=vp_shapley #SBATCH --account=inf26_pml4hep_0 #SBATCH --partition=dcgp_usr_prod -#SBATCH --time=02:00:00 +#SBATCH --time=08:00:00 #SBATCH --output=/leonardo/home/userexternal/rbonnetg/projects/nnpdf/validphys2/src/validphys/shapley/slurm/slurm-%j.out #SBATCH --error=/leonardo/home/userexternal/rbonnetg/projects/nnpdf/validphys2/src/validphys/shapley/slurm/slurm-%j.err From 66419f6ef8b64146d0634e5bc36ca702b52b2503 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Rapha=C3=ABl=20Bonnet=20Guerrini?= <81559347+rbonnetguerrini@users.noreply.github.com> Date: Fri, 13 Mar 2026 13:17:00 +0100 Subject: [PATCH 11/21] new plotting --- .../validphys/shapley/scripts/vp_shapley.py | 409 +++++++++++++++--- 1 file changed, 349 insertions(+), 60 deletions(-) diff --git a/validphys2/src/validphys/shapley/scripts/vp_shapley.py b/validphys2/src/validphys/shapley/scripts/vp_shapley.py index 0037281804..fd64273238 100644 --- a/validphys2/src/validphys/shapley/scripts/vp_shapley.py +++ b/validphys2/src/validphys/shapley/scripts/vp_shapley.py @@ -17,6 +17,7 @@ import matplotlib matplotlib.use('Agg') import matplotlib.pyplot as plt +import matplotlib.transforms as mtransforms import numpy as np import yaml @@ -29,10 +30,29 @@ from shapley_values import save_results +_MUTED_SERIES_COLORS = [ + "#4C78A8", + "#F58518", + "#54A24B", + "#E45756", + "#72B7B2", + "#EECA3B", + "#B279A2", + "#FF9DA6", + "#9D755D", + "#BAB0AC", +] +_SERIES_MARKERS = ["o", "s", "D", "^", "v", "P", "X", "<", ">", "h"] +_SOFT_POSITIVE_COLOR = "#7FAF9C" +_SOFT_NEGATIVE_COLOR = "#D8A0A0" + + def _plot_sv_bar(sv, labels, title=None, sv_err=None, ax=None, figsize=(12, 6), ylabel="Shapley Value (delta chi2/N)", - positive_color="green", negative_color="red", alpha=0.7): + positive_color=_SOFT_POSITIVE_COLOR, + negative_color=_SOFT_NEGATIVE_COLOR, + alpha=0.85, show_legend=True): """Bar chart of Shapley values with optional symmetric error bars. Parameters @@ -61,20 +81,24 @@ def _plot_sv_bar(sv, labels, title=None, sv_err=None, if sv_err is not None: sv_err = np.asarray(sv_err, dtype=float) - ax.errorbar( - labels, sv, - yerr=sv_err, - fmt="none", - ecolor="black", - elinewidth=1.2, - capsize=4, - capthick=1.2, - zorder=5, - ) + if np.any(np.isfinite(sv_err)): + sv_err = np.where(np.isfinite(sv_err), sv_err, 0.0) + ax.errorbar( + labels, sv, + yerr=sv_err, + fmt="none", + ecolor="#333333", + elinewidth=1.1, + capsize=3.2, + capthick=1.1, + zorder=5, + ) - ax.axhline(0, color="black", lw=0.5) + ax.axhline(0, color="#444444", lw=0.8, alpha=0.9) ax.set_ylabel(ylabel) - ax.grid(axis="y", ls="--", alpha=0.5) + ax.grid(axis="y", ls="--", alpha=0.35, linewidth=0.7) + ax.spines["top"].set_visible(False) + ax.spines["right"].set_visible(False) plt.setp(ax.get_xticklabels(), rotation=45, ha="right") if title: ax.set_title(title) @@ -83,11 +107,12 @@ def _plot_sv_bar(sv, labels, title=None, sv_err=None, mpatches.Patch(color=positive_color, alpha=alpha, label="SV > 0"), mpatches.Patch(color=negative_color, alpha=alpha, label="SV < 0"), ] - if sv_err is not None: + if sv_err is not None and np.any(np.isfinite(sv_err)): handles.append( - mlines.Line2D([], [], color="black", linewidth=1.2, label="1\u03c3 std") + mlines.Line2D([], [], color="#333333", linewidth=1.1, label="1\u03c3 std") ) - ax.legend(handles=handles, loc="upper right") + if show_legend: + ax.legend(handles=handles, loc="upper right", frameon=False) fig.tight_layout() return fig @@ -197,27 +222,264 @@ def _build_setup_context(cfg): } -def _format_experiment_title(exp_name, exp_meta): - """Build concise comparison subplot title including perturbation params.""" +def _format_axis_tick(val): + """Compact numeric tick labels suitable for x-scan values.""" + val = float(val) + if val == 0.0: + return "0" + abs_v = abs(val) + if 1e-2 <= abs_v < 1e2: + return f"{val:g}" + text = f"{val:.0e}" + return text.replace("e-0", "e-").replace("e+0", "e+") + + +def _resolve_scan_axis(exp_names, experiment_meta, evenly_spaced_bins=True): + """Return axis positions and display labels for experiment comparisons.""" + mu_vals = [] + xspaces = [] + for exp_name in exp_names: + pert = (experiment_meta.get(exp_name) or {}).get("perturbation", {}) + try: + mu_vals.append(float(pert.get("mu"))) + except (TypeError, ValueError): + mu_vals = None + break + xspaces.append(str(pert.get("xspace", "linear")).strip().lower()) + + n_exp = len(exp_names) + if not mu_vals or len(mu_vals) != n_exp: + x = np.arange(n_exp, dtype=float) + return { + "order": np.arange(n_exp), + "x": x, + "tick_labels": exp_names, + "xscale": "linear", + "xlabel": "Experiment", + "is_index_axis": True, + } + + order = np.argsort(mu_vals) + x_sorted = np.asarray(mu_vals, dtype=float)[order] + if evenly_spaced_bins: + # Use evenly spaced bins for readability while keeping sorted mu labels. + x_bins = np.arange(n_exp, dtype=float) + return { + "order": order, + "x": x_bins, + "tick_labels": [_format_axis_tick(v) for v in x_sorted], + "xscale": "linear", + "xlabel": "Perturbation center x (mu, evenly spaced bins)", + "is_index_axis": True, + } + + all_positive = bool(np.all(x_sorted > 0)) + use_log = all_positive and all(xs == "logx" for xs in xspaces) + return { + "order": order, + "x": x_sorted, + "tick_labels": [_format_axis_tick(v) for v in x_sorted], + "xscale": "log" if use_log else "linear", + "xlabel": "Perturbation center x (mu)", + "is_index_axis": False, + } + + +def _plot_sv_scan_comparison( + sv_matrix, + err_matrix, + labels, + basis, + output_dir, + axis_info, + output_stem, + title_suffix=None, + dodge_step_pt=4.5, + use_dodge=True, +): + """Plot SV vs scan-x with per-flavor markers and uncertainty bars.""" + x = np.asarray(axis_info["x"], dtype=float) + use_index_axis = bool(axis_info["is_index_axis"]) + + with matplotlib.rc_context( + { + "font.size": 12, + "axes.labelsize": 13, + "axes.titlesize": 14, + "legend.fontsize": 10, + "xtick.labelsize": 11, + "ytick.labelsize": 11, + } + ): + fig, ax = plt.subplots(figsize=(10.5, 6.2)) + n_series = len(labels) + if (not use_dodge) or n_series <= 1: + dodge_offsets_pt = np.zeros(n_series, dtype=float) + else: + # Constant display-space dodge keeps interpretation of x intact + # for both linear and logarithmic axes. + half_span_pt = 0.5 * dodge_step_pt * (n_series - 1) + dodge_offsets_pt = np.linspace( + -half_span_pt, half_span_pt, n_series, dtype=float + ) + + for i, flav in enumerate(labels): + y = sv_matrix[:, i] + yerr = err_matrix[:, i] if err_matrix is not None else None + valid = np.isfinite(y) + if not np.any(valid): + continue + + xv = x[valid] + yv = y[valid] + color = _MUTED_SERIES_COLORS[i % len(_MUTED_SERIES_COLORS)] + marker = _SERIES_MARKERS[i % len(_SERIES_MARKERS)] + + if yerr is not None: + yerrv = np.asarray(yerr[valid], dtype=float) + yerrv = np.where(np.isfinite(yerrv), yerrv, 0.0) + else: + yerrv = None + + err_container = ax.errorbar( + xv, + yv, + yerr=yerrv, + linestyle="none", + linewidth=0.0, + marker=marker, + markersize=5.0, + markerfacecolor="white", + markeredgewidth=1.0, + capsize=2.8, + elinewidth=1.0, + color=color, + alpha=0.95, + label=flav, + zorder=3, + ) + dx_pt = float(dodge_offsets_pt[i]) + if dx_pt != 0.0: + shift = mtransforms.ScaledTranslation( + dx_pt / 72.0, 0.0, fig.dpi_scale_trans + ) + shifted_data = ax.transData + shift + data_line, cap_lines, bar_linecols = err_container.lines + if data_line is not None: + data_line.set_transform(shifted_data) + for artist in cap_lines: + artist.set_transform(shifted_data) + for artist in bar_linecols: + artist.set_transform(shifted_data) + + if axis_info["xscale"] == "log": + ax.set_xscale("log") + + ax.set_xticks(x) + ax.set_xticklabels(axis_info["tick_labels"], rotation=0 if not use_index_axis else 35) + ax.set_xlabel(axis_info["xlabel"]) + ax.set_ylabel("Shapley Value (delta chi2/N)") + title = f"Shapley comparison ({basis} basis)" + if title_suffix: + title = f"{title} - {title_suffix}" + ax.set_title(title) + ax.axhline(0.0, color="#555555", linewidth=0.9, alpha=0.9) + ax.grid(True, which="major", linestyle="--", linewidth=0.7, alpha=0.35) + ax.spines["top"].set_visible(False) + ax.spines["right"].set_visible(False) + + ax.legend( + loc="upper left", + bbox_to_anchor=(1.01, 1.0), + frameon=False, + ncol=1, + borderaxespad=0.0, + ) + fig.tight_layout(rect=[0, 0, 0.82, 1]) + + png_path = output_dir / f"{output_stem}_{basis}.png" + pdf_path = output_dir / f"{output_stem}_{basis}.pdf" + fig.savefig(png_path, dpi=220, bbox_inches="tight") + fig.savefig(pdf_path, bbox_inches="tight") + plt.close(fig) + print(f"Saved comparison plot: {png_path}") + print(f"Saved comparison plot: {pdf_path}") + + +def _format_experiment_panel_title(exp_name, exp_meta): + """Compact per-panel title for bar comparison figures.""" pert = (exp_meta or {}).get("perturbation", {}) - amp = pert.get("amplitude", "na") - mu = pert.get("mu", "na") - sigma = pert.get("sigma", "na") - mode = pert.get("mode", "additive") - xspace = pert.get("xspace") - if mode == "ablation": - title = f"{exp_name} | {mode}" - elif mode == "calibrated": - title = f"{exp_name} | A={amp}\u03c3_rep, mu={mu}, sigma={sigma}, {mode}" - else: - title = f"{exp_name} | A={amp}, mu={mu}, sigma={sigma}, {mode}" - if xspace is not None: - title += f", {xspace}" - return title + mu = pert.get("mu") + sigma = pert.get("sigma") + if mu is None: + return str(exp_name) + mu_txt = _format_axis_tick(mu) + if sigma is None: + return f"{exp_name} | mu={mu_txt}" + return f"{exp_name} | mu={mu_txt}, sigma={sigma}" + + +def _plot_sv_bar_comparison( + sv_matrix, + err_matrix, + labels, + basis, + exp_names_ordered, + output_dir, + experiment_meta, +): + """Save publication-style multi-panel bar comparisons across experiments.""" + n = len(exp_names_ordered) + if n == 0: + return + + ncols = min(n, 3) + nrows = int(np.ceil(n / ncols)) + + with matplotlib.rc_context( + { + "font.size": 11, + "axes.labelsize": 11, + "axes.titlesize": 12, + "xtick.labelsize": 10, + "ytick.labelsize": 10, + } + ): + fig, axes = plt.subplots(nrows, ncols, figsize=(6.2 * ncols, 4.4 * nrows)) + axes_flat = np.atleast_1d(axes).ravel() + + for i, (ax, exp_name) in enumerate(zip(axes_flat, exp_names_ordered)): + title = _format_experiment_panel_title( + exp_name, experiment_meta.get(exp_name, {}) + ) + _plot_sv_bar( + sv_matrix[i, :], + labels, + title=title, + sv_err=err_matrix[i, :], + ax=ax, + show_legend=False, + ) + if (i % ncols) != 0: + ax.set_ylabel("") + + for ax in axes_flat[n:]: + ax.set_visible(False) + + fig.suptitle(f"Shapley bar comparison ({basis} basis)", y=0.995) + fig.tight_layout(rect=[0, 0, 1, 0.98]) + + png_path = output_dir / f"shapley_comparison_bars_{basis}.png" + pdf_path = output_dir / f"shapley_comparison_bars_{basis}.pdf" + fig.savefig(png_path, dpi=220, bbox_inches="tight") + fig.savefig(pdf_path, bbox_inches="tight") + plt.close(fig) + print(f"Saved comparison plot: {png_path}") + print(f"Saved comparison plot: {pdf_path}") def _save_comparison_plots(all_experiment_results, output_dir, experiment_meta): - """Save per-basis comparison plots across experiments (with error bars when available).""" + """Save per-basis SV-vs-x and bar-comparison plots across experiments.""" if len(all_experiment_results) < 2: return @@ -229,6 +491,14 @@ def _save_comparison_plots(all_experiment_results, output_dir, experiment_meta): } ) exp_names = list(all_experiment_results.keys()) + axis_info_bins = _resolve_scan_axis( + exp_names, experiment_meta, evenly_spaced_bins=True + ) + axis_info_truex = _resolve_scan_axis( + exp_names, experiment_meta, evenly_spaced_bins=False + ) + order_bins = axis_info_bins["order"] + exp_names_ordered = [exp_names[i] for i in order_bins] for basis in basis_names: labels = None @@ -240,39 +510,58 @@ def _save_comparison_plots(all_experiment_results, output_dir, experiment_meta): continue sv_rows = [] - std_rows = [] + err_rows = [] for exp_name in exp_names: basis_results = all_experiment_results[exp_name].get(basis, {}) sv_map = basis_results.get("shapley_values", {}) - std_map = basis_results.get("shapley_std") or {} + err_map = ( + basis_results.get("shapley_std") + or basis_results.get("shapley_err") + or {} + ) sv_rows.append(np.array([float(sv_map.get(lbl, 0.0)) for lbl in labels])) - std_rows.append( - np.array([float(std_map.get(lbl, 0.0)) for lbl in labels]) - if std_map else None + err_rows.append( + np.array([float(err_map.get(lbl, np.nan)) for lbl in labels]) + if err_map else np.full(len(labels), np.nan) ) - titles = [ - _format_experiment_title(exp_name, experiment_meta.get(exp_name, {})) - for exp_name in exp_names - ] - - n = len(exp_names) - ncols = min(n, 3) - nrows = int(np.ceil(n / ncols)) - fig, axes = plt.subplots(nrows, ncols, figsize=(7 * ncols, 5 * nrows)) - axes_flat = np.atleast_1d(axes).ravel() - - for ax, sv_row, std_row, ttl in zip(axes_flat, sv_rows, std_rows, titles): - _plot_sv_bar(sv_row, labels, title=ttl, sv_err=std_row, ax=ax) - - for ax in axes_flat[n:]: - ax.set_visible(False) - - fig.tight_layout() - out_path = output_dir / f"shapley_comparison_{basis}.png" - fig.savefig(out_path, dpi=150, bbox_inches="tight") - plt.close(fig) - print(f"Saved comparison plot: {out_path}") + sv_matrix_bins = np.asarray(sv_rows, dtype=float)[order_bins, :] + err_matrix_bins = np.asarray(err_rows, dtype=float)[order_bins, :] + _plot_sv_scan_comparison( + sv_matrix=sv_matrix_bins, + err_matrix=err_matrix_bins, + labels=labels, + basis=basis, + output_dir=output_dir, + axis_info=axis_info_bins, + output_stem="shapley_comparison", + title_suffix="binned x, dodged points", + dodge_step_pt=4.5, + use_dodge=True, + ) + order_truex = axis_info_truex["order"] + sv_matrix_truex = np.asarray(sv_rows, dtype=float)[order_truex, :] + err_matrix_truex = np.asarray(err_rows, dtype=float)[order_truex, :] + _plot_sv_scan_comparison( + sv_matrix=sv_matrix_truex, + err_matrix=err_matrix_truex, + labels=labels, + basis=basis, + output_dir=output_dir, + axis_info=axis_info_truex, + output_stem="shapley_comparison_truex", + title_suffix="true x, overlapping", + use_dodge=False, + ) + _plot_sv_bar_comparison( + sv_matrix=sv_matrix_bins, + err_matrix=err_matrix_bins, + labels=labels, + basis=basis, + exp_names_ordered=exp_names_ordered, + output_dir=output_dir, + experiment_meta=experiment_meta, + ) def _save_diagnostic_files(diag, output_dir, basis): From e3db0bfc713b4fbcb11cb7b76903f5cbfa8ee136 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Rapha=C3=ABl=20Bonnet=20Guerrini?= <81559347+rbonnetguerrini@users.noreply.github.com> Date: Fri, 13 Mar 2026 15:12:26 +0100 Subject: [PATCH 12/21] few fixes + read me --- .../validphys/shapley/runcards/gluon/DIS.yaml | 91 +++++++++ .../validphys/shapley/runcards/gluon/DY.yaml | 87 +++++++++ .../validphys/shapley/runcards/gluon/JET.yaml | 89 +++++++++ .../validphys/shapley/runcards/gluon/tt.yaml | 101 ++++++++++ .../shapley/runcards/nnpdf4.0_ablation.yaml | 121 ++++++++++++ .../shapley/runcards/nnpdf4.0_calibrated.yaml | 177 ++++++++++++++++++ ...bal.yaml => nnpdf4.0_calibrated_evol.yaml} | 87 +++++++-- .../validphys/shapley/runcards/sv_dy_lhc.yaml | 40 ---- .../src/validphys/shapley/scripts/README.md | 99 ++++++++++ .../validphys/shapley/scripts/vp_shapley.py | 16 +- .../shapley/slurm/run_vp_shapley.slurm | 4 +- 11 files changed, 848 insertions(+), 64 deletions(-) create mode 100644 validphys2/src/validphys/shapley/runcards/gluon/DIS.yaml create mode 100644 validphys2/src/validphys/shapley/runcards/gluon/DY.yaml create mode 100644 validphys2/src/validphys/shapley/runcards/gluon/JET.yaml create mode 100644 validphys2/src/validphys/shapley/runcards/gluon/tt.yaml create mode 100644 validphys2/src/validphys/shapley/runcards/nnpdf4.0_ablation.yaml create mode 100644 validphys2/src/validphys/shapley/runcards/nnpdf4.0_calibrated.yaml rename validphys2/src/validphys/shapley/runcards/{sv_global.yaml => nnpdf4.0_calibrated_evol.yaml} (75%) delete mode 100644 validphys2/src/validphys/shapley/runcards/sv_dy_lhc.yaml create mode 100644 validphys2/src/validphys/shapley/scripts/README.md diff --git a/validphys2/src/validphys/shapley/runcards/gluon/DIS.yaml b/validphys2/src/validphys/shapley/runcards/gluon/DIS.yaml new file mode 100644 index 0000000000..1e3316c4e0 --- /dev/null +++ b/validphys2/src/validphys/shapley/runcards/gluon/DIS.yaml @@ -0,0 +1,91 @@ +# +# Experiment layout +# ----------------- +# x-scan : 5 log-spaced mu values covering [1e-4, 0.5], alpha=-1.0 +# -> produces phi_j(x) Shapley density on the full global fit +# +# sigma is fixed in log10(x) units (xspace: logx) so the bump width is +# constant in decades across the full x range. + +pdf_name: NNPDF40_nnlo_as_01180 +theory_id: 708 +use_cuts: internal +n_replicas: 100 +output_root: sv_results/gluon +log_root: slurm/logs/gluon +run_name: xscan_dis +per_replica: true +random_sign: true +enforce_sumrules: false +stabilization: + enabled: true + action: exclude_dataset + dataset_delta_chi2_threshold: 1e6 + max_outlier_coalitions: 5 + rerun_stable: true +experiments: + + # --- x-scan + + - name: 1e-4 + basis: [flavor] + perturbation: + mu: 0.0001 + sigma: 0.2 + amplitude: 1.0 + mode: calibrated + xspace: logx + + - name: 1e-3 + basis: [flavor] + perturbation: + mu: 0.001 + sigma: 0.3 + amplitude: 1.0 + mode: calibrated + xspace: logx + + - name: 1e-2 + basis: [flavor] + perturbation: + mu: 0.01 + sigma: 0.3 + amplitude: 1.0 + mode: calibrated + xspace: logx + + - name: 1e-1 + basis: [flavor] + perturbation: + mu: 0.1 + sigma: 0.3 + amplitude: 1.0 + mode: calibrated + xspace: logx + + - name: 5e-1 + basis: [flavor] + perturbation: + mu: 0.5 + sigma: 0.2 + amplitude: 1.0 + mode: calibrated + xspace: logx + - name: 8e-1 + basis: [flavor] + perturbation: + mu: 0.8 + sigma: 0.2 + amplitude: 1.0 + mode: calibrated + xspace: logx + +datasets: + # DIS: HERA combined + - {dataset: HERA_NC_318GEV_EM-SIGMARED, variant: legacy} + - {dataset: HERA_NC_225GEV_EP-SIGMARED, variant: legacy} + - {dataset: HERA_NC_251GEV_EP-SIGMARED, variant: legacy} + - {dataset: HERA_NC_300GEV_EP-SIGMARED, variant: legacy} + - {dataset: HERA_NC_318GEV_EP-SIGMARED, variant: legacy} + - {dataset: HERA_NC_318GEV_EAVG_CHARM-SIGMARED, variant: legacy} + - {dataset: HERA_NC_318GEV_EAVG_BOTTOM-SIGMARED, variant: legacy} diff --git a/validphys2/src/validphys/shapley/runcards/gluon/DY.yaml b/validphys2/src/validphys/shapley/runcards/gluon/DY.yaml new file mode 100644 index 0000000000..14d0b81c2e --- /dev/null +++ b/validphys2/src/validphys/shapley/runcards/gluon/DY.yaml @@ -0,0 +1,87 @@ +# +# Experiment layout +# ----------------- +# x-scan : 5 log-spaced mu values covering [1e-4, 0.5], alpha=-1.0 +# -> produces phi_j(x) Shapley density on the full global fit +# +# sigma is fixed in log10(x) units (xspace: logx) so the bump width is +# constant in decades across the full x range. + +pdf_name: NNPDF40_nnlo_as_01180 +theory_id: 708 +use_cuts: internal +n_replicas: 100 +output_root: sv_results/gluon +log_root: slurm/logs/gluon +run_name: xscan_DY +per_replica: true +random_sign: true +enforce_sumrules: false +stabilization: + enabled: true + action: exclude_dataset + dataset_delta_chi2_threshold: 1e6 + max_outlier_coalitions: 5 + rerun_stable: true +experiments: + + # --- x-scan + + - name: 1e-4 + basis: [flavor] + perturbation: + mu: 0.0001 + sigma: 0.2 + amplitude: 1.0 + mode: calibrated + xspace: logx + + - name: 1e-3 + basis: [flavor] + perturbation: + mu: 0.001 + sigma: 0.3 + amplitude: 1.0 + mode: calibrated + xspace: logx + + - name: 1e-2 + basis: [flavor] + perturbation: + mu: 0.01 + sigma: 0.3 + amplitude: 1.0 + mode: calibrated + xspace: logx + + - name: 1e-1 + basis: [flavor] + perturbation: + mu: 0.1 + sigma: 0.3 + amplitude: 1.0 + mode: calibrated + xspace: logx + + - name: 5e-1 + basis: [flavor] + perturbation: + mu: 0.5 + sigma: 0.2 + amplitude: 1.0 + mode: calibrated + xspace: logx + - name: 8e-1 + basis: [flavor] + perturbation: + mu: 0.8 + sigma: 0.2 + amplitude: 1.0 + mode: calibrated + xspace: logx + +datasets: + - {dataset: DYE866_Z0_800GEV_DW_RATIO_PDXSECRATIO, variant: legacy} + - {dataset: DYE866_Z0_800GEV_PXSEC, variant: legacy} + - {dataset: DYE605_Z0_38P8GEV_DW_PXSEC, variant: legacy} + - {dataset: DYE906_Z0_120GEV_DW_PDXSECRATIO, cfac: [ACC], variant: legacy} \ No newline at end of file diff --git a/validphys2/src/validphys/shapley/runcards/gluon/JET.yaml b/validphys2/src/validphys/shapley/runcards/gluon/JET.yaml new file mode 100644 index 0000000000..87004ca079 --- /dev/null +++ b/validphys2/src/validphys/shapley/runcards/gluon/JET.yaml @@ -0,0 +1,89 @@ +# +# Experiment layout +# ----------------- +# x-scan : 5 log-spaced mu values covering [1e-4, 0.5], alpha=-1.0 +# -> produces phi_j(x) Shapley density on the full global fit +# +# sigma is fixed in log10(x) units (xspace: logx) so the bump width is +# constant in decades across the full x range. + +pdf_name: NNPDF40_nnlo_as_01180 +theory_id: 708 +use_cuts: internal +n_replicas: 100 +output_root: sv_results/gluon +log_root: slurm/logs/gluon +run_name: xscan_jet +per_replica: true +random_sign: true +enforce_sumrules: false +stabilization: + enabled: true + action: exclude_dataset + dataset_delta_chi2_threshold: 1e6 + max_outlier_coalitions: 5 + rerun_stable: true +experiments: + + # --- x-scan + + - name: 1e-4 + basis: [flavor] + perturbation: + mu: 0.0001 + sigma: 0.2 + amplitude: 1.0 + mode: calibrated + xspace: logx + + - name: 1e-3 + basis: [flavor] + perturbation: + mu: 0.001 + sigma: 0.3 + amplitude: 1.0 + mode: calibrated + xspace: logx + + - name: 1e-2 + basis: [flavor] + perturbation: + mu: 0.01 + sigma: 0.3 + amplitude: 1.0 + mode: calibrated + xspace: logx + + - name: 1e-1 + basis: [flavor] + perturbation: + mu: 0.1 + sigma: 0.3 + amplitude: 1.0 + mode: calibrated + xspace: logx + + - name: 5e-1 + basis: [flavor] + perturbation: + mu: 0.5 + sigma: 0.2 + amplitude: 1.0 + mode: calibrated + xspace: logx + - name: 8e-1 + basis: [flavor] + perturbation: + mu: 0.8 + sigma: 0.2 + amplitude: 1.0 + mode: calibrated + xspace: logx + + +datasets: + - {dataset: ATLAS_1JET_8TEV_R06_PTY, variant: legacy_decorrelated} + - {dataset: ATLAS_2JET_7TEV_R06_M12Y, variant: legacy} + - {dataset: CMS_2JET_7TEV_M12-Y, variant: legacy} + - {dataset: CMS_1JET_8TEV_PTY, variant: legacy} + diff --git a/validphys2/src/validphys/shapley/runcards/gluon/tt.yaml b/validphys2/src/validphys/shapley/runcards/gluon/tt.yaml new file mode 100644 index 0000000000..892d7433d6 --- /dev/null +++ b/validphys2/src/validphys/shapley/runcards/gluon/tt.yaml @@ -0,0 +1,101 @@ +# +# Experiment layout +# ----------------- +# x-scan : 5 log-spaced mu values covering [1e-4, 0.5], alpha=-1.0 +# -> produces phi_j(x) Shapley density on the full global fit +# +# sigma is fixed in log10(x) units (xspace: logx) so the bump width is +# constant in decades across the full x range. + +pdf_name: NNPDF40_nnlo_as_01180 +theory_id: 708 +use_cuts: internal +n_replicas: 100 +output_root: sv_results/gluon +log_root: slurm/logs/gluon +run_name: xscan_tt +per_replica: true +random_sign: true +enforce_sumrules: false +stabilization: + enabled: true + action: exclude_dataset + dataset_delta_chi2_threshold: 1e6 + max_outlier_coalitions: 5 + rerun_stable: true +experiments: + + # --- x-scan + + - name: 1e-4 + basis: [flavor] + perturbation: + mu: 0.0001 + sigma: 0.2 + amplitude: 1.0 + mode: calibrated + xspace: logx + + - name: 1e-3 + basis: [flavor] + perturbation: + mu: 0.001 + sigma: 0.3 + amplitude: 1.0 + mode: calibrated + xspace: logx + + - name: 1e-2 + basis: [flavor] + perturbation: + mu: 0.01 + sigma: 0.3 + amplitude: 1.0 + mode: calibrated + xspace: logx + + - name: 1e-1 + basis: [flavor] + perturbation: + mu: 0.1 + sigma: 0.3 + amplitude: 1.0 + mode: calibrated + xspace: logx + + - name: 5e-1 + basis: [flavor] + perturbation: + mu: 0.5 + sigma: 0.2 + amplitude: 1.0 + mode: calibrated + xspace: logx + - name: 8e-1 + basis: [flavor] + perturbation: + mu: 0.8 + sigma: 0.2 + amplitude: 1.0 + mode: calibrated + xspace: logx + + +datasets: + # Top: ttbar total cross-sections + - {dataset: ATLAS_TTBAR_7TEV_TOT_X-SEC, variant: legacy} + - {dataset: ATLAS_TTBAR_8TEV_TOT_X-SEC, variant: legacy} + - {dataset: ATLAS_TTBAR_13TEV_TOT_X-SEC, variant: legacy} + - {dataset: CMS_TTBAR_7TEV_TOT_X-SEC, variant: legacy} + - {dataset: CMS_TTBAR_8TEV_TOT_X-SEC, variant: legacy} + - {dataset: CMS_TTBAR_13TEV_TOT_X-SEC, variant: legacy} + - {dataset: CMS_TTBAR_5TEV_TOT_X-SEC, variant: legacy} + + # Top: ttbar differential + - {dataset: ATLAS_TTBAR_8TEV_LJ_DIF_YT-NORM, variant: legacy} + - {dataset: ATLAS_TTBAR_8TEV_LJ_DIF_YTTBAR-NORM, variant: legacy} + - {dataset: ATLAS_TTBAR_8TEV_2L_DIF_YTTBAR-NORM, variant: legacy} + - {dataset: CMS_TTBAR_8TEV_LJ_DIF_YTTBAR-NORM, variant: legacy} + - {dataset: CMS_TTBAR_8TEV_2L_DIF_MTTBAR-YT-NORM, variant: legacy} + - {dataset: CMS_TTBAR_13TEV_2L_DIF_YT, variant: legacy} + - {dataset: CMS_TTBAR_13TEV_LJ_2016_DIF_YT, variant: legacy} \ No newline at end of file diff --git a/validphys2/src/validphys/shapley/runcards/nnpdf4.0_ablation.yaml b/validphys2/src/validphys/shapley/runcards/nnpdf4.0_ablation.yaml new file mode 100644 index 0000000000..656df1557c --- /dev/null +++ b/validphys2/src/validphys/shapley/runcards/nnpdf4.0_ablation.yaml @@ -0,0 +1,121 @@ +# Shapley value runcard - NNPDF4.0-like global fit, ablation perturbation +# Datasets restricted to NULL and ADD operations only. +# +# Ablation sets flavour channels to zero over all x. This is undefined for +# datasets whose FK operation involves division (ASY, RATIO, COM, SMN): +# zeroing a flavour sends the denominator to zero -> NaN chi2. +# +# Removed from the full 82-dataset list (22 datasets): +# RATIO : NMC_NC_NOTFIXED_EM-F2, DYE866_Z0_800GEV_DW_RATIO_PDXSECRATIO, +# D0_Z0_1P96TEV_ZRAP, +# ATLAS_TTBAR_8TEV_LJ_DIF_YT-NORM, ATLAS_TTBAR_8TEV_LJ_DIF_YTTBAR-NORM, +# ATLAS_TTBAR_8TEV_2L_DIF_YTTBAR-NORM, CMS_TTBAR_8TEV_LJ_DIF_YTTBAR-NORM, +# CMS_TTBAR_8TEV_2L_DIF_MTTBAR-YT-NORM, +# ATLAS_SINGLETOP_7TEV_TCHANNEL-XSEC, ATLAS_SINGLETOP_13TEV_TCHANNEL-XSEC, +# ATLAS_SINGLETOP_7TEV_T-Y-NORM, ATLAS_SINGLETOP_7TEV_TBAR-Y-NORM, +# ATLAS_SINGLETOP_8TEV_T-RAP-NORM, ATLAS_SINGLETOP_8TEV_TBAR-RAP-NORM, +# CMS_SINGLETOP_8TEV_TCHANNEL-XSEC, CMS_SINGLETOP_13TEV_TCHANNEL-XSEC +# ASY : D0_WPWM_1P96TEV_ASY, CMS_WPWM_7TEV_ELECTRON_ASY, CMS_WPWM_7TEV_MUON_ASY +# COM : DYE906_Z0_120GEV_DW_PDXSECRATIO + + +pdf_name: NNPDF40_nnlo_as_01180 +theory_id: 708 +use_cuts: internal +n_replicas: 100 +output_root: sv_results/nnpdf40/ablation +log_root: slurm/logs/nnpdf40/ablation +run_name: ablation_ev + +stabilization: + enabled: true + action: exclude_dataset + dataset_delta_chi2_threshold: 1e6 + max_outlier_coalitions: 5 + rerun_stable: true +experiments: + + - name: ablation + basis: [evolution] + perturbation: + mu: 0.0 # ignored for mode=ablation + sigma: 1.0 # ignored for mode=ablation + amplitude: 1.0 # ignored for mode=ablation + mode: ablation + +datasets: + # DIS: Fixed-target (NMC_NC_NOTFIXED_EM-F2 removed: RATIO) + - {dataset: NMC_NC_NOTFIXED_P_EM-SIGMARED, variant: legacy} + - {dataset: SLAC_NC_NOTFIXED_P_EM-F2, variant: legacy_dw} + - {dataset: SLAC_NC_NOTFIXED_D_EM-F2, variant: legacy_dw} + - {dataset: BCDMS_NC_NOTFIXED_P_EM-F2, variant: legacy_dw} + - {dataset: BCDMS_NC_NOTFIXED_D_EM-F2, variant: legacy_dw} + - {dataset: CHORUS_CC_NOTFIXED_PB_NU-SIGMARED, variant: legacy_dw} + - {dataset: CHORUS_CC_NOTFIXED_PB_NB-SIGMARED, variant: legacy_dw} + - {dataset: NUTEV_CC_NOTFIXED_FE_NU-SIGMARED, cfac: [MAS], variant: legacy_dw} + - {dataset: NUTEV_CC_NOTFIXED_FE_NB-SIGMARED, cfac: [MAS], variant: legacy_dw} + # DIS: HERA combined + - {dataset: HERA_NC_318GEV_EM-SIGMARED, variant: legacy} + - {dataset: HERA_NC_225GEV_EP-SIGMARED, variant: legacy} + - {dataset: HERA_NC_251GEV_EP-SIGMARED, variant: legacy} + - {dataset: HERA_NC_300GEV_EP-SIGMARED, variant: legacy} + - {dataset: HERA_NC_318GEV_EP-SIGMARED, variant: legacy} + - {dataset: HERA_CC_318GEV_EM-SIGMARED, variant: legacy} + - {dataset: HERA_CC_318GEV_EP-SIGMARED, variant: legacy} + - {dataset: HERA_NC_318GEV_EAVG_CHARM-SIGMARED, variant: legacy} + - {dataset: HERA_NC_318GEV_EAVG_BOTTOM-SIGMARED, variant: legacy} + # DY: Fixed-target (RATIO and COM datasets removed) + - {dataset: DYE866_Z0_800GEV_PXSEC, variant: legacy} + - {dataset: DYE605_Z0_38P8GEV_DW_PXSEC, variant: legacy} + # DY: Tevatron (D0_Z0_1P96TEV_ZRAP RATIO, D0_WPWM_1P96TEV_ASY ASY removed) + - {dataset: CDF_Z0_1P96TEV_ZRAP, variant: legacy} + # DY: ATLAS + - {dataset: ATLAS_WPWM_7TEV_36PB_ETA, variant: legacy} + - {dataset: ATLAS_Z0_7TEV_36PB_ETA, variant: legacy} + - {dataset: ATLAS_Z0_7TEV_49FB_HIMASS, variant: legacy} + - {dataset: ATLAS_Z0_7TEV_LOMASS_M, variant: legacy} + - {dataset: ATLAS_WPWM_7TEV_46FB_CC-ETA, variant: legacy} + - {dataset: ATLAS_Z0_7TEV_46FB_CC-Y, variant: legacy} + - {dataset: ATLAS_Z0_7TEV_46FB_CF-Y, variant: legacy} + - {dataset: ATLAS_Z0_8TEV_HIMASS_M-Y, variant: legacy} + - {dataset: ATLAS_Z0_8TEV_LOWMASS_M-Y, variant: legacy} + - {dataset: ATLAS_Z0_13TEV_TOT, cfac: [NRM], variant: legacy} + - {dataset: ATLAS_WPWM_13TEV_TOT, cfac: [NRM], variant: legacy} + - {dataset: ATLAS_WJ_8TEV_WP-PT, variant: legacy} + - {dataset: ATLAS_WJ_8TEV_WM-PT, variant: legacy} + - {dataset: ATLAS_Z0J_8TEV_PT-M, variant: legacy_10} + - {dataset: ATLAS_Z0J_8TEV_PT-Y, variant: legacy_10} + # DY: CMS (ASY datasets removed) + - CMS_Z0_7TEV_DIMUON_2D + - {dataset: CMS_WPWM_8TEV_MUON_Y, variant: legacy} + - {dataset: CMS_Z0J_8TEV_PT-Y, cfac: [NRM], variant: legacy_10} + # DY: LHCb + - LHCB_Z0_7TEV_DIELECTRON_Y + - LHCB_Z0_8TEV_DIELECTRON_Y + - {dataset: LHCB_WPWM_7TEV_MUON_Y, cfac: [NRM]} + - {dataset: LHCB_Z0_7TEV_MUON_Y, cfac: [NRM]} + - {dataset: LHCB_WPWM_8TEV_MUON_Y, cfac: [NRM]} + - {dataset: LHCB_Z0_8TEV_MUON_Y, cfac: [NRM]} + - LHCB_Z0_13TEV_DIMUON-Y + - LHCB_Z0_13TEV_DIELECTRON-Y + # Top: ttbar total cross-sections + - {dataset: ATLAS_TTBAR_7TEV_TOT_X-SEC, variant: legacy} + - {dataset: ATLAS_TTBAR_8TEV_TOT_X-SEC, variant: legacy} + - {dataset: ATLAS_TTBAR_13TEV_TOT_X-SEC, variant: legacy} + - {dataset: CMS_TTBAR_7TEV_TOT_X-SEC, variant: legacy} + - {dataset: CMS_TTBAR_8TEV_TOT_X-SEC, variant: legacy} + - {dataset: CMS_TTBAR_13TEV_TOT_X-SEC, variant: legacy} + - {dataset: CMS_TTBAR_5TEV_TOT_X-SEC, variant: legacy} + # Top: ttbar differential (RATIO/NORM datasets removed, NULL ones kept) + - {dataset: CMS_TTBAR_13TEV_2L_DIF_YT, variant: legacy} + - {dataset: CMS_TTBAR_13TEV_LJ_2016_DIF_YT, variant: legacy} + # Jets + - {dataset: ATLAS_1JET_8TEV_R06_PTY, variant: legacy_decorrelated} + - {dataset: ATLAS_2JET_7TEV_R06_M12Y, variant: legacy} + - {dataset: CMS_2JET_7TEV_M12-Y, variant: legacy} + - {dataset: CMS_1JET_8TEV_PTY, variant: legacy} + # Prompt photon + - {dataset: ATLAS_PH_13TEV_XSEC, cfac: [EWK], variant: legacy} + # Single top (only CMS_7TEV kept: ADD; all others are RATIO) + - {dataset: CMS_SINGLETOP_7TEV_TCHANNEL-XSEC, variant: legacy} + diff --git a/validphys2/src/validphys/shapley/runcards/nnpdf4.0_calibrated.yaml b/validphys2/src/validphys/shapley/runcards/nnpdf4.0_calibrated.yaml new file mode 100644 index 0000000000..9c9f16809e --- /dev/null +++ b/validphys2/src/validphys/shapley/runcards/nnpdf4.0_calibrated.yaml @@ -0,0 +1,177 @@ +# +# Experiment layout +# ----------------- +# x-scan : 5 log-spaced mu values covering [1e-4, 0.5], alpha=-1.0 +# -> produces phi_j(x) Shapley density on the full global fit +# +# sigma is fixed in log10(x) units (xspace: logx) so the bump width is +# constant in decades across the full x range. + +pdf_name: NNPDF40_nnlo_as_01180 +theory_id: 708 +use_cuts: internal +n_replicas: 1 +output_root: sv_results/nnpdf40_calibrated +log_root: slurm/logs/nnpdf40_calibrated +run_name: calibrated_xscan +per_replica: true +random_sign: true +enforce_sumrules: false +stabilization: + enabled: true + action: exclude_dataset + dataset_delta_chi2_threshold: 1e6 + max_outlier_coalitions: 5 + rerun_stable: true +experiments: + + # --- x-scan at alpha=-1.0 (1-sigma shift per flavour) ------------------- + + - name: 1e-4 + basis: [flavor] + perturbation: + mu: 0.0001 + sigma: 0.2 + amplitude: 1.0 + mode: calibrated + xspace: logx + + - name: 1e-3 + basis: [flavor] + perturbation: + mu: 0.001 + sigma: 0.3 + amplitude: 1.0 + mode: calibrated + xspace: logx + + - name: 1e-2 + basis: [flavor] + perturbation: + mu: 0.01 + sigma: 0.3 + amplitude: 1.0 + mode: calibrated + xspace: logx + + - name: 1e-1 + basis: [flavor] + perturbation: + mu: 0.1 + sigma: 0.3 + amplitude: 1.0 + mode: calibrated + xspace: logx + + - name: 5e-1 + basis: [flavor] + perturbation: + mu: 0.5 + sigma: 0.2 + amplitude: 1.0 + mode: calibrated + xspace: logx + - name: 8e-1 + basis: [flavor] + perturbation: + mu: 0.8 + sigma: 0.2 + amplitude: 1.0 + mode: calibrated + xspace: logx + +datasets: + # DIS: Fixed-target + - {dataset: NMC_NC_NOTFIXED_EM-F2, variant: legacy_dw} + - {dataset: NMC_NC_NOTFIXED_P_EM-SIGMARED, variant: legacy} + - {dataset: SLAC_NC_NOTFIXED_P_EM-F2, variant: legacy_dw} + - {dataset: SLAC_NC_NOTFIXED_D_EM-F2, variant: legacy_dw} + - {dataset: BCDMS_NC_NOTFIXED_P_EM-F2, variant: legacy_dw} + - {dataset: BCDMS_NC_NOTFIXED_D_EM-F2, variant: legacy_dw} + - {dataset: CHORUS_CC_NOTFIXED_PB_NU-SIGMARED, variant: legacy_dw} + - {dataset: CHORUS_CC_NOTFIXED_PB_NB-SIGMARED, variant: legacy_dw} + - {dataset: NUTEV_CC_NOTFIXED_FE_NU-SIGMARED, cfac: [MAS], variant: legacy_dw} + - {dataset: NUTEV_CC_NOTFIXED_FE_NB-SIGMARED, cfac: [MAS], variant: legacy_dw} + # DIS: HERA combined + - {dataset: HERA_NC_318GEV_EM-SIGMARED, variant: legacy} + - {dataset: HERA_NC_225GEV_EP-SIGMARED, variant: legacy} + - {dataset: HERA_NC_251GEV_EP-SIGMARED, variant: legacy} + - {dataset: HERA_NC_300GEV_EP-SIGMARED, variant: legacy} + - {dataset: HERA_NC_318GEV_EP-SIGMARED, variant: legacy} + - {dataset: HERA_CC_318GEV_EM-SIGMARED, variant: legacy} + - {dataset: HERA_CC_318GEV_EP-SIGMARED, variant: legacy} + - {dataset: HERA_NC_318GEV_EAVG_CHARM-SIGMARED, variant: legacy} + - {dataset: HERA_NC_318GEV_EAVG_BOTTOM-SIGMARED, variant: legacy} + # DY: Fixed-target + - {dataset: DYE866_Z0_800GEV_DW_RATIO_PDXSECRATIO, variant: legacy} + - {dataset: DYE866_Z0_800GEV_PXSEC, variant: legacy} + - {dataset: DYE605_Z0_38P8GEV_DW_PXSEC, variant: legacy} + - {dataset: DYE906_Z0_120GEV_DW_PDXSECRATIO, cfac: [ACC], variant: legacy} + # DY: Tevatron + - {dataset: CDF_Z0_1P96TEV_ZRAP, variant: legacy} + - {dataset: D0_Z0_1P96TEV_ZRAP, variant: legacy} + - {dataset: D0_WPWM_1P96TEV_ASY, variant: legacy} + # DY: ATLAS + - {dataset: ATLAS_WPWM_7TEV_36PB_ETA, variant: legacy} + - {dataset: ATLAS_Z0_7TEV_36PB_ETA, variant: legacy} + - {dataset: ATLAS_Z0_7TEV_49FB_HIMASS, variant: legacy} + - {dataset: ATLAS_Z0_7TEV_LOMASS_M, variant: legacy} + - {dataset: ATLAS_WPWM_7TEV_46FB_CC-ETA, variant: legacy} + - {dataset: ATLAS_Z0_7TEV_46FB_CC-Y, variant: legacy} + - {dataset: ATLAS_Z0_7TEV_46FB_CF-Y, variant: legacy} + - {dataset: ATLAS_Z0_8TEV_HIMASS_M-Y, variant: legacy} + - {dataset: ATLAS_Z0_8TEV_LOWMASS_M-Y, variant: legacy} + - {dataset: ATLAS_Z0_13TEV_TOT, cfac: [NRM], variant: legacy} + - {dataset: ATLAS_WPWM_13TEV_TOT, cfac: [NRM], variant: legacy} + - {dataset: ATLAS_WJ_8TEV_WP-PT, variant: legacy} + - {dataset: ATLAS_WJ_8TEV_WM-PT, variant: legacy} + - {dataset: ATLAS_Z0J_8TEV_PT-M, variant: legacy_10} + - {dataset: ATLAS_Z0J_8TEV_PT-Y, variant: legacy_10} + # DY: CMS + - CMS_WPWM_7TEV_ELECTRON_ASY + - {dataset: CMS_WPWM_7TEV_MUON_ASY, variant: legacy} + - CMS_Z0_7TEV_DIMUON_2D + - {dataset: CMS_WPWM_8TEV_MUON_Y, variant: legacy} + - {dataset: CMS_Z0J_8TEV_PT-Y, cfac: [NRM], variant: legacy_10} + # DY: LHCb + - LHCB_Z0_7TEV_DIELECTRON_Y + - LHCB_Z0_8TEV_DIELECTRON_Y + - {dataset: LHCB_WPWM_7TEV_MUON_Y, cfac: [NRM]} + - {dataset: LHCB_Z0_7TEV_MUON_Y, cfac: [NRM]} + - {dataset: LHCB_WPWM_8TEV_MUON_Y, cfac: [NRM]} + - {dataset: LHCB_Z0_8TEV_MUON_Y, cfac: [NRM]} + - LHCB_Z0_13TEV_DIMUON-Y + - LHCB_Z0_13TEV_DIELECTRON-Y + # Top: ttbar total cross-sections + - {dataset: ATLAS_TTBAR_7TEV_TOT_X-SEC, variant: legacy} + - {dataset: ATLAS_TTBAR_8TEV_TOT_X-SEC, variant: legacy} + - {dataset: ATLAS_TTBAR_13TEV_TOT_X-SEC, variant: legacy} + - {dataset: CMS_TTBAR_7TEV_TOT_X-SEC, variant: legacy} + - {dataset: CMS_TTBAR_8TEV_TOT_X-SEC, variant: legacy} + - {dataset: CMS_TTBAR_13TEV_TOT_X-SEC, variant: legacy} + - {dataset: CMS_TTBAR_5TEV_TOT_X-SEC, variant: legacy} + # Top: ttbar differential + - {dataset: ATLAS_TTBAR_8TEV_LJ_DIF_YT-NORM, variant: legacy} + - {dataset: ATLAS_TTBAR_8TEV_LJ_DIF_YTTBAR-NORM, variant: legacy} + - {dataset: ATLAS_TTBAR_8TEV_2L_DIF_YTTBAR-NORM, variant: legacy} + - {dataset: CMS_TTBAR_8TEV_LJ_DIF_YTTBAR-NORM, variant: legacy} + - {dataset: CMS_TTBAR_8TEV_2L_DIF_MTTBAR-YT-NORM, variant: legacy} + - {dataset: CMS_TTBAR_13TEV_2L_DIF_YT, variant: legacy} + - {dataset: CMS_TTBAR_13TEV_LJ_2016_DIF_YT, variant: legacy} + # Jets + - {dataset: ATLAS_1JET_8TEV_R06_PTY, variant: legacy_decorrelated} + - {dataset: ATLAS_2JET_7TEV_R06_M12Y, variant: legacy} + - {dataset: CMS_2JET_7TEV_M12-Y, variant: legacy} + - {dataset: CMS_1JET_8TEV_PTY, variant: legacy} + # Prompt photon + - {dataset: ATLAS_PH_13TEV_XSEC, cfac: [EWK], variant: legacy} + # Single top + - {dataset: ATLAS_SINGLETOP_7TEV_TCHANNEL-XSEC, variant: legacy} + - {dataset: ATLAS_SINGLETOP_13TEV_TCHANNEL-XSEC, variant: legacy} + - {dataset: ATLAS_SINGLETOP_7TEV_T-Y-NORM, variant: legacy} + - {dataset: ATLAS_SINGLETOP_7TEV_TBAR-Y-NORM, variant: legacy} + - {dataset: ATLAS_SINGLETOP_8TEV_T-RAP-NORM, variant: legacy} + - {dataset: ATLAS_SINGLETOP_8TEV_TBAR-RAP-NORM, variant: legacy} + - {dataset: CMS_SINGLETOP_7TEV_TCHANNEL-XSEC, variant: legacy} + - {dataset: CMS_SINGLETOP_8TEV_TCHANNEL-XSEC, variant: legacy} + - {dataset: CMS_SINGLETOP_13TEV_TCHANNEL-XSEC, variant: legacy} diff --git a/validphys2/src/validphys/shapley/runcards/sv_global.yaml b/validphys2/src/validphys/shapley/runcards/nnpdf4.0_calibrated_evol.yaml similarity index 75% rename from validphys2/src/validphys/shapley/runcards/sv_global.yaml rename to validphys2/src/validphys/shapley/runcards/nnpdf4.0_calibrated_evol.yaml index f76b5a4aeb..f34e644004 100644 --- a/validphys2/src/validphys/shapley/runcards/sv_global.yaml +++ b/validphys2/src/validphys/shapley/runcards/nnpdf4.0_calibrated_evol.yaml @@ -1,25 +1,84 @@ -# Shapley value runcard - full NNPDF4.0-like global fit -# 82 datasets, both bases. Matches n3fit/runcards/examples/nnpdf40-like.yml - +# +# Experiment layout +# ----------------- +# x-scan : 5 log-spaced mu values covering [1e-4, 0.5], alpha=1.0 +# -> produces phi_j(x) Shapley density on the full global fit +# +# sigma is fixed in log10(x) units (xspace: logx) so the bump width is +# constant in decades across the full x range. pdf_name: NNPDF40_nnlo_as_01180 theory_id: 708 use_cuts: internal n_replicas: 100 -output_root: sv_results/nnpdf40 -log_root: slurm/logs/nnpdf40 -run_name: sv_global - -basis: - - flavor +output_root: sv_results/nnpdf40_calibrated +log_root: slurm/logs/nnpdf40_calibrated +run_name: calibrated_xscan_ev_replica +enforce_sumrules: false +per_replica: true +stabilization: + enabled: true + action: exclude_dataset + dataset_delta_chi2_threshold: 1e6 + max_outlier_coalitions: 5 + rerun_stable: true experiments: - - name: baseline + + # --- x-scan at alpha=1.0 (1-sigma shift per flavour) ------------------- + + - name: 1e-4 + basis: [evolution] + perturbation: + mu: 0.0001 + sigma: 0.2 + amplitude: 1.0 + mode: calibrated + xspace: logx + + - name: 1e-3 + basis: [evolution] + perturbation: + mu: 0.001 + sigma: 0.3 + amplitude: 1.0 + mode: calibrated + xspace: logx + + - name: 1e-2 + basis: [evolution] + perturbation: + mu: 0.01 + sigma: 0.3 + amplitude: 1.0 + mode: calibrated + xspace: logx + + - name: 1e-1 + basis: [evolution] + perturbation: + mu: 0.1 + sigma: 0.3 + amplitude: 1.0 + mode: calibrated + xspace: logx + + - name: 5e-1 + basis: [evolution] + perturbation: + mu: 0.5 + sigma: 0.2 + amplitude: 1.0 + mode: calibrated + xspace: logx + - name: 8e-1 + basis: [evolution] perturbation: - mu: 0.05 - sigma: 0.1 - amplitude: -10 - mode: additive + mu: 0.8 + sigma: 0.2 + amplitude: 1.0 + mode: calibrated + xspace: logx datasets: # DIS: Fixed-target diff --git a/validphys2/src/validphys/shapley/runcards/sv_dy_lhc.yaml b/validphys2/src/validphys/shapley/runcards/sv_dy_lhc.yaml deleted file mode 100644 index 192db57858..0000000000 --- a/validphys2/src/validphys/shapley/runcards/sv_dy_lhc.yaml +++ /dev/null @@ -1,40 +0,0 @@ -# Shapley value runcard Drell-Yan focus (ATLAS + CMS + LHCb) -# Hadronic-only datasets, both bases for comparison. - -pdf_name: NNPDF40_nnlo_as_01180 -theory_id: 708 -use_cuts: internal -n_replicas: 100 -output_root: sv_results/nnpdf40 -log_root: slurm/logs/nnpdf40 -run_name: sv_dy_lhc - -basis: - - evolution - - flavor - -experiments: - - name: baseline - perturbation: - mu: 0.02 - sigma: 0.1 - amplitude: 0.30 - -datasets: - # ATLAS DY - - ATLAS_Z0_7TEV_49FB_HIMASS - - ATLAS_Z0_7TEV_46FB_CC-Y - - ATLAS_WPWM_7TEV_46FB_CC-ETA - - ATLAS_Z0J_8TEV_PT-M - - ATLAS_Z0_8TEV_ZMASS_LL - # CMS DY - - CMS_Z0_7TEV_DIMUON_2D - - CMS_WPWM_7TEV_ELECTRON_ASY - - CMS_WPWM_8TEV_MUON_Y - - CMS_Z0J_8TEV_PT-Y - # LHCb DY - - LHCB_Z0_7TEV_DIELECTRON_Y - - LHCB_WPWM_7TEV_MUON_Y - - LHCB_Z0_8TEV_DIELECTRON_Y - - LHCB_WPWM_8TEV_MUON_Y - - LHCB_Z0_13TEV_DIMUON-Y diff --git a/validphys2/src/validphys/shapley/scripts/README.md b/validphys2/src/validphys/shapley/scripts/README.md new file mode 100644 index 0000000000..bbb824bc87 --- /dev/null +++ b/validphys2/src/validphys/shapley/scripts/README.md @@ -0,0 +1,99 @@ +# vp-shapley + +Compute Shapley values to quantify the relative importance of different PDF regions to global fit quality. This tool analyzes how perturbations in specific kinematic regions affect the chi-squared fit, providing interpretable metrics for feature importance in PDF fits. + +## Installation + +Requires the external `shapley-values` package: + + pip install git+https://github.com/rbonnetguerrini/shapley-values.git@main + +## Quick Start + +Local run (single machine): + + vp-shapley runcards/sv_dis_hera.yaml --output results/my_analysis + +Cluster run with parallelization: + + sbatch --cpus-per-task=64 --export=ALL,N_JOBS=64 \ + /path/to/slurm/run_vp_shapley.slurm \ + /path/to/runcards/gluon/DIS.yaml + +## Usage + + vp-shapley [OPTIONS] + + Options: + --output, -o PATH Output directory (default: sv_results/_) + --n-jobs N Parallel worker threads for coalition evaluation + --diagnostic Write per-coalition chi2 and marginal contribution files + --no-diagnostic Disable diagnostics even if runcard sets diagnostic: true + --outlier-n-sigma FLOAT Z-score threshold for flagging extreme coalitions (default: 3.0) + +## Runcard keys + + pdf_name LHAPDF set name [required] + datasets List of dataset names [required] + experiments List / mapping of experiment configs [required] + name Experiment label + perturbation: + mu Perturbation centre in x + sigma Gaussian width + amplitude Perturbation amplitude + mode additive (default) | multiplicative + xspace linear (default) | logx + theory_id NNPDF theory ID [default: 708] + basis evolution (default) | flavor | list of both + n_replicas Number of PDF replicas [default: 100] + n_jobs Worker threads (overridden by --n-jobs) + enforce_sumrules true | false [default: false] + per_replica Report per-replica SV uncertainty [default: false] + random_sign Flip amplitude sign per replica [default: false] + diagnostic Save coalition-level diagnostics [default: false] + outlier_n_sigma Z-score for outlier flagging [default: 3.0] + stabilization: + enabled [default: true] + action exclude_dataset | report_only + dataset_delta_chi2_threshold[default: 1e4] + max_outlier_coalitions [default: 5] + rerun_stable Re-run after exclusion [default: true] + output_dir Fixed output path (relative to shapley root or absolute) + output_root Root for timestamped output dirs + run_name Label used in output directory name + +## Output (per experiment sub-directory) + +**Main results:** +- `results.json` — Combined Shapley values and metadata +- `shapley_values_.csv` — Mean Shapley value per flavour +- `shapley_bar_.png` — Visualization of feature importance + +**Uncertainties & Stability:** +- `shapley_uncertainties_.csv` — Per-replica uncertainties (if `per_replica: true`) +- `shapley_values__raw.csv` — Pre-stabilization result +- `shapley_values__stable.csv` — Post-exclusion result (if stabilization applied) +- `stabilization_report_.json` — Flagged datasets and exclusion reasoning + +**Diagnostics (with `--diagnostic`):** +- `coalition_chi2_.csv` — Chi-squared per coalition +- `marginal_contributions_.csv` — Marginal value contributions +- `diagnostic_stats_.json` — Statistical summary + +**Multi-experiment output** (when running multiple experiments): + + shapley_comparison_.png/pdf SV vs scan parameter (binned) + shapley_comparison_truex_.png/pdf SV vs scan parameter (true values) + shapley_comparison_bars_.png/pdf Multi-panel bar comparison + experiments_summary.json + +## Interpreting Results + +- **Positive SV**: Region is helpful to fit quality; removing it would increase global chi-squared +- **Negative SV**: Region conflicts with fit; perturbing it actually improves overall fit +- **Large |SV|**: Region is critical for PDF determination +- **Small SV**: Region has minimal impact on fit quality + +## Stabilization + +When enabled, the tool automatically detects and excludes datasets that cause numerical instability (e.g., extreme outlier coalitions). The `stabilization_report_.json` logs which datasets were flagged and why. Disable with `stabilization: {enabled: false}` or inspect flagged datasets before re-running. diff --git a/validphys2/src/validphys/shapley/scripts/vp_shapley.py b/validphys2/src/validphys/shapley/scripts/vp_shapley.py index fd64273238..2baf67ce20 100644 --- a/validphys2/src/validphys/shapley/scripts/vp_shapley.py +++ b/validphys2/src/validphys/shapley/scripts/vp_shapley.py @@ -31,20 +31,20 @@ _MUTED_SERIES_COLORS = [ - "#4C78A8", - "#F58518", - "#54A24B", "#E45756", - "#72B7B2", + "#F58518", "#EECA3B", + "#71BD00", + "#72B7B2", + "#4C78A8", "#B279A2", - "#FF9DA6", "#9D755D", + "#FF9DA6", "#BAB0AC", ] _SERIES_MARKERS = ["o", "s", "D", "^", "v", "P", "X", "<", ">", "h"] -_SOFT_POSITIVE_COLOR = "#7FAF9C" -_SOFT_NEGATIVE_COLOR = "#D8A0A0" +_SOFT_POSITIVE_COLOR = "#518500" +_SOFT_NEGATIVE_COLOR = "#FFBF00" def _plot_sv_bar(sv, labels, title=None, sv_err=None, @@ -428,7 +428,7 @@ def _plot_sv_bar_comparison( output_dir, experiment_meta, ): - """Save publication-style multi-panel bar comparisons across experiments.""" + """Multi-panel bar comparisons across experiments.""" n = len(exp_names_ordered) if n == 0: return diff --git a/validphys2/src/validphys/shapley/slurm/run_vp_shapley.slurm b/validphys2/src/validphys/shapley/slurm/run_vp_shapley.slurm index 2e37dbc1c5..f0e46e3721 100644 --- a/validphys2/src/validphys/shapley/slurm/run_vp_shapley.slurm +++ b/validphys2/src/validphys/shapley/slurm/run_vp_shapley.slurm @@ -3,8 +3,8 @@ #SBATCH --account=inf26_pml4hep_0 #SBATCH --partition=dcgp_usr_prod #SBATCH --time=08:00:00 -#SBATCH --output=/leonardo/home/userexternal/rbonnetg/projects/nnpdf/validphys2/src/validphys/shapley/slurm/slurm-%j.out -#SBATCH --error=/leonardo/home/userexternal/rbonnetg/projects/nnpdf/validphys2/src/validphys/shapley/slurm/slurm-%j.err +#SBATCH --output=/leonardo/home/userexternal/rbonnetg/projects/nnpdf/validphys2/src/validphys/shapley/slurm/logs/slurm-%j.out +#SBATCH --error=/leonardo/home/userexternal/rbonnetg/projects/nnpdf/validphys2/src/validphys/shapley/slurm/logs/slurm-%j.err set -euo pipefail From 3541813251439954ad3f8e9eaac10dee64fc91b5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Rapha=C3=ABl=20Bonnet=20Guerrini?= <81559347+rbonnetguerrini@users.noreply.github.com> Date: Fri, 13 Mar 2026 15:40:23 +0100 Subject: [PATCH 13/21] small fixes --- .../shapley/runcards/gluon/DY_other.yaml | 119 ++++++++++++++++++ .../runcards/gluon/{DY.yaml => DY_pt.yaml} | 14 ++- 2 files changed, 128 insertions(+), 5 deletions(-) create mode 100644 validphys2/src/validphys/shapley/runcards/gluon/DY_other.yaml rename validphys2/src/validphys/shapley/runcards/gluon/{DY.yaml => DY_pt.yaml} (83%) diff --git a/validphys2/src/validphys/shapley/runcards/gluon/DY_other.yaml b/validphys2/src/validphys/shapley/runcards/gluon/DY_other.yaml new file mode 100644 index 0000000000..74bcf7cf89 --- /dev/null +++ b/validphys2/src/validphys/shapley/runcards/gluon/DY_other.yaml @@ -0,0 +1,119 @@ +# +# Experiment layout +# ----------------- +# x-scan : 5 log-spaced mu values covering [1e-4, 0.5], alpha=-1.0 +# -> produces phi_j(x) Shapley density on the full global fit +# +# sigma is fixed in log10(x) units (xspace: logx) so the bump width is +# constant in decades across the full x range. + +pdf_name: NNPDF40_nnlo_as_01180 +theory_id: 708 +use_cuts: internal +n_replicas: 100 +output_root: sv_results/gluon +log_root: slurm/logs/gluon +run_name: xscan_DY_other +per_replica: true +random_sign: true +enforce_sumrules: false +stabilization: + enabled: true + action: exclude_dataset + dataset_delta_chi2_threshold: 1e6 + max_outlier_coalitions: 5 + rerun_stable: true +experiments: + + # --- x-scan + + - name: 1e-4 + basis: [flavor] + perturbation: + mu: 0.0001 + sigma: 0.2 + amplitude: 1.0 + mode: calibrated + xspace: logx + + - name: 1e-3 + basis: [flavor] + perturbation: + mu: 0.001 + sigma: 0.3 + amplitude: 1.0 + mode: calibrated + xspace: logx + + - name: 1e-2 + basis: [flavor] + perturbation: + mu: 0.01 + sigma: 0.3 + amplitude: 1.0 + mode: calibrated + xspace: logx + + - name: 1e-1 + basis: [flavor] + perturbation: + mu: 0.1 + sigma: 0.3 + amplitude: 1.0 + mode: calibrated + xspace: logx + + - name: 5e-1 + basis: [flavor] + perturbation: + mu: 0.5 + sigma: 0.2 + amplitude: 1.0 + mode: calibrated + xspace: logx + - name: 8e-1 + basis: [flavor] + perturbation: + mu: 0.8 + sigma: 0.2 + amplitude: 1.0 + mode: calibrated + xspace: logx + +datasets: + + # DY: Fixed-target + - {dataset: DYE866_Z0_800GEV_DW_RATIO_PDXSECRATIO, variant: legacy} + - {dataset: DYE866_Z0_800GEV_PXSEC, variant: legacy} + - {dataset: DYE605_Z0_38P8GEV_DW_PXSEC, variant: legacy} + - {dataset: DYE906_Z0_120GEV_DW_PDXSECRATIO, cfac: [ACC], variant: legacy} + # DY: Tevatron + - {dataset: CDF_Z0_1P96TEV_ZRAP, variant: legacy} + - {dataset: D0_Z0_1P96TEV_ZRAP, variant: legacy} + - {dataset: D0_WPWM_1P96TEV_ASY, variant: legacy} + # DY: ATLAS + - {dataset: ATLAS_WPWM_7TEV_36PB_ETA, variant: legacy} + - {dataset: ATLAS_Z0_7TEV_36PB_ETA, variant: legacy} + - {dataset: ATLAS_Z0_7TEV_49FB_HIMASS, variant: legacy} + - {dataset: ATLAS_Z0_7TEV_LOMASS_M, variant: legacy} + - {dataset: ATLAS_WPWM_7TEV_46FB_CC-ETA, variant: legacy} + - {dataset: ATLAS_Z0_7TEV_46FB_CC-Y, variant: legacy} + - {dataset: ATLAS_Z0_7TEV_46FB_CF-Y, variant: legacy} + - {dataset: ATLAS_Z0_8TEV_HIMASS_M-Y, variant: legacy} + - {dataset: ATLAS_Z0_8TEV_LOWMASS_M-Y, variant: legacy} + - {dataset: ATLAS_Z0_13TEV_TOT, cfac: [NRM], variant: legacy} + - {dataset: ATLAS_WPWM_13TEV_TOT, cfac: [NRM], variant: legacy} + # DY: CMS + - CMS_WPWM_7TEV_ELECTRON_ASY + - {dataset: CMS_WPWM_7TEV_MUON_ASY, variant: legacy} + - CMS_Z0_7TEV_DIMUON_2D + - {dataset: CMS_WPWM_8TEV_MUON_Y, variant: legacy} + # DY: LHCb + - LHCB_Z0_7TEV_DIELECTRON_Y + - LHCB_Z0_8TEV_DIELECTRON_Y + - {dataset: LHCB_WPWM_7TEV_MUON_Y, cfac: [NRM]} + - {dataset: LHCB_Z0_7TEV_MUON_Y, cfac: [NRM]} + - {dataset: LHCB_WPWM_8TEV_MUON_Y, cfac: [NRM]} + - {dataset: LHCB_Z0_8TEV_MUON_Y, cfac: [NRM]} + - LHCB_Z0_13TEV_DIMUON-Y + - LHCB_Z0_13TEV_DIELECTRON-Y \ No newline at end of file diff --git a/validphys2/src/validphys/shapley/runcards/gluon/DY.yaml b/validphys2/src/validphys/shapley/runcards/gluon/DY_pt.yaml similarity index 83% rename from validphys2/src/validphys/shapley/runcards/gluon/DY.yaml rename to validphys2/src/validphys/shapley/runcards/gluon/DY_pt.yaml index 14d0b81c2e..fc091a2602 100644 --- a/validphys2/src/validphys/shapley/runcards/gluon/DY.yaml +++ b/validphys2/src/validphys/shapley/runcards/gluon/DY_pt.yaml @@ -13,7 +13,7 @@ use_cuts: internal n_replicas: 100 output_root: sv_results/gluon log_root: slurm/logs/gluon -run_name: xscan_DY +run_name: xscan_DY_pt per_replica: true random_sign: true enforce_sumrules: false @@ -81,7 +81,11 @@ experiments: xspace: logx datasets: - - {dataset: DYE866_Z0_800GEV_DW_RATIO_PDXSECRATIO, variant: legacy} - - {dataset: DYE866_Z0_800GEV_PXSEC, variant: legacy} - - {dataset: DYE605_Z0_38P8GEV_DW_PXSEC, variant: legacy} - - {dataset: DYE906_Z0_120GEV_DW_PDXSECRATIO, cfac: [ACC], variant: legacy} \ No newline at end of file + + # DY: ATLAS + - {dataset: ATLAS_WJ_8TEV_WP-PT, variant: legacy} + - {dataset: ATLAS_WJ_8TEV_WM-PT, variant: legacy} + - {dataset: ATLAS_Z0J_8TEV_PT-M, variant: legacy_10} + - {dataset: ATLAS_Z0J_8TEV_PT-Y, variant: legacy_10} + # DY: CMS + - {dataset: CMS_Z0J_8TEV_PT-Y, cfac: [NRM], variant: legacy_10} From ca2590b176045d314827928f0ec3b7a2830b6166 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Rapha=C3=ABl=20Bonnet=20Guerrini?= <81559347+rbonnetguerrini@users.noreply.github.com> Date: Fri, 13 Mar 2026 15:48:54 +0100 Subject: [PATCH 14/21] new runcard sorting --- .../shapley/runcards/{gluon/DIS.yaml => DIS/HERA.yaml} | 0 .../shapley/runcards/{gluon => DY}/DY_other.yaml | 0 .../validphys/shapley/runcards/{gluon => DY}/DY_pt.yaml | 0 .../src/validphys/shapley/runcards/nnpdf4.0_ablation.yaml | 8 ++++---- .../validphys/shapley/runcards/nnpdf4.0_calibrated.yaml | 4 ++-- .../shapley/runcards/nnpdf4.0_calibrated_evol.yaml | 4 ++-- 6 files changed, 8 insertions(+), 8 deletions(-) rename validphys2/src/validphys/shapley/runcards/{gluon/DIS.yaml => DIS/HERA.yaml} (100%) rename validphys2/src/validphys/shapley/runcards/{gluon => DY}/DY_other.yaml (100%) rename validphys2/src/validphys/shapley/runcards/{gluon => DY}/DY_pt.yaml (100%) diff --git a/validphys2/src/validphys/shapley/runcards/gluon/DIS.yaml b/validphys2/src/validphys/shapley/runcards/DIS/HERA.yaml similarity index 100% rename from validphys2/src/validphys/shapley/runcards/gluon/DIS.yaml rename to validphys2/src/validphys/shapley/runcards/DIS/HERA.yaml diff --git a/validphys2/src/validphys/shapley/runcards/gluon/DY_other.yaml b/validphys2/src/validphys/shapley/runcards/DY/DY_other.yaml similarity index 100% rename from validphys2/src/validphys/shapley/runcards/gluon/DY_other.yaml rename to validphys2/src/validphys/shapley/runcards/DY/DY_other.yaml diff --git a/validphys2/src/validphys/shapley/runcards/gluon/DY_pt.yaml b/validphys2/src/validphys/shapley/runcards/DY/DY_pt.yaml similarity index 100% rename from validphys2/src/validphys/shapley/runcards/gluon/DY_pt.yaml rename to validphys2/src/validphys/shapley/runcards/DY/DY_pt.yaml diff --git a/validphys2/src/validphys/shapley/runcards/nnpdf4.0_ablation.yaml b/validphys2/src/validphys/shapley/runcards/nnpdf4.0_ablation.yaml index 656df1557c..67a4f8749d 100644 --- a/validphys2/src/validphys/shapley/runcards/nnpdf4.0_ablation.yaml +++ b/validphys2/src/validphys/shapley/runcards/nnpdf4.0_ablation.yaml @@ -23,9 +23,9 @@ pdf_name: NNPDF40_nnlo_as_01180 theory_id: 708 use_cuts: internal n_replicas: 100 -output_root: sv_results/nnpdf40/ablation -log_root: slurm/logs/nnpdf40/ablation -run_name: ablation_ev +output_root: sv_results/ablation +log_root: slurm/logs/ablation +run_name: flavor stabilization: enabled: true @@ -36,7 +36,7 @@ stabilization: experiments: - name: ablation - basis: [evolution] + basis: [flavor] perturbation: mu: 0.0 # ignored for mode=ablation sigma: 1.0 # ignored for mode=ablation diff --git a/validphys2/src/validphys/shapley/runcards/nnpdf4.0_calibrated.yaml b/validphys2/src/validphys/shapley/runcards/nnpdf4.0_calibrated.yaml index 9c9f16809e..26fc9d622c 100644 --- a/validphys2/src/validphys/shapley/runcards/nnpdf4.0_calibrated.yaml +++ b/validphys2/src/validphys/shapley/runcards/nnpdf4.0_calibrated.yaml @@ -10,12 +10,12 @@ pdf_name: NNPDF40_nnlo_as_01180 theory_id: 708 use_cuts: internal -n_replicas: 1 +n_replicas: 100 output_root: sv_results/nnpdf40_calibrated log_root: slurm/logs/nnpdf40_calibrated run_name: calibrated_xscan per_replica: true -random_sign: true +random_sign: true #turn to false for replica only UQ enforce_sumrules: false stabilization: enabled: true diff --git a/validphys2/src/validphys/shapley/runcards/nnpdf4.0_calibrated_evol.yaml b/validphys2/src/validphys/shapley/runcards/nnpdf4.0_calibrated_evol.yaml index f34e644004..90dc6b78da 100644 --- a/validphys2/src/validphys/shapley/runcards/nnpdf4.0_calibrated_evol.yaml +++ b/validphys2/src/validphys/shapley/runcards/nnpdf4.0_calibrated_evol.yaml @@ -13,10 +13,11 @@ use_cuts: internal n_replicas: 100 output_root: sv_results/nnpdf40_calibrated log_root: slurm/logs/nnpdf40_calibrated -run_name: calibrated_xscan_ev_replica +run_name: calibrated_xscan_ev_ enforce_sumrules: false per_replica: true +random_sign: true stabilization: enabled: true action: exclude_dataset @@ -79,7 +80,6 @@ experiments: amplitude: 1.0 mode: calibrated xspace: logx - datasets: # DIS: Fixed-target - {dataset: NMC_NC_NOTFIXED_EM-F2, variant: legacy_dw} From 8919c2cf59a72f0c98d0e30586442c1e1bba888b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Rapha=C3=ABl=20Bonnet=20Guerrini?= <81559347+rbonnetguerrini@users.noreply.github.com> Date: Fri, 13 Mar 2026 15:50:05 +0100 Subject: [PATCH 15/21] small fixes runcards --- validphys2/src/validphys/shapley/runcards/DIS/HERA.yaml | 4 ++-- validphys2/src/validphys/shapley/runcards/DY/DY_other.yaml | 4 ++-- validphys2/src/validphys/shapley/runcards/DY/DY_pt.yaml | 4 ++-- 3 files changed, 6 insertions(+), 6 deletions(-) diff --git a/validphys2/src/validphys/shapley/runcards/DIS/HERA.yaml b/validphys2/src/validphys/shapley/runcards/DIS/HERA.yaml index 1e3316c4e0..9f6187a65a 100644 --- a/validphys2/src/validphys/shapley/runcards/DIS/HERA.yaml +++ b/validphys2/src/validphys/shapley/runcards/DIS/HERA.yaml @@ -11,8 +11,8 @@ pdf_name: NNPDF40_nnlo_as_01180 theory_id: 708 use_cuts: internal n_replicas: 100 -output_root: sv_results/gluon -log_root: slurm/logs/gluon +output_root: sv_results/DIS +log_root: slurm/logs/DIS run_name: xscan_dis per_replica: true random_sign: true diff --git a/validphys2/src/validphys/shapley/runcards/DY/DY_other.yaml b/validphys2/src/validphys/shapley/runcards/DY/DY_other.yaml index 74bcf7cf89..095834a3d6 100644 --- a/validphys2/src/validphys/shapley/runcards/DY/DY_other.yaml +++ b/validphys2/src/validphys/shapley/runcards/DY/DY_other.yaml @@ -11,8 +11,8 @@ pdf_name: NNPDF40_nnlo_as_01180 theory_id: 708 use_cuts: internal n_replicas: 100 -output_root: sv_results/gluon -log_root: slurm/logs/gluon +output_root: sv_results/DY +log_root: slurm/logs/DY run_name: xscan_DY_other per_replica: true random_sign: true diff --git a/validphys2/src/validphys/shapley/runcards/DY/DY_pt.yaml b/validphys2/src/validphys/shapley/runcards/DY/DY_pt.yaml index fc091a2602..8160274c59 100644 --- a/validphys2/src/validphys/shapley/runcards/DY/DY_pt.yaml +++ b/validphys2/src/validphys/shapley/runcards/DY/DY_pt.yaml @@ -11,8 +11,8 @@ pdf_name: NNPDF40_nnlo_as_01180 theory_id: 708 use_cuts: internal n_replicas: 100 -output_root: sv_results/gluon -log_root: slurm/logs/gluon +output_root: sv_results/DY +log_root: slurm/logs/DY run_name: xscan_DY_pt per_replica: true random_sign: true From 5449120e98178b6d9f51c9fc49fcc8fd0b82aaf6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Rapha=C3=ABl=20Bonnet=20Guerrini?= <81559347+rbonnetguerrini@users.noreply.github.com> Date: Fri, 13 Mar 2026 16:07:01 +0100 Subject: [PATCH 16/21] adding new runcards, + reorganizing them --- .../validphys/shapley/runcards/DIS/HERA.yaml | 2 +- .../shapley/runcards/DIS/NU_fixed.yaml | 88 +++++++++++++++++++ .../src/validphys/shapley/scripts/README.md | 4 +- 3 files changed, 91 insertions(+), 3 deletions(-) create mode 100644 validphys2/src/validphys/shapley/runcards/DIS/NU_fixed.yaml diff --git a/validphys2/src/validphys/shapley/runcards/DIS/HERA.yaml b/validphys2/src/validphys/shapley/runcards/DIS/HERA.yaml index 9f6187a65a..a43258e8b6 100644 --- a/validphys2/src/validphys/shapley/runcards/DIS/HERA.yaml +++ b/validphys2/src/validphys/shapley/runcards/DIS/HERA.yaml @@ -13,7 +13,7 @@ use_cuts: internal n_replicas: 100 output_root: sv_results/DIS log_root: slurm/logs/DIS -run_name: xscan_dis +run_name: xscan_hera per_replica: true random_sign: true enforce_sumrules: false diff --git a/validphys2/src/validphys/shapley/runcards/DIS/NU_fixed.yaml b/validphys2/src/validphys/shapley/runcards/DIS/NU_fixed.yaml new file mode 100644 index 0000000000..c83f458c02 --- /dev/null +++ b/validphys2/src/validphys/shapley/runcards/DIS/NU_fixed.yaml @@ -0,0 +1,88 @@ +# +# Experiment layout +# ----------------- +# x-scan : 5 log-spaced mu values covering [1e-4, 0.5], alpha=-1.0 +# -> produces phi_j(x) Shapley density on the full global fit +# +# sigma is fixed in log10(x) units (xspace: logx) so the bump width is +# constant in decades across the full x range. + +pdf_name: NNPDF40_nnlo_as_01180 +theory_id: 708 +use_cuts: internal +n_replicas: 100 +output_root: sv_results/DIS +log_root: slurm/logs/DIS +run_name: xscan_nu_fixed +per_replica: true +random_sign: true +enforce_sumrules: false +stabilization: + enabled: true + action: exclude_dataset + dataset_delta_chi2_threshold: 1e6 + max_outlier_coalitions: 5 + rerun_stable: true +experiments: + + # --- x-scan + + - name: 1e-4 + basis: [flavor] + perturbation: + mu: 0.0001 + sigma: 0.2 + amplitude: 1.0 + mode: calibrated + xspace: logx + + - name: 1e-3 + basis: [flavor] + perturbation: + mu: 0.001 + sigma: 0.3 + amplitude: 1.0 + mode: calibrated + xspace: logx + + - name: 1e-2 + basis: [flavor] + perturbation: + mu: 0.01 + sigma: 0.3 + amplitude: 1.0 + mode: calibrated + xspace: logx + + - name: 1e-1 + basis: [flavor] + perturbation: + mu: 0.1 + sigma: 0.3 + amplitude: 1.0 + mode: calibrated + xspace: logx + + - name: 5e-1 + basis: [flavor] + perturbation: + mu: 0.5 + sigma: 0.2 + amplitude: 1.0 + mode: calibrated + xspace: logx + - name: 8e-1 + basis: [flavor] + perturbation: + mu: 0.8 + sigma: 0.2 + amplitude: 1.0 + mode: calibrated + xspace: logx + +datasets: + - {dataset: CHORUS_CC_NOTFIXED_PB_NU-SIGMARED, variant: legacy_dw} + - {dataset: CHORUS_CC_NOTFIXED_PB_NB-SIGMARED, variant: legacy_dw} + - {dataset: NUTEV_CC_NOTFIXED_FE_NU-SIGMARED, cfac: [MAS], variant: legacy_dw} + - {dataset: NUTEV_CC_NOTFIXED_FE_NB-SIGMARED, cfac: [MAS], variant: legacy_dw} + diff --git a/validphys2/src/validphys/shapley/scripts/README.md b/validphys2/src/validphys/shapley/scripts/README.md index bbb824bc87..a6ac1adcb7 100644 --- a/validphys2/src/validphys/shapley/scripts/README.md +++ b/validphys2/src/validphys/shapley/scripts/README.md @@ -12,13 +12,13 @@ Requires the external `shapley-values` package: Local run (single machine): - vp-shapley runcards/sv_dis_hera.yaml --output results/my_analysis + vp-shapley runcards/DIS/HERA.yaml --output results/my_analysis Cluster run with parallelization: sbatch --cpus-per-task=64 --export=ALL,N_JOBS=64 \ /path/to/slurm/run_vp_shapley.slurm \ - /path/to/runcards/gluon/DIS.yaml + /path/to/runcards/DIS/HERA.yaml ## Usage From 1c796fb5de2e211406c2c8c97cb1fb7774e2cbf3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Rapha=C3=ABl=20Bonnet=20Guerrini?= <81559347+rbonnetguerrini@users.noreply.github.com> Date: Tue, 24 Mar 2026 16:26:30 +0100 Subject: [PATCH 17/21] New UQ quantification for perturbation. Now set one perturbation mask per SV game --- validphys2/src/validphys/shapley/analyzer.py | 629 ++++++++++++++---- .../src/validphys/shapley/perturbation.py | 47 +- .../validphys/shapley/scripts/vp_shapley.py | 173 +++-- validphys2/src/validphys/shapley/setup.py | 31 +- 4 files changed, 665 insertions(+), 215 deletions(-) diff --git a/validphys2/src/validphys/shapley/analyzer.py b/validphys2/src/validphys/shapley/analyzer.py index 70ffb0dee4..4b36462a86 100644 --- a/validphys2/src/validphys/shapley/analyzer.py +++ b/validphys2/src/validphys/shapley/analyzer.py @@ -18,11 +18,9 @@ import numpy as np import matplotlib.pyplot as plt -import matplotlib.patches as mpatches from validphys.convolution import FK_FLAVOURS from validphys.pdfbases import evolution as evol_basis, ALL_FLAVOURS -from validphys.gridvalues import grid_values as _lhapdf_grid_values from shapley_values import ExactShapley, plot_shapley_bar @@ -83,15 +81,22 @@ class NNPDFShapleyAnalyzer: } def __init__(self, pdf, observables, flavor_info, n_replicas=None, - basis='evolution', enforce_sumrules=False): + basis='evolution', enforce_sumrules=False, + member_mode='replicas'): self.pdf = pdf self.observables = observables self.flavor_info = flavor_info self.n_replicas = n_replicas self.basis = basis self.enforce_sumrules = enforce_sumrules + self.member_mode = str(member_mode).strip().lower() + if self.member_mode not in {"replicas", "central"}: + raise ValueError( + f"Unknown member_mode '{member_mode}'. Use 'replicas' or 'central'." + ) self._gv_cache: dict = {} + self._gv_calib_cache: dict = {} self._gv_cache_lock = threading.Lock() self._sumrule_lock = threading.Lock() @@ -100,6 +105,8 @@ def __init__(self, pdf, observables, flavor_info, n_replicas=None, self._sr_weights = None self._sr_gv_evol = None self._sr_gv_flav = None + self._sr_calib_gv_evol = None + self._sr_calib_gv_flav = None self._sr_rotation = None if basis == 'evolution': @@ -130,21 +137,42 @@ def _setup_sumrule_grid(self): sr_xgrid, sr_weights = gen_integration_input(2000) Q0 = self.observables[0].Q0 - sr_gv_evol = evol_basis.grid_values( - self.pdf, qmat=[Q0], vmat=FK_FLAVOURS, xmat=sr_xgrid - ).squeeze(-1) - if self.n_replicas is not None: - sr_gv_evol = sr_gv_evol[1: self.n_replicas + 1] + sr_gv_evol = get_pdf_grid_values_all14( + self.pdf, + type("SumruleTarget", (), {"Q0": Q0, "xgrid": sr_xgrid})(), + n_replicas=self.n_replicas, + member_mode=self.member_mode, + ) + if self.member_mode == "central": + sr_gv_calib_evol = get_pdf_grid_values_all14( + self.pdf, + type("SumruleTarget", (), {"Q0": Q0, "xgrid": sr_xgrid})(), + n_replicas=self.n_replicas, + member_mode="replicas", + ) + else: + sr_gv_calib_evol = sr_gv_evol sr_gv_flav = None + sr_gv_calib_flav = None sr_rotation = None if self.basis == 'flavor': - sr_gv_flav = _lhapdf_grid_values( - self.pdf, list(ALL_FLAVOURS), sr_xgrid, [Q0] - ).squeeze(-1) - if self.n_replicas is not None: - sr_gv_flav = sr_gv_flav[1: self.n_replicas + 1] + sr_gv_flav = get_pdf_flavor_grid_values( + self.pdf, + type("SumruleTarget", (), {"Q0": Q0, "xgrid": sr_xgrid})(), + n_replicas=self.n_replicas, + member_mode=self.member_mode, + ) + if self.member_mode == "central": + sr_gv_calib_flav = get_pdf_flavor_grid_values( + self.pdf, + type("SumruleTarget", (), {"Q0": Q0, "xgrid": sr_xgrid})(), + n_replicas=self.n_replicas, + member_mode="replicas", + ) + else: + sr_gv_calib_flav = sr_gv_flav evol_row_inds = evol_basis._to_indexes(FK_FLAVOURS) sr_rotation = evol_basis.from_flavour_mat[evol_row_inds, :] @@ -153,10 +181,12 @@ def _setup_sumrule_grid(self): self._sr_weights = sr_weights self._sr_gv_evol = sr_gv_evol self._sr_gv_flav = sr_gv_flav + self._sr_calib_gv_evol = sr_gv_calib_evol + self._sr_calib_gv_flav = sr_gv_calib_flav self._sr_rotation = sr_rotation def _compute_sumrule_norm(self, flavor_subset, mu, sigma, amplitude, - mode, xspace): + mode, xspace, random_sign_matrix=None): """Compute normalization constants for a perturbed coalition.""" ready = ( self._sr_xgrid is not None @@ -190,16 +220,28 @@ def _compute_sumrule_norm(self, flavor_subset, mu, sigma, amplitude, if self.basis == 'evolution': gv = self._sr_gv_evol.copy() perturb_idx = [self.flavor_indices[p] for p in flavor_subset] + perturb_signs = ( + random_sign_matrix[:, flavor_subset] + if random_sign_matrix is not None else None + ) gv_pert = apply_gaussian_perturbation( gv, perturb_idx, mu, sigma, amplitude, - self._sr_xgrid, mode=mode, xspace=xspace + self._sr_xgrid, mode=mode, xspace=xspace, + flavor_signs=perturb_signs, + calibration_gv=self._sr_calib_gv_evol, ) else: gv_flav = self._sr_gv_flav.copy() perturb_idx = [self.flavor_indices[p] for p in flavor_subset] + perturb_signs = ( + random_sign_matrix[:, flavor_subset] + if random_sign_matrix is not None else None + ) gv_flav_pert = apply_gaussian_perturbation( gv_flav, perturb_idx, mu, sigma, amplitude, - self._sr_xgrid, mode=mode, xspace=xspace + self._sr_xgrid, mode=mode, xspace=xspace, + flavor_signs=perturb_signs, + calibration_gv=self._sr_calib_gv_flav, ) gv_pert = np.einsum( 'ef,rfx->rex', self._sr_rotation, gv_flav_pert @@ -220,6 +262,7 @@ def _apply_norm_to_gv(gv, norm, flavor_indices): def clear_cache(self): """Drop cached grid values.""" self._gv_cache.clear() + self._gv_calib_cache.clear() def _get_gv_for_entry(self, obs, entry_idx): """Cached evolution-basis grid values (FK-subset flavours).""" @@ -229,10 +272,24 @@ def _get_gv_for_entry(self, obs, entry_idx): if key not in self._gv_cache: entry = obs.fk_entries[entry_idx] self._gv_cache[key] = get_pdf_grid_values( - self.pdf, entry, n_replicas=self.n_replicas + self.pdf, entry, n_replicas=self.n_replicas, + member_mode=self.member_mode, ) return self._gv_cache[key] + def _get_calibration_gv_for_entry(self, obs, entry_idx): + """Cached evolution-basis replica ensemble used for calibration.""" + key = (obs.name, entry_idx, 'evol_calib') + if key not in self._gv_calib_cache: + with self._gv_cache_lock: + if key not in self._gv_calib_cache: + entry = obs.fk_entries[entry_idx] + self._gv_calib_cache[key] = get_pdf_grid_values( + self.pdf, entry, n_replicas=self.n_replicas, + member_mode='replicas', + ) + return self._gv_calib_cache[key] + def _get_flavor_gv_for_entry(self, obs, entry_idx): """Cached physical flavor-basis grid values.""" key = (obs.name, entry_idx, 'flavor') @@ -241,10 +298,24 @@ def _get_flavor_gv_for_entry(self, obs, entry_idx): if key not in self._gv_cache: entry = obs.fk_entries[entry_idx] self._gv_cache[key] = get_pdf_flavor_grid_values( - self.pdf, entry, n_replicas=self.n_replicas + self.pdf, entry, n_replicas=self.n_replicas, + member_mode=self.member_mode, ) return self._gv_cache[key] + def _get_calibration_flavor_gv_for_entry(self, obs, entry_idx): + """Cached flavor-basis replica ensemble used for calibration.""" + key = (obs.name, entry_idx, 'flavor_calib') + if key not in self._gv_calib_cache: + with self._gv_cache_lock: + if key not in self._gv_calib_cache: + entry = obs.fk_entries[entry_idx] + self._gv_calib_cache[key] = get_pdf_flavor_grid_values( + self.pdf, entry, n_replicas=self.n_replicas, + member_mode='replicas', + ) + return self._gv_calib_cache[key] + def _get_gv_all14_for_entry(self, obs, entry_idx): """Cached full 14-flavour evolution-basis grid values.""" key = (obs.name, entry_idx, 'evol_all14') @@ -253,10 +324,24 @@ def _get_gv_all14_for_entry(self, obs, entry_idx): if key not in self._gv_cache: entry = obs.fk_entries[entry_idx] self._gv_cache[key] = get_pdf_grid_values_all14( - self.pdf, entry, n_replicas=self.n_replicas + self.pdf, entry, n_replicas=self.n_replicas, + member_mode=self.member_mode, ) return self._gv_cache[key] + def _get_calibration_gv_all14_for_entry(self, obs, entry_idx): + """Cached full 14-flavour replica ensemble used for calibration.""" + key = (obs.name, entry_idx, 'evol_all14_calib') + if key not in self._gv_calib_cache: + with self._gv_cache_lock: + if key not in self._gv_calib_cache: + entry = obs.fk_entries[entry_idx] + self._gv_calib_cache[key] = get_pdf_grid_values_all14( + self.pdf, entry, n_replicas=self.n_replicas, + member_mode='replicas', + ) + return self._gv_calib_cache[key] + def _get_gv_list(self, obs): """Get list of baseline grid values for all FK entries.""" result = [] @@ -277,11 +362,89 @@ def _local_flavor_indices_for_entry(self, entry, global_flavor_subset): local.append(fi_list.index(global_fi)) return local + def _local_flavor_indices_and_players_for_entry(self, entry, global_flavor_subset): + """Map global player indices to local FK columns, preserving order.""" + local = [] + players = [] + fi_list = entry.flavor_indices.tolist() + for player in global_flavor_subset: + global_fi = self.flavor_indices[player] + if global_fi in fi_list: + local.append(fi_list.index(global_fi)) + players.append(player) + return local, players + + def _infer_n_members(self): + """Infer the number of PDF members currently loaded by the analyzer.""" + obs0 = self.observables[0] + if self.basis == 'flavor': + return int(self._get_flavor_gv_for_entry(obs0, 0).shape[0]) + + entry0 = obs0.fk_entries[0] + if entry0.hadronic: + return int(self._get_gv_all14_for_entry(obs0, 0).shape[0]) + return int(self._get_gv_for_entry(obs0, 0).shape[0]) + + @staticmethod + def _build_sign_matrices( + n_members, + n_flavors, + n_sign_samples, + random_seed=None, + unique_rows=False, + ): + """Build one or more fixed sign tables for sign-mask sampling. + + Parameters + ---------- + unique_rows : bool + When True and n_sign_samples=1, draw per-member sign masks + without replacement so every member gets a distinct mask. + """ + if int(n_sign_samples) < 1: + raise ValueError(f"n_sign_samples must be >= 1, got {n_sign_samples}") + + rng = np.random.default_rng(random_seed) + n_sign_samples = int(n_sign_samples) + if n_sign_samples == 1: + if unique_rows: + n_unique_max = 2 ** int(n_flavors) + if int(n_members) > n_unique_max: + raise ValueError( + "Requested unique per-member sign masks but n_members " + f"({n_members}) exceeds available unique masks " + f"(2**n_flavors = {n_unique_max})." + ) + + chosen = rng.choice(n_unique_max, size=int(n_members), replace=False) + bit_pos = np.arange(int(n_flavors), dtype=np.int64) + bits = ((chosen[:, None] >> bit_pos[None, :]) & 1).astype(float) + signs = np.where(bits > 0.5, 1.0, -1.0) + return [signs] + + return [ + rng.choice(np.array([-1.0, 1.0]), size=(n_members, n_flavors)) + ] + + if n_sign_samples % 2 != 0: + raise ValueError( + "n_sign_samples must be even when random_sign is enabled " + "and more than one sign sample is requested." + ) + + n_pairs = n_sign_samples // 2 + base = [ + rng.choice(np.array([-1.0, 1.0]), size=(n_members, n_flavors)) + for _ in range(n_pairs) + ] + return base + [-m for m in base] + # -- Chi2 evaluation with perturbation ---------------------------------- def _evaluate_chi2(self, flavor_subset, mu, sigma, amplitude, mode='additive', xspace='linear', - per_replica=False, random_sign=False): + per_replica=False, random_sign=False, + random_sign_matrix=None): """Chi2/Ndata across all observables for a given perturbation. Parameters @@ -296,8 +459,9 @@ def _evaluate_chi2(self, flavor_subset, mu, sigma, amplitude, When True return the per-replica array of shape (nrep,) so that Shapley values can be computed independently for every replica. random_sign : bool - When True the perturbation amplitude is independently randomised - to ±1 for each replica. Forwarded to apply_gaussian_perturbation. + When True use signed perturbations. When ``random_sign_matrix`` is + provided, those fixed replica/flavour signs are reused for all + coalition evaluations in the run. Returns ------- @@ -307,12 +471,14 @@ def _evaluate_chi2(self, flavor_subset, mu, sigma, amplitude, sr_norm = None if self.enforce_sumrules: sr_norm = self._compute_sumrule_norm( - flavor_subset, mu, sigma, amplitude, mode, xspace + flavor_subset, mu, sigma, amplitude, mode, xspace, + random_sign_matrix=random_sign_matrix, ) - # Use a single rng per call so all FK entries of one coalition share - # the same random signs (same coalition = same perturbation direction). - rng = np.random.default_rng() if random_sign else None + rng = ( + np.random.default_rng() + if random_sign and random_sign_matrix is None else None + ) total_chi2 = 0.0 # used when per_replica=False total_chi2_rep = None # used when per_replica=True shape (nrep,) @@ -321,8 +487,14 @@ def _evaluate_chi2(self, flavor_subset, mu, sigma, amplitude, for obs in self.observables: if self.basis == 'flavor': gv_pert_list = [] + perturb_players = list(flavor_subset) + perturb_signs = ( + random_sign_matrix[:, perturb_players] + if random_sign_matrix is not None else None + ) for idx, entry in enumerate(obs.fk_entries): gv_flav = self._get_flavor_gv_for_entry(obs, idx) + gv_flav_calib = self._get_calibration_flavor_gv_for_entry(obs, idx) perturb_idx = [ self.flavor_indices[p] for p in flavor_subset ] @@ -330,6 +502,8 @@ def _evaluate_chi2(self, flavor_subset, mu, sigma, amplitude, gv_flav, perturb_idx, mu, sigma, amplitude, entry.xgrid, mode=mode, xspace=xspace, random_sign=random_sign, rng=rng, + flavor_signs=perturb_signs, + calibration_gv=gv_flav_calib, ) gv_pert_list.append(gv_pert) @@ -351,18 +525,29 @@ def _evaluate_chi2(self, flavor_subset, mu, sigma, amplitude, for idx, entry in enumerate(obs.fk_entries): if entry.hadronic: gv = self._get_gv_all14_for_entry(obs, idx) + gv_calib = self._get_calibration_gv_all14_for_entry(obs, idx) + perturb_players = list(flavor_subset) perturb_idx = [ self.flavor_indices[p] for p in flavor_subset ] else: gv = self._get_gv_for_entry(obs, idx) - perturb_idx = self._local_flavor_indices_for_entry( - entry, flavor_subset + gv_calib = self._get_calibration_gv_for_entry(obs, idx) + perturb_idx, perturb_players = ( + self._local_flavor_indices_and_players_for_entry( + entry, flavor_subset + ) ) + perturb_signs = ( + random_sign_matrix[:, perturb_players] + if random_sign_matrix is not None else None + ) gv_pert = apply_gaussian_perturbation( gv, perturb_idx, mu, sigma, amplitude, entry.xgrid, mode=mode, xspace=xspace, random_sign=random_sign, rng=rng, + flavor_signs=perturb_signs, + calibration_gv=gv_calib, ) if sr_norm is not None: fi = (range(14) if entry.hadronic else entry.flavor_indices) @@ -390,7 +575,8 @@ def _evaluate_chi2(self, flavor_subset, mu, sigma, amplitude, def build_value_function(self, mu, sigma, amplitude, mode='additive', xspace='linear', _coalition_log=None, - random_sign=False): + random_sign=False, + random_sign_matrix=None): """Return a callable v(coalition) -> float for ExactShapley. The wrapper tracks progress: coalition count, elapsed time, and estimated time remaining (ETA). @@ -406,8 +592,10 @@ def build_value_function(self, mu, sigma, amplitude, this list during evaluation. Use this to build the full per-coalition chi2 record for diagnostics. random_sign : bool - Forwarded to _evaluate_chi2. Each call draws fresh signs so - the serial ExactShapley path also benefits. + Forwarded to _evaluate_chi2. + random_sign_matrix : np.ndarray or None + Fixed sign table with shape ``(n_members, n_flavors)`` reused for + every coalition evaluation in the run. Returns ------- @@ -430,6 +618,7 @@ def v(coalition): coalition, mu, sigma, amplitude, mode=mode, xspace=xspace, random_sign=random_sign, + random_sign_matrix=random_sign_matrix, ) # Record coalition -> chi2 for diagnostics if requested. @@ -520,7 +709,7 @@ def _compute_diagnostics(self, coalition_log, outlier_n_sigma=3.0): outlier_coalitions.sort(key=lambda x: -x["chi2"]) # Per-player marginal contribution analysis: - # delta_v(i, S) = v(S ∪ {i}) - v(S) for all S not containing i. + # delta_v(i, S) = v(S U {i}) - v(S) for all S not containing i. per_player_marginals = {} all_marginals = [] # flat list used for the contributions CSV @@ -609,7 +798,8 @@ def _coalition_with_player(coalition, player): def _compute_exact_shap_parallel(self, mu, sigma, amplitude, mode, xspace, n_jobs, verbose=True, - per_replica=False, random_sign=False): + per_replica=False, random_sign=False, + sign_matrices=None): """Compute exact Shapley values from a parallel coalition cache. When per_replica=True every coalition is evaluated independently for @@ -623,6 +813,8 @@ def _compute_exact_shap_parallel(self, mu, sigma, amplitude, mode, xspace, all_coalitions = list(self._iter_all_coalitions()) total_coalitions = len(all_coalitions) value_cache = {} + sign_matrices = [None] if sign_matrices is None else list(sign_matrices) + n_sign_samples = len(sign_matrices) if verbose: print( @@ -636,10 +828,21 @@ def _compute_exact_shap_parallel(self, mu, sigma, amplitude, mode, xspace, log_every = max(1, total_coalitions // 100) def _evaluate_one(coalition): - value = self._evaluate_chi2( - coalition, mu, sigma, amplitude, mode=mode, xspace=xspace, - per_replica=per_replica, random_sign=random_sign, - ) + if n_sign_samples == 1: + value = self._evaluate_chi2( + coalition, mu, sigma, amplitude, mode=mode, xspace=xspace, + per_replica=per_replica, random_sign=random_sign, + random_sign_matrix=sign_matrices[0], + ) + else: + value = np.stack([ + self._evaluate_chi2( + coalition, mu, sigma, amplitude, mode=mode, xspace=xspace, + per_replica=per_replica, random_sign=random_sign, + random_sign_matrix=sign_matrix, + ) + for sign_matrix in sign_matrices + ], axis=0) return coalition, value with ThreadPoolExecutor(max_workers=n_jobs) as executor: @@ -685,44 +888,103 @@ def _evaluate_one(coalition): sys.stderr.flush() baseline_raw = value_cache[tuple()] + mean_value_cache = { + coalition: float(np.mean(value)) + for coalition, value in value_cache.items() + } # per-replica path if per_replica: - # value_cache values are ndarray(nrep,) - nrep = len(next(iter(value_cache.values()))) - baseline = float(np.mean(baseline_raw)) - - # shapley_per_replica[k, j] = phi_j^(k) - shapley_per_replica = np.zeros((nrep, n), dtype=float) - - for player in range(n): - if verbose: - print(f" Player {player}: {self.flavor_labels[player]}", - end="", flush=True) - - for coalition in all_coalitions: - if player in coalition: - continue - s = len(coalition) - weight = ( - factorial[s] * factorial[n - s - 1] - ) / factorial_n - coalition_with_player = self._coalition_with_player( - coalition, player - ) - v_with = value_cache[coalition_with_player] # (nrep,) - v_without = value_cache[coalition] # (nrep,) - shapley_per_replica[:, player] += weight * (v_with - v_without) - - if verbose: - sv_mean = float(np.mean(shapley_per_replica[:, player])) - sv_std = float(np.std(shapley_per_replica[:, player], ddof=1)) - print(f" -> SV = {sv_mean:+.6f} ± {sv_std:.6f}") + first_value = next(iter(value_cache.values())) + if n_sign_samples == 1: + nrep = len(first_value) + baseline = float(np.mean(baseline_raw)) + + # shapley_per_replica[k, j] = phi_j^(k) + shapley_per_replica = np.zeros((nrep, n), dtype=float) + + for player in range(n): + if verbose: + print(f" Player {player}: {self.flavor_labels[player]}", + end="", flush=True) + + for coalition in all_coalitions: + if player in coalition: + continue + s = len(coalition) + weight = ( + factorial[s] * factorial[n - s - 1] + ) / factorial_n + coalition_with_player = self._coalition_with_player( + coalition, player + ) + v_with = value_cache[coalition_with_player] + v_without = value_cache[coalition] + shapley_per_replica[:, player] += weight * (v_with - v_without) + + if verbose: + sv_mean = float(np.mean(shapley_per_replica[:, player])) + sv_std = float(np.std(shapley_per_replica[:, player], ddof=1)) + print(f" -> SV = {sv_mean:+.6f} +/- {sv_std:.6f}") + + shapley_vals = shapley_per_replica.mean(axis=0) + shapley_std = ( + shapley_per_replica.std(axis=0, ddof=1) if nrep > 1 + else np.zeros(n, dtype=float) + ) + shapley_err = shapley_std / np.sqrt(nrep) + shapley_per_sign_sample = None + shapley_sign_std = None + shapley_sign_err = None + else: + nrep = int(first_value.shape[1]) + baseline = float(np.mean(baseline_raw)) + shapley_sample_replica = np.zeros((n_sign_samples, nrep, n), dtype=float) + + for player in range(n): + if verbose: + print(f" Player {player}: {self.flavor_labels[player]}", + end="", flush=True) + + for coalition in all_coalitions: + if player in coalition: + continue + s = len(coalition) + weight = ( + factorial[s] * factorial[n - s - 1] + ) / factorial_n + coalition_with_player = self._coalition_with_player( + coalition, player + ) + v_with = value_cache[coalition_with_player] + v_without = value_cache[coalition] + shapley_sample_replica[:, :, player] += ( + weight * (v_with - v_without) + ) - shapley_vals = shapley_per_replica.mean(axis=0) - shapley_std = shapley_per_replica.std(axis=0, ddof=1) if nrep > 1 \ - else np.zeros(n, dtype=float) - shapley_err = shapley_std / np.sqrt(nrep) + if verbose: + sv_mean = float(np.mean(shapley_sample_replica[:, :, player])) + sv_std = float( + np.std( + shapley_sample_replica.mean(axis=1)[:, player], + ddof=1, + ) + ) if n_sign_samples > 1 else 0.0 + print(f" -> SV = {sv_mean:+.6f} +/- {sv_std:.6f}") + + shapley_per_replica = shapley_sample_replica.mean(axis=0) + shapley_per_sign_sample = shapley_sample_replica.mean(axis=1) + shapley_vals = shapley_per_replica.mean(axis=0) + shapley_std = ( + shapley_per_replica.std(axis=0, ddof=1) if nrep > 1 + else np.zeros(n, dtype=float) + ) + shapley_err = shapley_std / np.sqrt(nrep) + shapley_sign_std = ( + shapley_per_sign_sample.std(axis=0, ddof=1) + if n_sign_samples > 1 else np.zeros(n, dtype=float) + ) + shapley_sign_err = shapley_sign_std / np.sqrt(n_sign_samples) elapsed = time.time() - t0 @@ -733,15 +995,14 @@ def _evaluate_one(coalition): print(f"Max SV std : {np.max(shapley_std):.6f}") print(f"Elapsed : {elapsed:.1f}s") - # Serialize per-replica matrix as list-of-lists for JSON - sv_per_rep_serializable = [ - {str(k): v for k, v in value_cache.items()} - ] return { "shapley_values": shapley_vals, "shapley_values_per_replica": shapley_per_replica, + "shapley_values_per_sign_sample": shapley_per_sign_sample, "shapley_std": shapley_std, "shapley_err": shapley_err, + "shapley_sign_std": shapley_sign_std, + "shapley_sign_err": shapley_sign_err, "baseline": baseline, "baseline_per_replica": baseline_raw, "player_labels": self.flavor_labels, @@ -750,34 +1011,80 @@ def _evaluate_one(coalition): "total_coalitions": total_coalitions, "elapsed_seconds": elapsed, "n_replicas": nrep, + "n_sign_samples": n_sign_samples, + "_mean_value_cache": mean_value_cache, } # scalar (mean-chi2) path - baseline = float(baseline_raw) - shapley_vals = np.zeros(n, dtype=float) + if n_sign_samples == 1: + baseline = float(baseline_raw) + shapley_vals = np.zeros(n, dtype=float) - for player in range(n): - if verbose: - print(f" Player {player}: {self.flavor_labels[player]}", end="", - flush=True) - - for coalition in all_coalitions: - if player in coalition: - continue - - s = len(coalition) - weight = ( - factorial[s] * factorial[n - s - 1] - ) / factorial_n - coalition_with_player = self._coalition_with_player( - coalition, player - ) - v_with = value_cache[coalition_with_player] - v_without = value_cache[coalition] - shapley_vals[player] += weight * (v_with - v_without) + for player in range(n): + if verbose: + print(f" Player {player}: {self.flavor_labels[player]}", end="", + flush=True) - if verbose: - print(f" -> SV = {shapley_vals[player]:+.6f}") + for coalition in all_coalitions: + if player in coalition: + continue + + s = len(coalition) + weight = ( + factorial[s] * factorial[n - s - 1] + ) / factorial_n + coalition_with_player = self._coalition_with_player( + coalition, player + ) + v_with = value_cache[coalition_with_player] + v_without = value_cache[coalition] + shapley_vals[player] += weight * (v_with - v_without) + + if verbose: + print(f" -> SV = {shapley_vals[player]:+.6f}") + + shapley_per_sign_sample = None + shapley_std = None + shapley_err = None + shapley_sign_std = None + shapley_sign_err = None + else: + baseline = float(np.mean(baseline_raw)) + shapley_per_sign_sample = np.zeros((n_sign_samples, n), dtype=float) + + for player in range(n): + if verbose: + print(f" Player {player}: {self.flavor_labels[player]}", end="", + flush=True) + + for coalition in all_coalitions: + if player in coalition: + continue + + s = len(coalition) + weight = ( + factorial[s] * factorial[n - s - 1] + ) / factorial_n + coalition_with_player = self._coalition_with_player( + coalition, player + ) + v_with = value_cache[coalition_with_player] + v_without = value_cache[coalition] + shapley_per_sign_sample[:, player] += weight * (v_with - v_without) + + if verbose: + print( + f" -> SV = {float(np.mean(shapley_per_sign_sample[:, player])):+.6f}" + ) + + shapley_vals = shapley_per_sign_sample.mean(axis=0) + shapley_sign_std = ( + shapley_per_sign_sample.std(axis=0, ddof=1) + if n_sign_samples > 1 else np.zeros(n, dtype=float) + ) + shapley_sign_err = shapley_sign_std / np.sqrt(n_sign_samples) + shapley_std = shapley_sign_std + shapley_err = shapley_sign_err elapsed = time.time() - t0 @@ -792,23 +1099,29 @@ def _evaluate_one(coalition): return { "shapley_values": shapley_vals, "shapley_values_per_replica": None, - "shapley_std": None, - "shapley_err": None, + "shapley_values_per_sign_sample": shapley_per_sign_sample, + "shapley_std": shapley_std, + "shapley_err": shapley_err, + "shapley_sign_std": shapley_sign_std, + "shapley_sign_err": shapley_sign_err, "baseline": baseline, "player_labels": self.flavor_labels, "player_short": self.flavor_short, "coalitions_evaluated": len(value_cache), "total_coalitions": total_coalitions, "elapsed_seconds": elapsed, + "n_sign_samples": n_sign_samples, "value_cache": { str(k): v for k, v in value_cache.items() }, + "_mean_value_cache": mean_value_cache, } def exact_shap(self, mu, sigma, amplitude, mode='additive', xspace='linear', plot=True, n_jobs=1, diagnostic=False, outlier_n_sigma=3.0, - per_replica=False, random_sign=False): + per_replica=False, random_sign=False, + n_sign_samples=1, random_seed=None): """Compute exact Shapley values for all flavour players. Uses the ``shapley_values.ExactShapley`` solver with the NNPDF @@ -834,7 +1147,7 @@ def exact_shap(self, mu, sigma, amplitude, mode='additive', Shapley values. outlier_n_sigma : float Z-score threshold used to flag outlier coalitions/marginals. - Default is 3.0 (mean ± 3σ). + Default is 3.0 (mean +/- 3 sigma). per_replica : bool When True compute phi_j^(k) for every replica k and return the full (nrep, n_flavors) matrix together with the ensemble mean, @@ -842,9 +1155,13 @@ def exact_shap(self, mu, sigma, amplitude, mode='additive', parallel evaluation path (n_jobs>=1). This implements Eq. (shapley_replicas) from the paper. random_sign : bool - When True the perturbation amplitude is independently drawn from - {-1, +1} for each replica at every coalition evaluation, reducing - sensitivity of the Shapley values to the sign of the bump. + When True draw a fixed sign table indexed by replica and flavour, + and reuse it for every coalition evaluation in the run. + n_sign_samples : int + Number of independent sign-table games to average when + ``random_sign=True``. Defaults to 1. + random_seed : int or None + Optional seed for reproducible sign-mask sampling. Returns ------- @@ -860,47 +1177,70 @@ def exact_shap(self, mu, sigma, amplitude, mode='additive', ) if int(n_jobs) < 1: raise ValueError(f"n_jobs must be >= 1, got {n_jobs}") + if int(n_sign_samples) < 1: + raise ValueError(f"n_sign_samples must be >= 1, got {n_sign_samples}") + + effective_n_sign_samples = int(n_sign_samples) + if not random_sign: + effective_n_sign_samples = 1 + elif per_replica: + if effective_n_sign_samples != 1: + print( + "Note: per_replica=True uses one fixed sign mask per replica; " + f"ignoring n_sign_samples={effective_n_sign_samples} and using 1." + ) + effective_n_sign_samples = 1 basis_name = "flavor" if self.basis == 'flavor' else "evolution" print(f"Perturbation basis : {basis_name}") print(f"Perturbation mode : {mode}") print(f"Perturbation xspace: {xspace}") print(f"Sum rules : {'ON' if self.enforce_sumrules else 'OFF'}") + print(f"PDF member mode : {self.member_mode}") print(f"Parallel workers : {int(n_jobs)}") print(f"Per-replica SVs : {'ON' if per_replica else 'OFF'}") print(f"Random sign : {'ON' if random_sign else 'OFF'}") + print(f"Sign samples : {effective_n_sign_samples}") + + sign_matrices = [None] + if random_sign: + sign_matrices = self._build_sign_matrices( + self._infer_n_members(), + self.n_flavors, + n_sign_samples=effective_n_sign_samples, + random_seed=random_seed, + unique_rows=bool(per_replica), + ) # per_replica=True requires vector-valued value function; the external # ExactShapley solver only handles scalars, so always use the parallel # path (which supports both scalar and vector modes). - if per_replica or int(n_jobs) > 1: + if per_replica or int(n_jobs) > 1 or len(sign_matrices) > 1: results = self._compute_exact_shap_parallel( mu, sigma, amplitude, mode, xspace, n_jobs=int(n_jobs), per_replica=per_replica, random_sign=random_sign, + sign_matrices=sign_matrices, ) # Build coalition_log for diagnostics from _compute_exact_shap_parallel # (the parallel path does not produce a coalition_log internally; # re-run with diagnostics via the scalar path below if requested). coalition_log = None if diagnostic: - # Re-evaluate all coalitions through the serial value function - # (scalar, mean-chi2) to collect the log for the diagnostic. - coalition_log = [] - v_diag = self.build_value_function( - mu, sigma, amplitude, mode, xspace, - _coalition_log=coalition_log, - random_sign=random_sign, - ) - for coalition in self._iter_all_coalitions(): - v_diag(list(coalition)) + mean_value_cache = results.get("_mean_value_cache", {}) + coalition_log = [ + (coalition, mean_value_cache[coalition]) + for coalition in self._iter_all_coalitions() + if coalition in mean_value_cache + ] else: coalition_log = [] if diagnostic else None v = self.build_value_function( mu, sigma, amplitude, mode, xspace, _coalition_log=coalition_log, random_sign=random_sign, + random_sign_matrix=sign_matrices[0], ) solver = ExactShapley( n_players=self.n_flavors, @@ -931,7 +1271,7 @@ def exact_shap(self, mu, sigma, amplitude, mode='additive', f"max={cs.get('max', 0):.4f}" ) print( - f" Outlier threshold ({outlier_n_sigma}σ): " + f" Outlier threshold ({outlier_n_sigma} sigma): " f"{diag.get('outlier_chi2_threshold', 0):.4f} " f"({diag.get('n_outlier_coalitions', 0)} outlier coalitions)" ) @@ -966,6 +1306,11 @@ def exact_shap(self, mu, sigma, amplitude, mode='additive', results["n_jobs"] = int(n_jobs) results["per_replica"] = bool(per_replica) results["random_sign"] = bool(random_sign) + results["member_mode"] = self.member_mode + results["n_sign_samples"] = int(effective_n_sign_samples) + results["antithetic_sign"] = bool(random_sign and effective_n_sign_samples > 1) + results["random_seed"] = random_seed + results["_sign_matrices"] = sign_matrices if random_sign else None # Convenience: scalar uncertainty arrays (None when per_replica=False) # shapley_std[j] = std_k phi_j^(k) (replica-to-replica spread) # shapley_err[j] = shapley_std[j] / sqrt(nrep) (standard error of mean) @@ -973,6 +1318,13 @@ def exact_shap(self, mu, sigma, amplitude, mode='additive', results["shapley_std"] = None if results.get("shapley_err") is None: results["shapley_err"] = None + if results.get("shapley_values_per_sign_sample") is None: + results["shapley_values_per_sign_sample"] = None + if results.get("shapley_sign_std") is None: + results["shapley_sign_std"] = None + if results.get("shapley_sign_err") is None: + results["shapley_sign_err"] = None + results.pop("_mean_value_cache", None) # Plot fig_pdfs = None @@ -1049,20 +1401,38 @@ def plot_pdfs(self, amplitude=0.08, mu=0.02, sigma=0.1, x_axis_scale = "linear" if float(mu) > 0.1 else "log" Q0 = self.observables[0].Q0 + class PlotTarget: + pass + + plot_target = PlotTarget() + plot_target.Q0 = Q0 + plot_target.xgrid = x_plot + plot_target.flavor_indices = np.asarray(self.flavor_indices) + if self.basis == 'flavor': - pdg_codes = [int(ALL_FLAVOURS[i]) for i in self.flavor_indices] - gv_ref = _lhapdf_grid_values( - self.pdf, pdg_codes, x_plot, [Q0] - ).squeeze(-1) + gv_ref_all = get_pdf_flavor_grid_values( + self.pdf, plot_target, n_replicas=self.n_replicas, + member_mode=self.member_mode, + ) + gv_calib_all = get_pdf_flavor_grid_values( + self.pdf, plot_target, n_replicas=self.n_replicas, + member_mode='replicas', + ) + # get_pdf_flavor_grid_values returns all 14 PDG flavours in + # ALL_FLAVOURS order. Shapley players are a subset given by + # self.flavor_indices (indices into that 14-flavour axis). + sel = np.asarray(self.flavor_indices, dtype=int) + gv_ref = gv_ref_all[:, sel, :] + gv_calib = gv_calib_all[:, sel, :] else: - gv_func = functools.partial(evol_basis.grid_values, self.pdf) - all_names = FK_FLAVOURS[self.flavor_indices] - gv_ref = gv_func( - qmat=[Q0], vmat=all_names, xmat=x_plot - ).squeeze(-1) - - if self.n_replicas is not None: - gv_ref = gv_ref[1: self.n_replicas + 1] + gv_ref = get_pdf_grid_values( + self.pdf, plot_target, n_replicas=self.n_replicas, + member_mode=self.member_mode, + ) + gv_calib = get_pdf_grid_values( + self.pdf, plot_target, n_replicas=self.n_replicas, + member_mode='replicas', + ) gv_pert = apply_gaussian_perturbation( gv_ref, @@ -1073,6 +1443,7 @@ def plot_pdfs(self, amplitude=0.08, mu=0.02, sigma=0.1, xgrid=x_plot, mode=mode, xspace=xspace, + calibration_gv=gv_calib, ) n = len(self.flavor_short) diff --git a/validphys2/src/validphys/shapley/perturbation.py b/validphys2/src/validphys/shapley/perturbation.py index 88fc08aff1..9c94bff2ed 100644 --- a/validphys2/src/validphys/shapley/perturbation.py +++ b/validphys2/src/validphys/shapley/perturbation.py @@ -63,7 +63,8 @@ def gaussian_profile(xgrid, mu, sigma, amplitude, xspace='linear'): def apply_gaussian_perturbation(gv, local_flavor_idx, mu, sigma, amplitude, xgrid, mode='additive', xspace='linear', - random_sign=False, rng=None): + random_sign=False, rng=None, + flavor_signs=None, calibration_gv=None): """Perturb selected flavour channels with a Gaussian bump. Parameters @@ -88,13 +89,19 @@ def apply_gaussian_perturbation(gv, local_flavor_idx, mu, sigma, amplitude, 'linear' or 'logx' (ignored for mode='ablation') random_sign : bool When True the Gaussian amplitude is independently flipped to +1 or -1 - for each replica (drawn uniformly from {-1, +1}). This decorrelates - the direction of the perturbation across the Monte Carlo ensemble, - reducing sensitivity to the sign convention of the bump. + for each replica/flavour pair (drawn uniformly from {-1, +1}). Ignored for mode='ablation'. rng : numpy.random.Generator or None Optional random-number generator for reproducibility. When None a fresh, non-seeded generator is created per call. + flavor_signs : np.ndarray or None + Optional explicit sign matrix with shape ``(nrep, n_selected_flavours)`` + matching ``local_flavor_idx`` order. When provided, these fixed signs + override the internal random-sign draw. + calibration_gv : np.ndarray or None + Optional grid-value ensemble used only to determine the calibrated + per-flavour replica spread. Useful when the evaluated members differ + from the replica ensemble, e.g. central-only runs. Returns ------- @@ -128,28 +135,44 @@ def apply_gaussian_perturbation(gv, local_flavor_idx, mu, sigma, amplitude, gv_pert[:, fi, :] = 0.0 return gv_pert # positivity trivially satisfied; skip clipping - # Per-replica sign vector: shape (nrep, 1) for broadcasting over nx. - if random_sign: + # Sign matrix: one sign per replica/flavour pair for the selected flavours. + if flavor_signs is not None: + sign_matrix = np.asarray(flavor_signs, dtype=float) + if sign_matrix.ndim == 1: + sign_matrix = sign_matrix[:, np.newaxis] + expected_shape = (nrep, len(local_flavor_idx)) + if sign_matrix.shape != expected_shape: + raise ValueError( + "flavor_signs must have shape " + f"{expected_shape}, got {sign_matrix.shape}." + ) + elif random_sign: _rng = rng if rng is not None else np.random.default_rng() - signs = _rng.choice(np.array([-1.0, 1.0]), size=nrep)[:, np.newaxis] + sign_matrix = _rng.choice( + np.array([-1.0, 1.0]), size=(nrep, len(local_flavor_idx)) + ) else: - signs = np.ones((nrep, 1), dtype=float) + sign_matrix = np.ones((nrep, len(local_flavor_idx)), dtype=float) if mode == 'calibrated': # Per-flavor amplitude: alpha * replica std at x closest to mu. xgrid_arr = np.asarray(xgrid) idx_mu = int(np.argmin(np.abs(xgrid_arr - mu))) - for fi in local_flavor_idx: - sigma_rep = float(gv[:, fi, idx_mu].std()) + gv_sigma = gv if calibration_gv is None else np.asarray(calibration_gv, dtype=float) + for col, fi in enumerate(local_flavor_idx): + sigma_rep = float(gv_sigma[:, fi, idx_mu].std()) gauss = gaussian_profile(xgrid, mu, sigma, amplitude * sigma_rep, xspace) + signs = sign_matrix[:, col][:, np.newaxis] gv_pert[:, fi, :] += signs * gauss[np.newaxis, :] elif mode == 'additive': gauss = gaussian_profile(xgrid, mu, sigma, amplitude, xspace) - for fi in local_flavor_idx: + for col, fi in enumerate(local_flavor_idx): + signs = sign_matrix[:, col][:, np.newaxis] gv_pert[:, fi, :] += signs * gauss[np.newaxis, :] else: # multiplicative gauss = gaussian_profile(xgrid, mu, sigma, amplitude, xspace) - for fi in local_flavor_idx: + for col, fi in enumerate(local_flavor_idx): + signs = sign_matrix[:, col][:, np.newaxis] gv_pert[:, fi, :] *= (1.0 + signs * gauss[np.newaxis, :]) # Enforce positivity only on perturbed channels and only when the perturbation would drive a previously non-negative point below zero. diff --git a/validphys2/src/validphys/shapley/scripts/vp_shapley.py b/validphys2/src/validphys/shapley/scripts/vp_shapley.py index 2baf67ce20..8d26c22047 100644 --- a/validphys2/src/validphys/shapley/scripts/vp_shapley.py +++ b/validphys2/src/validphys/shapley/scripts/vp_shapley.py @@ -195,6 +195,8 @@ def _normalize_experiments(cfg): "n_jobs", "enforce_sumrules", "n_replicas", + "n_sign_samples", + "random_seed", "run_name", "stabilization", ]: @@ -582,7 +584,7 @@ def _save_diagnostic_files(diag, output_dir, basis): """ import copy - # ── coalition_chi2 CSV ───────────────────────────────────────────────── + # -- coalition_chi2 CSV ------------------------------------------------- outlier_threshold = diag.get("outlier_chi2_threshold", float("inf")) outlier_set = { tuple(oc["coalition"]) for oc in diag.get("outlier_coalitions", []) @@ -620,7 +622,7 @@ def _save_diagnostic_files(diag, output_dir, basis): f.write(f"{labels_str},{len(coal)},{chi2:.8f},{is_out}\n") print(f"Saved: {coalition_csv_path}") - # ── marginal_contributions CSV ───────────────────────────────────────── + # -- marginal_contributions CSV ----------------------------------------- contrib_csv_path = output_dir / f"marginal_contributions_{basis}.csv" with open(contrib_csv_path, "w") as f: f.write("player,coalition_without,v_without,v_with,delta_v,is_outlier\n") @@ -635,7 +637,7 @@ def _save_diagnostic_files(diag, output_dir, basis): ) print(f"Saved: {contrib_csv_path}") - # ── diagnostic_stats JSON ───────────────────────────────────────────── + # -- diagnostic_stats JSON ---------------------------------------------- # Strip the internal key before serialising. diag_public = {k: v for k, v in diag.items() if k != "_marginal_contributions"} stats_path = output_dir / f"diagnostic_stats_{basis}.json" @@ -682,81 +684,104 @@ def _resolve_stabilization_cfg(cfg): } -def _dataset_mean_chi2_for_coalition(analyzer, coalition, pert): +def _dataset_mean_chi2_for_coalition(analyzer, coalition, pert, sign_matrices=None): """Compute per-dataset mean chi2 for a single coalition.""" mu = pert["mu"] sigma = pert["sigma"] amplitude = pert["amplitude"] mode = pert.get("mode", "additive") xspace = pert.get("xspace", "linear") - - sr_norm = None - if analyzer.enforce_sumrules: - sr_norm = analyzer._compute_sumrule_norm( - coalition, mu, sigma, amplitude, mode, xspace - ) + sign_matrices = [None] if sign_matrices is None else list(sign_matrices) rows = [] for obs in analyzer.observables: - if analyzer.basis == "flavor": - gv_pert_list = [] - perturb_idx = [analyzer.flavor_indices[p] for p in coalition] - for idx, entry in enumerate(obs.fk_entries): - gv_flav = analyzer._get_flavor_gv_for_entry(obs, idx) - gv_pert = apply_gaussian_perturbation( - gv_flav, - perturb_idx, - mu, - sigma, - amplitude, - entry.xgrid, - mode=mode, - xspace=xspace, + mean_samples = [] + for sign_matrix in sign_matrices: + sr_norm = None + if analyzer.enforce_sumrules: + sr_norm = analyzer._compute_sumrule_norm( + coalition, mu, sigma, amplitude, mode, xspace, + random_sign_matrix=sign_matrix, ) - gv_pert_list.append(gv_pert) - if sr_norm is not None: - gv_evol_list = obs.rotate_to_evolution(gv_pert_list) - gv_evol_list = [ - analyzer._apply_norm_to_gv( - gv, - sr_norm, - range(14) if entry.hadronic else entry.flavor_indices, + if analyzer.basis == "flavor": + gv_pert_list = [] + perturb_idx = [analyzer.flavor_indices[p] for p in coalition] + perturb_signs = ( + sign_matrix[:, coalition] if sign_matrix is not None else None + ) + for idx, entry in enumerate(obs.fk_entries): + gv_flav = analyzer._get_flavor_gv_for_entry(obs, idx) + gv_flav_calib = analyzer._get_calibration_flavor_gv_for_entry(obs, idx) + gv_pert = apply_gaussian_perturbation( + gv_flav, + perturb_idx, + mu, + sigma, + amplitude, + entry.xgrid, + mode=mode, + xspace=xspace, + flavor_signs=perturb_signs, + calibration_gv=gv_flav_calib, ) - for gv, entry in zip(gv_evol_list, obs.fk_entries) - ] - chi2_arr = obs.chi2(gv_evol_list) - else: - chi2_arr = obs.chi2_from_flavor(gv_pert_list) - else: - gv_pert_list = [] - for idx, entry in enumerate(obs.fk_entries): - if entry.hadronic: - gv = analyzer._get_gv_all14_for_entry(obs, idx) - perturb_idx = [analyzer.flavor_indices[p] for p in coalition] + gv_pert_list.append(gv_pert) + + if sr_norm is not None: + gv_evol_list = obs.rotate_to_evolution(gv_pert_list) + gv_evol_list = [ + analyzer._apply_norm_to_gv( + gv, + sr_norm, + range(14) if entry.hadronic else entry.flavor_indices, + ) + for gv, entry in zip(gv_evol_list, obs.fk_entries) + ] + chi2_arr = obs.chi2(gv_evol_list) else: - gv = analyzer._get_gv_for_entry(obs, idx) - perturb_idx = analyzer._local_flavor_indices_for_entry( - entry, coalition + chi2_arr = obs.chi2_from_flavor(gv_pert_list) + else: + gv_pert_list = [] + for idx, entry in enumerate(obs.fk_entries): + if entry.hadronic: + gv = analyzer._get_gv_all14_for_entry(obs, idx) + gv_calib = analyzer._get_calibration_gv_all14_for_entry(obs, idx) + perturb_players = list(coalition) + perturb_idx = [analyzer.flavor_indices[p] for p in coalition] + else: + gv = analyzer._get_gv_for_entry(obs, idx) + gv_calib = analyzer._get_calibration_gv_for_entry(obs, idx) + perturb_idx, perturb_players = ( + analyzer._local_flavor_indices_and_players_for_entry( + entry, coalition + ) + ) + perturb_signs = ( + sign_matrix[:, perturb_players] + if sign_matrix is not None else None ) - gv_pert = apply_gaussian_perturbation( - gv, - perturb_idx, - mu, - sigma, - amplitude, - entry.xgrid, - mode=mode, - xspace=xspace, - ) - if sr_norm is not None: - fi = range(14) if entry.hadronic else entry.flavor_indices - gv_pert = analyzer._apply_norm_to_gv(gv_pert, sr_norm, fi) - gv_pert_list.append(gv_pert) - chi2_arr = obs.chi2(gv_pert_list) + gv_pert = apply_gaussian_perturbation( + gv, + perturb_idx, + mu, + sigma, + amplitude, + entry.xgrid, + mode=mode, + xspace=xspace, + flavor_signs=perturb_signs, + calibration_gv=gv_calib, + ) + if sr_norm is not None: + fi = range(14) if entry.hadronic else entry.flavor_indices + gv_pert = analyzer._apply_norm_to_gv(gv_pert, sr_norm, fi) + gv_pert_list.append(gv_pert) + chi2_arr = obs.chi2(gv_pert_list) - mean_chi2 = float(np.mean(chi2_arr)) + mean_samples.append(float(np.mean(chi2_arr))) + + mean_chi2 = float(np.mean(mean_samples)) rows.append( { "dataset": obs.name, @@ -980,6 +1005,7 @@ def run_analysis(cfg, output_dir, setup_context, n_jobs_override=None, n_replicas=n_replicas, basis=basis, enforce_sumrules=enforce_sumrules, + member_mode=member_mode, ) t0 = time.time() @@ -998,6 +1024,8 @@ def run_analysis(cfg, output_dir, setup_context, n_jobs_override=None, mode=mode, xspace=xspace, plot=True, n_jobs=n_jobs, diagnostic=raw_diagnostic, outlier_n_sigma=diag_sigma, per_replica=per_replica, random_sign=random_sign, + n_sign_samples=n_sign_samples, + random_seed=random_seed, ) stabilization_report = None stabilization_json = None @@ -1038,12 +1066,15 @@ def run_analysis(cfg, output_dir, setup_context, n_jobs_override=None, n_replicas=n_replicas, basis=basis, enforce_sumrules=enforce_sumrules, + member_mode=member_mode, ) results_final = stable_analyzer.exact_shap( mu=mu, sigma=sigma, amplitude=amplitude, mode=mode, xspace=xspace, plot=True, n_jobs=n_jobs, diagnostic=diagnostic, outlier_n_sigma=diag_sigma, per_replica=per_replica, random_sign=random_sign, + n_sign_samples=n_sign_samples, + random_seed=random_seed, ) stable_rerun_performed = True observables_used = kept @@ -1114,8 +1145,22 @@ def run_analysis(cfg, output_dir, setup_context, n_jobs_override=None, {l: float(v) for l, v in zip(labels, sv_err)} if sv_err is not None else None ), + "shapley_sign_std": ( + {l: float(v) for l, v in zip(labels, sv_sign_std)} + if sv_sign_std is not None else None + ), + "shapley_sign_err": ( + {l: float(v) for l, v in zip(labels, sv_sign_err)} + if sv_sign_err is not None else None + ), "per_replica": per_replica, "random_sign": random_sign, + "member_mode": member_mode, + "n_sign_samples": int(results_final.get("n_sign_samples", n_sign_samples)), + "antithetic_sign": bool( + results_final.get("random_sign") and results_final.get("n_sign_samples", 1) > 1 + ), + "random_seed": random_seed, "baseline_chi2": float(results_final["baseline_chi2"]), "coalitions_evaluated": results_final["coalitions_evaluated"], "elapsed_seconds": round(elapsed, 1), @@ -1146,6 +1191,10 @@ def run_analysis(cfg, output_dir, setup_context, n_jobs_override=None, "mode": mode, "xspace": xspace, "per_replica": per_replica, "random_sign": random_sign, + "member_mode": member_mode, + "n_sign_samples": int(n_sign_samples), + "antithetic_sign": bool(random_sign and int(n_sign_samples) > 1), + "random_seed": random_seed, }, "enforce_sumrules": enforce_sumrules, "n_jobs": int(n_jobs), diff --git a/validphys2/src/validphys/shapley/setup.py b/validphys2/src/validphys/shapley/setup.py index d6c783c993..7c79daba05 100644 --- a/validphys2/src/validphys/shapley/setup.py +++ b/validphys2/src/validphys/shapley/setup.py @@ -464,7 +464,20 @@ def setup_observables( # Grid-value evaluation # --------------------------------------------------------------------------- -def get_pdf_grid_values(pdf, target, n_replicas=None): +def _select_pdf_members(gv, n_replicas=None, member_mode="replicas"): + """Select either replica members or the central member from a PDF grid.""" + if member_mode == "central": + return gv[:1] + if member_mode != "replicas": + raise ValueError( + f"Unknown member_mode '{member_mode}'. Choose from ('replicas', 'central')." + ) + if n_replicas is not None: + return gv[1: n_replicas + 1] + return gv + + +def get_pdf_grid_values(pdf, target, n_replicas=None, member_mode="replicas"): """Evaluate PDF in evolution basis (FK-subset flavours only). Returns shape (nrep, nfl_used, nx). @@ -474,12 +487,10 @@ def get_pdf_grid_values(pdf, target, n_replicas=None): gv = gv_func( qmat=[target.Q0], vmat=flavour_names, xmat=target.xgrid ).squeeze(-1) - if n_replicas is not None: - gv = gv[1: n_replicas + 1] - return gv + return _select_pdf_members(gv, n_replicas=n_replicas, member_mode=member_mode) -def get_pdf_flavor_grid_values(pdf, target, n_replicas=None): +def get_pdf_flavor_grid_values(pdf, target, n_replicas=None, member_mode="replicas"): """Evaluate PDF in physical flavor basis (all 14 PDG codes). Returns shape (nrep, 14, nx). @@ -488,12 +499,10 @@ def get_pdf_flavor_grid_values(pdf, target, n_replicas=None): gv = _lhapdf_grid_values( pdf, pdg_codes, target.xgrid, [target.Q0] ).squeeze(-1) - if n_replicas is not None: - gv = gv[1: n_replicas + 1] - return gv + return _select_pdf_members(gv, n_replicas=n_replicas, member_mode=member_mode) -def get_pdf_grid_values_all14(pdf, target, n_replicas=None): +def get_pdf_grid_values_all14(pdf, target, n_replicas=None, member_mode="replicas"): """Evaluate PDF in all 14 evolution-basis flavours. Returns shape (nrep, 14, nx). @@ -501,6 +510,4 @@ def get_pdf_grid_values_all14(pdf, target, n_replicas=None): gv = evol_basis.grid_values( pdf, qmat=[target.Q0], vmat=FK_FLAVOURS, xmat=target.xgrid ).squeeze(-1) - if n_replicas is not None: - gv = gv[1: n_replicas + 1] - return gv + return _select_pdf_members(gv, n_replicas=n_replicas, member_mode=member_mode) From 73f33fdc545111cf27ac8a29c0491b6f84a57b8d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Rapha=C3=ABl=20Bonnet=20Guerrini?= <81559347+rbonnetguerrini@users.noreply.github.com> Date: Tue, 24 Mar 2026 16:27:18 +0100 Subject: [PATCH 18/21] Parallelizing the compute of each experiment within a runcard --- .../validphys/shapley/scripts/vp_shapley.py | 293 +++++++++++++++++- .../shapley/slurm/run_vp_shapley.slurm | 158 +++++++++- 2 files changed, 433 insertions(+), 18 deletions(-) diff --git a/validphys2/src/validphys/shapley/scripts/vp_shapley.py b/validphys2/src/validphys/shapley/scripts/vp_shapley.py index 8d26c22047..f0dc2f4a7c 100644 --- a/validphys2/src/validphys/shapley/scripts/vp_shapley.py +++ b/validphys2/src/validphys/shapley/scripts/vp_shapley.py @@ -654,6 +654,48 @@ def _write_shapley_csv(path, labels, values): f.write(f"{lbl},{float(val):.8f}\n") +def _write_shapley_per_replica_csv(path, labels, values_per_replica): + """Write per-replica Shapley values as a replica-by-flavour matrix.""" + matrix = np.asarray(values_per_replica, dtype=float) + with open(path, "w") as f: + f.write("replica," + ",".join(labels) + "\n") + for replica_idx, row in enumerate(matrix, start=1): + values_txt = ",".join(f"{float(val):.8f}" for val in row) + f.write(f"{replica_idx},{values_txt}\n") + + +def _write_shapley_per_sample_csv(path, labels, values_per_sample): + """Write per-sign-sample Shapley values as a sample-by-flavour matrix.""" + matrix = np.asarray(values_per_sample, dtype=float) + with open(path, "w") as f: + f.write("sample," + ",".join(labels) + "\n") + for sample_idx, row in enumerate(matrix, start=1): + values_txt = ",".join(f"{float(val):.8f}" for val in row) + f.write(f"{sample_idx},{values_txt}\n") + + +def _serialize_shapley_per_replica(labels, values_per_replica): + """Convert per-replica SV matrix into JSON-native flavour -> list form.""" + if values_per_replica is None: + return None + matrix = np.asarray(values_per_replica, dtype=float) + return { + lbl: [float(val) for val in matrix[:, i]] + for i, lbl in enumerate(labels) + } + + +def _serialize_shapley_per_sample(labels, values_per_sample): + """Convert per-sign-sample SV matrix into JSON-native flavour -> list form.""" + if values_per_sample is None: + return None + matrix = np.asarray(values_per_sample, dtype=float) + return { + lbl: [float(val) for val in matrix[:, i]] + for i, lbl in enumerate(labels) + } + + def _resolve_stabilization_cfg(cfg): """Resolve stabilization options with safe defaults.""" stab = cfg.get("stabilization", {}) or {} @@ -799,11 +841,14 @@ def _dataset_mean_chi2_for_coalition(analyzer, coalition, pert, sign_matrices=No def _build_stabilization_report(analyzer, raw_results, pert, stab_cfg): """Build coalition->dataset outlier report and exclusion list.""" diag = raw_results.get("diagnostic") or {} + sign_matrices = raw_results.get("_sign_matrices") outliers = list(diag.get("outlier_coalitions", [])) n_selected = min(len(outliers), int(stab_cfg["max_outlier_coalitions"])) selected = outliers[:n_selected] - baseline_rows = _dataset_mean_chi2_for_coalition(analyzer, [], pert) + baseline_rows = _dataset_mean_chi2_for_coalition( + analyzer, [], pert, sign_matrices=sign_matrices + ) baseline_map = {r["dataset"]: r for r in baseline_rows} threshold = float(stab_cfg["dataset_delta_chi2_threshold"]) @@ -813,7 +858,9 @@ def _build_stabilization_report(analyzer, raw_results, pert, stab_cfg): for oc in selected: coalition_idx = list(oc.get("coalition", [])) coalition_labels = list(oc.get("coalition_labels", [])) - coalition_rows = _dataset_mean_chi2_for_coalition(analyzer, coalition_idx, pert) + coalition_rows = _dataset_mean_chi2_for_coalition( + analyzer, coalition_idx, pert, sign_matrices=sign_matrices + ) flagged = [] for crow in coalition_rows: @@ -904,6 +951,7 @@ def _build_stabilization_report(analyzer, raw_results, pert, stab_cfg): def _save_stabilization_files(report, output_dir, basis): """Write stabilization report JSON + compact flagged-dataset CSV.""" + output_dir.mkdir(parents=True, exist_ok=True) json_path = output_dir / f"stabilization_report_{basis}.json" with open(json_path, "w") as f: json.dump(report, f, indent=2) @@ -958,10 +1006,34 @@ def run_analysis(cfg, output_dir, setup_context, n_jobs_override=None, per_replica = bool( pert.get("per_replica", cfg.get("per_replica", False)) ) - # Random sign: flip amplitude sign independently per replica per coalition. + # Random sign: draw a fixed sign for each replica/flavour for the run. random_sign = bool( pert.get("random_sign", cfg.get("random_sign", False)) ) + n_sign_samples = int( + pert.get("n_sign_samples", cfg.get("n_sign_samples", 1)) + ) + random_seed = pert.get("random_seed", cfg.get("random_seed")) + expected_member_mode = "replicas" if per_replica else "central" + explicit_member_mode = pert.get("member_mode", cfg.get("member_mode")) + if explicit_member_mode is not None: + member_mode = str(explicit_member_mode).strip().lower() + if member_mode != expected_member_mode: + raise ValueError( + "member_mode is redundant with per_replica and must match it: " + f"expected '{expected_member_mode}', got '{member_mode}'." + ) + else: + member_mode = expected_member_mode + if not random_sign: + n_sign_samples = 1 + elif per_replica: + if n_sign_samples != 1: + print( + "Note: per_replica=True uses one fixed sign mask per replica; " + f"ignoring n_sign_samples={n_sign_samples} and using 1." + ) + n_sign_samples = 1 enforce_sumrules = cfg.get("enforce_sumrules", False) n_jobs = int(cfg.get("n_jobs", 1)) if n_jobs_override is not None: @@ -1106,9 +1178,21 @@ def run_analysis(cfg, output_dir, setup_context, n_jobs_override=None, _write_shapley_csv(csv_path, labels, sv) print(f"Saved: {csv_path}") - # Per-replica uncertainty CSV. + # Sampling-axis outputs. + sv_per_replica = results_final.get("shapley_values_per_replica") + sv_per_sample = results_final.get("shapley_values_per_sign_sample") sv_std = results_final.get("shapley_std") sv_err = results_final.get("shapley_err") + sv_sign_std = results_final.get("shapley_sign_std") + sv_sign_err = results_final.get("shapley_sign_err") + if per_replica and sv_per_replica is not None: + per_rep_path = output_dir / f"shapley_values_per_replica_{basis}.csv" + _write_shapley_per_replica_csv(per_rep_path, labels, sv_per_replica) + print(f"Saved: {per_rep_path}") + if sv_per_sample is not None: + per_sample_path = output_dir / f"shapley_values_per_sign_sample_{basis}.csv" + _write_shapley_per_sample_csv(per_sample_path, labels, sv_per_sample) + print(f"Saved: {per_sample_path}") if per_replica and sv_std is not None: unc_path = output_dir / f"shapley_uncertainties_{basis}.csv" with open(unc_path, "w") as f: @@ -1123,6 +1207,20 @@ def run_analysis(cfg, output_dir, setup_context, n_jobs_override=None, f"{lbl},{float(mean_v):.8f},{float(std_v):.8f},{float(err_v):.8f}\n" ) print(f"Saved: {unc_path}") + if sv_sign_std is not None: + sign_unc_path = output_dir / f"shapley_sign_uncertainties_{basis}.csv" + with open(sign_unc_path, "w") as f: + f.write("flavour,mean,std,err\n") + for lbl, mean_v, std_v, err_v in zip( + labels, + sv, + sv_sign_std, + sv_sign_err, + ): + f.write( + f"{lbl},{float(mean_v):.8f},{float(std_v):.8f},{float(err_v):.8f}\n" + ) + print(f"Saved: {sign_unc_path}") if stable_rerun_performed: csv_stable = output_dir / f"shapley_values_{basis}_stable.csv" @@ -1137,6 +1235,12 @@ def run_analysis(cfg, output_dir, setup_context, n_jobs_override=None, all_results[basis] = { "shapley_values": {l: float(v) for l, v in zip(labels, sv)}, + "shapley_values_per_replica": _serialize_shapley_per_replica( + labels, sv_per_replica + ), + "shapley_values_per_sign_sample": _serialize_shapley_per_sample( + labels, sv_per_sample + ), "shapley_std": ( {l: float(v) for l, v in zip(labels, sv_std)} if sv_std is not None else None @@ -1216,6 +1320,40 @@ def run_analysis(cfg, output_dir, setup_context, n_jobs_override=None, return all_results +def _save_consolidated_results(all_experiment_results, summary, output_dir): + """Save consolidated results from all experiments into a single JSON. + + Combines results from all experiments into a single JSON file with a smart + structure that preserves per-experiment metadata and results by basis. + + Parameters + ---------- + all_experiment_results : dict + Dictionary mapping experiment name to per-basis results + summary : dict + Experiment summary with perturbation and output_dir info + output_dir : Path + Top-level output directory + """ + consolidated = { + "timestamp": datetime.now().isoformat(), + "experiments": {} + } + + for exp_name, exp_results in all_experiment_results.items(): + exp_summary = summary.get(exp_name, {}) + consolidated["experiments"][exp_name] = { + "output_dir": exp_summary.get("output_dir"), + "perturbation": exp_summary.get("perturbation"), + "results_by_basis": exp_results + } + + json_path = output_dir / "consolidated_results.json" + with open(json_path, "w") as f: + json.dump(consolidated, f, indent=2) + print(f"Saved consolidated results: {json_path}") + + def main(): parser = argparse.ArgumentParser( description="NNPDF Shapley value analysis from a YAML runcard." @@ -1253,6 +1391,44 @@ def main(): "contributions in the diagnostic output (default: 3.0)." ), ) + + exp_sel = parser.add_argument_group("experiment selection") + exp_sel.add_argument( + "--list-experiments", + action="store_true", + help="List normalized experiments with indices and exit.", + ) + exp_sel.add_argument( + "--experiment", + type=str, + default=None, + help=( + "Run only the experiment with this name (as in the runcard). " + "By default, single-experiment runs skip cross-experiment plots." + ), + ) + exp_sel.add_argument( + "--experiment-index", + type=int, + default=None, + help=( + "Run only the experiment at this 0-based index in the normalized list. " + "Useful for SLURM array tasks (SLURM_ARRAY_TASK_ID)." + ), + ) + exp_sel.add_argument( + "--aggregate-only", + action="store_true", + help=( + "Do not run Shapley; instead rebuild cross-experiment plots and " + "consolidated summaries from per-experiment results already on disk." + ), + ) + exp_sel.add_argument( + "--no-compare", + action="store_true", + help="Skip cross-experiment comparison plots and consolidated summaries.", + ) args = parser.parse_args() cfg = load_runcard(args.runcard) @@ -1264,13 +1440,107 @@ def main(): print(f"Output : {output_dir}\n") experiments = _normalize_experiments(cfg) + + if args.list_experiments: + print("Normalized experiments:") + for i, (exp_name, exp_cfg) in enumerate(experiments): + exp_token = _safe_token(exp_name) or "exp" + pert = exp_cfg.get("perturbation", {}) + mu = pert.get("mu") + sigma = pert.get("sigma") + print( + f" [{i}] name={exp_name} token={exp_token} " + f"mu={mu} sigma={sigma}" + ) + return + output_dir.mkdir(parents=True, exist_ok=True) + # Resolve experiment selection (if any). + selected = experiments + selected_name = None + if args.experiment_index is not None and args.experiment is not None: + raise ValueError("Use only one of --experiment or --experiment-index") + if args.experiment_index is not None: + idx = int(args.experiment_index) + if idx < 0 or idx >= len(experiments): + raise IndexError( + f"--experiment-index out of range: {idx} (n={len(experiments)})" + ) + selected = [experiments[idx]] + selected_name = experiments[idx][0] + if args.experiment is not None: + target = str(args.experiment) + matches = [(n, c) for (n, c) in experiments if n == target] + if not matches: + # Convenience: allow matching by safe token as well. + matches = [(n, c) for (n, c) in experiments if _safe_token(n) == _safe_token(target)] + if not matches: + known = ", ".join(n for (n, _) in experiments) + raise KeyError(f"Unknown experiment '{target}'. Known: {known}") + selected = [matches[0]] + selected_name = matches[0][0] + + # By default, single-experiment runs skip cross-experiment comparison outputs. + compare_enabled = not args.no_compare + if len(selected) == 1 and not args.aggregate_only: + compare_enabled = False + + def _load_results_json(path: Path): + with open(path) as f: + payload = json.load(f) + results = payload.get("results") or {} + rb = results.get("results_by_basis") + if rb is None: + raise KeyError(f"Missing results.results_by_basis in {path}") + return rb, payload.get("metadata") or {} + + if args.aggregate_only: + # Aggregation needs a deterministic output directory. + if args.output is None and not cfg.get("output_dir"): + raise ValueError( + "--aggregate-only requires --output (or a runcard 'output_dir') " + "so the timestamped run directory can be located." + ) + + summary = {} + all_experiment_results = {} + missing = [] + for exp_name, exp_cfg in experiments: + exp_token = _safe_token(exp_name) or "exp" + exp_output_dir = output_dir / exp_token + res_path = exp_output_dir / "results.json" + if not res_path.exists(): + missing.append(str(res_path)) + continue + exp_results_by_basis, _ = _load_results_json(res_path) + all_experiment_results[exp_name] = exp_results_by_basis + summary[exp_name] = { + "output_dir": str(exp_output_dir), + "perturbation": exp_cfg["perturbation"], + } + + if missing: + print("WARNING: some experiments are missing results.json:") + for p in missing: + print(f" - {p}") + + if compare_enabled: + _save_comparison_plots(all_experiment_results, output_dir, summary) + + summary_path = output_dir / "experiments_summary.json" + with open(summary_path, "w") as f: + json.dump(summary, f, indent=2) + print(f"\nSaved multi-experiment summary: {summary_path}") + + _save_consolidated_results(all_experiment_results, summary, output_dir) + return + setup_context = _build_setup_context(cfg) summary = {} all_experiment_results = {} - for exp_name, exp_cfg in experiments: + for exp_name, exp_cfg in selected: exp_token = _safe_token(exp_name) or "exp" exp_output_dir = output_dir / exp_token print(f"\nRunning experiment '{exp_name}'") @@ -1289,12 +1559,15 @@ def main(): "perturbation": exp_cfg["perturbation"], } - _save_comparison_plots(all_experiment_results, output_dir, summary) + if compare_enabled and len(all_experiment_results) > 0: + _save_comparison_plots(all_experiment_results, output_dir, summary) + + summary_path = output_dir / "experiments_summary.json" + with open(summary_path, "w") as f: + json.dump(summary, f, indent=2) + print(f"\nSaved multi-experiment summary: {summary_path}") - summary_path = output_dir / "experiments_summary.json" - with open(summary_path, "w") as f: - json.dump(summary, f, indent=2) - print(f"\nSaved multi-experiment summary: {summary_path}") + _save_consolidated_results(all_experiment_results, summary, output_dir) if __name__ == "__main__": diff --git a/validphys2/src/validphys/shapley/slurm/run_vp_shapley.slurm b/validphys2/src/validphys/shapley/slurm/run_vp_shapley.slurm index f0e46e3721..309c92fe7e 100644 --- a/validphys2/src/validphys/shapley/slurm/run_vp_shapley.slurm +++ b/validphys2/src/validphys/shapley/slurm/run_vp_shapley.slurm @@ -8,10 +8,30 @@ set -euo pipefail +# Optional modes +# - --split (or SPLIT_EXPERIMENTS=1): submit an array job, one task per experiment, +# plus a dependent aggregation job. +# - --aggregate-only (or AGGREGATE_ONLY=1): only rebuild cross-experiment outputs +# from per-experiment results already on disk. +SPLIT_EXPERIMENTS="${SPLIT_EXPERIMENTS:-0}" +SPLIT_MODE="${SPLIT_MODE:-0}" +AGGREGATE_ONLY="${AGGREGATE_ONLY:-0}" + +if [[ "${1:-}" == "--split" ]]; then + SPLIT_EXPERIMENTS=1 + shift +fi +if [[ "${1:-}" == "--aggregate-only" ]]; then + AGGREGATE_ONLY=1 + shift +fi + RUNCARD_ARG="${1:-${RUNCARD:-}}" if [[ -z "${RUNCARD_ARG}" ]]; then echo "ERROR: Missing runcard path." >&2 - echo "Usage: sbatch ... run_vp_shapley.slurm /abs/path/to/runcard.yaml" >&2 + echo "Usage:" >&2 + echo " sbatch ... run_vp_shapley.slurm /abs/path/to/runcard.yaml" >&2 + echo " ./run_vp_shapley.slurm --split /abs/path/to/runcard.yaml" >&2 exit 1 fi @@ -96,6 +116,8 @@ fi REPO_DIR="$(cd "${SHAPLEY_DIR}/../../../../" && pwd)" +SCRIPT_PATH="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/$(basename "${BASH_SOURCE[0]}")" + # Ensure the runtime environment provides vp-shapley on compute nodes. CONDA_HOME="${CONDA_HOME:-/leonardo/home/userexternal/rbonnetg/miniconda3}" CONDA_ENV="${CONDA_ENV:-environment_nnpdf}" @@ -106,11 +128,123 @@ fi source "${CONDA_HOME}/etc/profile.d/conda.sh" conda activate "${CONDA_ENV}" +resolve_effective_output_dir() { + local out_dir="$1" + if [[ -z "${out_dir}" ]]; then + echo "" + return 0 + fi + if [[ "${out_dir}" = /* ]]; then + echo "${out_dir}" + else + echo "${SHAPLEY_DIR}/${out_dir}" + fi +} + +get_experiment_count() { + python - "$1" <<'PY' +import sys +import yaml + +runcard = sys.argv[1] +with open(runcard) as f: + cfg = yaml.safe_load(f) + +exps = cfg.get("experiments") +if isinstance(exps, dict): + n = len(list(exps.keys())) +elif isinstance(exps, list): + n = len(exps) +else: + n = 0 + +print(n) +PY +} + +# Submission helper mode: run this script directly (not under SLURM) +# to submit an array job + dependent aggregation job. +if [[ -z "${SLURM_JOB_ID:-}" && "${SPLIT_EXPERIMENTS}" == "1" ]]; then + # Extra args (after the runcard) are forwarded to the child jobs. + EXTRA_ARGS=() + if [[ $# -gt 1 ]]; then + EXTRA_ARGS=("${@:2}") + fi + + mkdir -p "${LOG_DIR}" "${RESULTS_BASE_DIR}" + + TS="$(date +%Y%m%d_%H%M%S)" + RUN_TOKEN="$(safe_token "${RUN_LABEL}")" + + # Compute a single shared output directory for this split run. + EFFECTIVE_OUTPUT_DIR="" + if [[ -n "${OUTPUT_DIR:-}" ]]; then + EFFECTIVE_OUTPUT_DIR="$(resolve_effective_output_dir "${OUTPUT_DIR}")" + elif [[ -n "${OUTPUT_DIR_CFG}" ]]; then + # output_dir is already a deterministic directory (no timestamp needed). + EFFECTIVE_OUTPUT_DIR="${RESULTS_BASE_DIR}" + else + # output_root requires a timestamped subdir to match vp-shapley defaults. + EFFECTIVE_OUTPUT_DIR="${RESULTS_BASE_DIR}/${TS}_${RUN_TOKEN}" + fi + mkdir -p "${EFFECTIVE_OUTPUT_DIR}" + + N_EXP="$(get_experiment_count "${RUNCARD_PATH}")" + if [[ -z "${N_EXP}" || "${N_EXP}" -lt 1 ]]; then + echo "ERROR: Could not determine experiment count from runcard." >&2 + exit 1 + fi + + ARRAY_MAX=$((N_EXP - 1)) + CPUS_PER_TASK="${CPUS_PER_TASK:-${N_JOBS:-1}}" + if [[ -z "${CPUS_PER_TASK}" || "${CPUS_PER_TASK}" -lt 1 ]]; then + CPUS_PER_TASK=1 + fi + echo "Submitting split Shapley run" >&2 + echo " Runcard : ${RUNCARD_PATH}" >&2 + echo " Experiments: ${N_EXP} (array 0-${ARRAY_MAX})" >&2 + echo " Output dir : ${EFFECTIVE_OUTPUT_DIR}" >&2 + echo " CPUs/task : ${CPUS_PER_TASK} (set CPUS_PER_TASK or N_JOBS)" >&2 + + array_submit_out="$( + sbatch \ + --job-name="vp_shapley_${RUN_TOKEN}" \ + --array="0-${ARRAY_MAX}" \ + --cpus-per-task="${CPUS_PER_TASK}" \ + --export=ALL,RUNCARD="${RUNCARD_PATH}",OUTPUT_DIR="${EFFECTIVE_OUTPUT_DIR}",SPLIT_MODE=1 \ + "${SCRIPT_PATH}" "${RUNCARD_PATH}" "${EXTRA_ARGS[@]}" + )" + echo "${array_submit_out}" >&2 + ARRAY_JOB_ID="$(echo "${array_submit_out}" | awk '{print $NF}')" + if [[ -z "${ARRAY_JOB_ID}" ]]; then + echo "ERROR: Failed to parse array job id from: ${array_submit_out}" >&2 + exit 1 + fi + + agg_submit_out="$( + sbatch \ + --job-name="vp_shapley_${RUN_TOKEN}_aggregate" \ + --dependency="afterok:${ARRAY_JOB_ID}" \ + --cpus-per-task="${CPUS_PER_TASK}" \ + --export=ALL,RUNCARD="${RUNCARD_PATH}",OUTPUT_DIR="${EFFECTIVE_OUTPUT_DIR}",AGGREGATE_ONLY=1 \ + "${SCRIPT_PATH}" "${RUNCARD_PATH}" "${EXTRA_ARGS[@]}" + )" + echo "${agg_submit_out}" >&2 + + echo "Submitted array job : ${ARRAY_JOB_ID}" >&2 + echo "Submitted aggregate : (afterok:${ARRAY_JOB_ID})" >&2 + exit 0 +fi + mkdir -p "${LOG_DIR}" "${RESULTS_BASE_DIR}" TS="$(date +%Y%m%d_%H%M%S)" -LOG_OUT="${LOG_DIR}/${TS}_${RUNCARD_STEM}_job${SLURM_JOB_ID:-manual}.out.log" -LOG_ERR="${LOG_DIR}/${TS}_${RUNCARD_STEM}_job${SLURM_JOB_ID:-manual}.err.log" +TASK_SUFFIX="" +if [[ -n "${SLURM_ARRAY_TASK_ID:-}" ]]; then + TASK_SUFFIX="_task${SLURM_ARRAY_TASK_ID}" +fi +LOG_OUT="${LOG_DIR}/${TS}_${RUNCARD_STEM}_job${SLURM_JOB_ID:-manual}${TASK_SUFFIX}.out.log" +LOG_ERR="${LOG_DIR}/${TS}_${RUNCARD_STEM}_job${SLURM_JOB_ID:-manual}${TASK_SUFFIX}.err.log" exec > >(tee -a "${LOG_OUT}") exec 2> >(tee -a "${LOG_ERR}" >&2) @@ -127,17 +261,25 @@ cd "${REPO_DIR}" CMD=(vp-shapley "${RUNCARD_PATH}") if [[ -n "${OUTPUT_DIR:-}" ]]; then - if [[ "${OUTPUT_DIR}" = /* ]]; then - EFFECTIVE_OUTPUT_DIR="${OUTPUT_DIR}" - else - EFFECTIVE_OUTPUT_DIR="${SHAPLEY_DIR}/${OUTPUT_DIR}" - fi + EFFECTIVE_OUTPUT_DIR="$(resolve_effective_output_dir "${OUTPUT_DIR}")" mkdir -p "${EFFECTIVE_OUTPUT_DIR}" CMD+=(--output "${EFFECTIVE_OUTPUT_DIR}") fi if [[ -n "${N_JOBS:-}" ]]; then CMD+=(--n-jobs "${N_JOBS}") fi + +if [[ "${SPLIT_MODE}" == "1" ]]; then + if [[ -z "${SLURM_ARRAY_TASK_ID:-}" ]]; then + echo "ERROR: SPLIT_MODE=1 requires SLURM_ARRAY_TASK_ID" >&2 + exit 1 + fi + CMD+=(--experiment-index "${SLURM_ARRAY_TASK_ID}" --no-compare) +fi +if [[ "${AGGREGATE_ONLY}" == "1" ]]; then + CMD+=(--aggregate-only) +fi + if [[ $# -gt 1 ]]; then CMD+=("${@:2}") fi From 514125e70ca78c653e66c542e301d66b5e6931d7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Rapha=C3=ABl=20Bonnet=20Guerrini?= <81559347+rbonnetguerrini@users.noreply.github.com> Date: Fri, 27 Mar 2026 14:19:09 +0100 Subject: [PATCH 19/21] new perturbation + dense heatmap plotting --- validphys2/src/validphys/shapley/analyzer.py | 574 +++++++++++++++--- .../src/validphys/shapley/perturbation.py | 45 +- .../validphys/shapley/runcards/DIS/DIS.yaml | 110 ++++ .../validphys/shapley/runcards/DIS/HERA.yaml | 5 +- .../shapley/runcards/DIS/NU_fixed.yaml | 5 +- .../shapley/runcards/DY/DY_other.yaml | 5 +- .../validphys/shapley/runcards/DY/DY_pt.yaml | 5 +- .../validphys/shapley/runcards/gluon/JET.yaml | 5 +- .../validphys/shapley/runcards/gluon/tt.yaml | 5 +- .../shapley/runcards/nnpdf4.0_calibrated.yaml | 9 +- .../runcards/nnpdf4.0_calibrated_dense.yaml | 278 +++++++++ .../runcards/nnpdf4.0_calibrated_evol.yaml | 7 +- .../validphys/shapley/scripts/vp_shapley.py | 463 +++++++++++--- .../shapley/slurm/run_vp_shapley.slurm | 2 +- 14 files changed, 1332 insertions(+), 186 deletions(-) create mode 100644 validphys2/src/validphys/shapley/runcards/DIS/DIS.yaml create mode 100644 validphys2/src/validphys/shapley/runcards/nnpdf4.0_calibrated_dense.yaml diff --git a/validphys2/src/validphys/shapley/analyzer.py b/validphys2/src/validphys/shapley/analyzer.py index 4b36462a86..61e461e2cc 100644 --- a/validphys2/src/validphys/shapley/analyzer.py +++ b/validphys2/src/validphys/shapley/analyzer.py @@ -796,6 +796,393 @@ def _coalition_with_player(coalition, player): """Return sorted coalition tuple with one extra player.""" return tuple(sorted(coalition + (player,))) + @staticmethod + def _coalition_to_bitmask(coalition): + """Encode a coalition tuple as an integer bitmask.""" + mask = 0 + for player in coalition: + mask |= (1 << int(player)) + return int(mask) + + @staticmethod + def _compute_shapley_from_cache(value_cache, all_coalitions, n_flavors): + """Compute exact Shapley values from a coalition->value cache.""" + factorial = [math.factorial(k) for k in range(n_flavors + 1)] + factorial_n = factorial[n_flavors] + + first_value = next(iter(value_cache.values())) + is_vector = np.ndim(first_value) > 0 + if is_vector: + n_members = int(np.asarray(first_value).shape[0]) + shapley_vals = np.zeros((n_members, n_flavors), dtype=float) + else: + shapley_vals = np.zeros(n_flavors, dtype=float) + + for player in range(n_flavors): + for coalition in all_coalitions: + if player in coalition: + continue + size = len(coalition) + weight = ( + factorial[size] * factorial[n_flavors - size - 1] + ) / factorial_n + coalition_with = tuple(sorted(coalition + (player,))) + delta = value_cache[coalition_with] - value_cache[coalition] + if is_vector: + shapley_vals[:, player] += weight * delta + else: + shapley_vals[player] += weight * delta + + return shapley_vals + + def _print_even_odd_validation_checks(self, checks, per_replica): + """Print numerical consistency checks for the deterministic dual-game construction.""" + def _fmt(entry): + return ( + f"max|diff|={entry['max_abs_diff']:.3e}, " + f"tol={entry['tol']:.1e}, pass={entry['pass']}" + ) + + print("\n--- Deterministic calibrated up/down checks ---") + print(f" completeness even : {_fmt(checks['completeness_even'])}") + print(f" completeness odd : {_fmt(checks['completeness_odd'])}") + print(f" v_even(empty)=0 : {_fmt(checks['empty_even_zero'])}") + print(f" v_odd(empty)=0 : {_fmt(checks['empty_odd_zero'])}") + print( + " odd from up/down : " + f"chi2_plus-minus residual={checks['chi2_symmetry_residual']:.3e}, " + f"max|phi_odd|={checks['odd_zero_if_symmetric']['phi_odd_max_abs']:.3e}, " + f"pass={checks['odd_zero_if_symmetric']['pass']}" + ) + print(f" phi_even relation : {_fmt(checks['even_vs_pm'])}") + print(f" phi_odd relation : {_fmt(checks['odd_vs_pm'])}") + if per_replica: + print(" (checks evaluated over replica vectors using max-abs residuals)") + print() + + def _compute_exact_shap_even_odd_parallel( + self, + mu, + sigma, + amplitude, + mode, + xspace, + n_jobs, + verbose=True, + per_replica=False, + ): + """Compute deterministic calibrated up/down exact Shapley values. + + For every coalition S, evaluate once: + chi2_plus(S) = chi2(p0 + Delta_S_plus) + chi2_minus(S) = chi2(p0 + Delta_S_minus) + + where Delta_S_plus and Delta_S_minus are built from the calibrated + +1sigma and -1sigma flavour templates, respectively, and are not + assumed to be opposite perturbations. + + Then define the two games: + v_even(S) = 0.5 * (chi2_plus + chi2_minus) - chi2_baseline + v_odd(S) = 0.5 * (chi2_plus - chi2_minus) + """ + n = self.n_flavors + all_coalitions = list(self._iter_all_coalitions()) + total_coalitions = len(all_coalitions) + non_empty = [c for c in all_coalitions if len(c) > 0] + coalition_bitmasks = { + coalition: self._coalition_to_bitmask(coalition) + for coalition in all_coalitions + } + + if verbose: + print( + f"Computing deterministic calibrated even/odd Shapley for {n} players " + f"({total_coalitions} coalitions) with {n_jobs} worker(s)..." + ) + + n_members = self._infer_n_members() + plus_sign_matrix = np.ones((n_members, n), dtype=float) + minus_sign_matrix = -np.ones((n_members, n), dtype=float) + + t0 = time.time() + progress_start = t0 + interactive_stderr = sys.stderr.isatty() + log_every = max(1, total_coalitions // 100) + + # Empty coalition is shared: plus and minus are both the baseline. + chi2_baseline = self._evaluate_chi2( + [], mu, sigma, amplitude, + mode=mode, xspace=xspace, + per_replica=per_replica, + random_sign=False, + random_sign_matrix=plus_sign_matrix, + ) + + chi2_plus_cache = {tuple(): chi2_baseline} + chi2_minus_cache = {tuple(): chi2_baseline} + + def _evaluate_one(coalition): + chi2_plus = self._evaluate_chi2( + coalition, mu, sigma, amplitude, + mode=mode, xspace=xspace, + per_replica=per_replica, + random_sign=False, + random_sign_matrix=plus_sign_matrix, + ) + chi2_minus = self._evaluate_chi2( + coalition, mu, sigma, amplitude, + mode=mode, xspace=xspace, + per_replica=per_replica, + random_sign=False, + random_sign_matrix=minus_sign_matrix, + ) + return coalition, chi2_plus, chi2_minus + + with ThreadPoolExecutor(max_workers=n_jobs) as executor: + future_map = { + executor.submit(_evaluate_one, coalition): coalition + for coalition in non_empty + } + completed = 1 # empty coalition already done + for future in as_completed(future_map): + coalition, chi2_plus, chi2_minus = future.result() + chi2_plus_cache[coalition] = chi2_plus + chi2_minus_cache[coalition] = chi2_minus + completed += 1 + + if verbose: + elapsed = time.time() - progress_start + if completed == 1: + msg = ( + f" [{completed}/{total_coalitions}] " + f"elapsed {elapsed:.0f}s ..." + ) + else: + rate = elapsed / completed + remaining = rate * (total_coalitions - completed) + mins, secs = divmod(int(remaining), 60) + msg = ( + f" [{completed}/{total_coalitions}] " + f"elapsed {elapsed:.0f}s | " + f"~{rate:.1f}s/coalition | ETA {mins}m{secs:02d}s " + ) + if interactive_stderr: + sys.stderr.write(f"\r{msg}") + sys.stderr.flush() + elif ( + completed == 1 + or completed == total_coalitions + or completed % log_every == 0 + ): + sys.stderr.write(f"{msg}\n") + sys.stderr.flush() + + if verbose: + sys.stderr.write("\n") + sys.stderr.flush() + + v_plus_cache = {} + v_minus_cache = {} + v_even_cache = {} + v_odd_cache = {} + for coalition in all_coalitions: + chi2_plus = chi2_plus_cache[coalition] + chi2_minus = chi2_minus_cache[coalition] + v_plus_cache[coalition] = chi2_plus - chi2_baseline + v_minus_cache[coalition] = chi2_minus - chi2_baseline + v_even_cache[coalition] = 0.5 * (chi2_plus + chi2_minus) - chi2_baseline + v_odd_cache[coalition] = 0.5 * (chi2_plus - chi2_minus) + + phi_even = self._compute_shapley_from_cache(v_even_cache, all_coalitions, n) + phi_odd = self._compute_shapley_from_cache(v_odd_cache, all_coalitions, n) + phi_plus = self._compute_shapley_from_cache(v_plus_cache, all_coalitions, n) + phi_minus = self._compute_shapley_from_cache(v_minus_cache, all_coalitions, n) + + coalition_full = tuple(range(n)) + tol = 1e-10 + + def _max_abs(x): + return float(np.max(np.abs(np.asarray(x, dtype=float)))) + + lhs_even = np.sum(phi_even, axis=0) if np.ndim(phi_even) == 1 else np.sum(phi_even, axis=1) + rhs_even = v_even_cache[coalition_full] - v_even_cache[tuple()] + lhs_odd = np.sum(phi_odd, axis=0) if np.ndim(phi_odd) == 1 else np.sum(phi_odd, axis=1) + rhs_odd = v_odd_cache[coalition_full] - v_odd_cache[tuple()] + + chi2_symmetry_residual = max( + _max_abs(chi2_plus_cache[c] - chi2_minus_cache[c]) + for c in all_coalitions + ) + odd_zero_tol = 1e-10 + odd_max_abs = _max_abs(phi_odd) + odd_zero_pass = (chi2_symmetry_residual > odd_zero_tol) or (odd_max_abs <= odd_zero_tol) + + even_pm_diff = phi_even - 0.5 * (phi_plus + phi_minus) + odd_pm_diff = phi_odd - 0.5 * (phi_plus - phi_minus) + + checks = { + "completeness_even": { + "max_abs_diff": _max_abs(lhs_even - rhs_even), + "tol": tol, + "pass": bool(_max_abs(lhs_even - rhs_even) <= tol), + }, + "completeness_odd": { + "max_abs_diff": _max_abs(lhs_odd - rhs_odd), + "tol": tol, + "pass": bool(_max_abs(lhs_odd - rhs_odd) <= tol), + }, + "empty_even_zero": { + "max_abs_diff": _max_abs(v_even_cache[tuple()]), + "tol": tol, + "pass": bool(_max_abs(v_even_cache[tuple()]) <= tol), + }, + "empty_odd_zero": { + "max_abs_diff": _max_abs(v_odd_cache[tuple()]), + "tol": tol, + "pass": bool(_max_abs(v_odd_cache[tuple()]) <= tol), + }, + "chi2_symmetry_residual": chi2_symmetry_residual, + "odd_zero_if_symmetric": { + "phi_odd_max_abs": odd_max_abs, + "tol": odd_zero_tol, + "pass": bool(odd_zero_pass), + }, + "even_vs_pm": { + "max_abs_diff": _max_abs(even_pm_diff), + "tol": tol, + "pass": bool(_max_abs(even_pm_diff) <= tol), + }, + "odd_vs_pm": { + "max_abs_diff": _max_abs(odd_pm_diff), + "tol": tol, + "pass": bool(_max_abs(odd_pm_diff) <= tol), + }, + } + + elapsed = time.time() - t0 + + if per_replica: + nrep = int(np.asarray(phi_even).shape[0]) + mean_even = np.mean(phi_even, axis=0) + std_even_rep = ( + np.std(phi_even, axis=0, ddof=1) if nrep > 1 + else np.zeros(n, dtype=float) + ) + err_even_rep = std_even_rep / np.sqrt(max(nrep, 1)) + + # Sign dependence should not cancel between replicas: + # S_abs_j = < |phi_odd_j| >_replicas + phi_odd_abs = np.abs(phi_odd) + mean_odd = np.mean(phi_odd_abs, axis=0) + + if verbose: + print(f"Baseline (mean) : {float(np.mean(chi2_baseline)):.6f}") + print(f"Max |phi_even| : {float(np.max(np.abs(mean_even))):.6f}") + print(f"Max S_abs : {float(np.max(mean_odd)):.6f}") + print(f"Max even std : {float(np.max(std_even_rep)):.6f}") + print(f"Elapsed : {elapsed:.1f}s") + self._print_even_odd_validation_checks(checks, per_replica=True) + + return { + "shapley_values": mean_even, + "shapley_values_odd": mean_odd, + "shapley_values_odd_signed": np.mean(phi_odd, axis=0), + "shapley_values_per_replica": phi_even, + "shapley_values_odd_per_replica": phi_odd_abs, + "shapley_values_odd_signed_per_replica": phi_odd, + "shapley_std": std_even_rep, + "shapley_err": err_even_rep, + "shapley_odd_std": None, + "shapley_odd_err": None, + "mean_even": mean_even, + "std_even_rep": std_even_rep, + "mean_odd": mean_odd, + "std_odd_rep": None, + "baseline": float(np.mean(chi2_baseline)), + "baseline_per_replica": chi2_baseline, + "player_labels": self.flavor_labels, + "player_short": self.flavor_short, + "coalitions_evaluated": total_coalitions, + "total_coalitions": total_coalitions, + "theory_evaluations": 1 + 2 * (total_coalitions - 1), + "elapsed_seconds": elapsed, + "n_replicas": nrep, + "checks": checks, + "value_cache_even": v_even_cache, + "value_cache_odd": v_odd_cache, + "value_cache_plus": v_plus_cache, + "value_cache_minus": v_minus_cache, + "chi2_plus_cache": chi2_plus_cache, + "chi2_minus_cache": chi2_minus_cache, + "_mean_value_cache": { + coalition: float(np.mean(v_even_cache[coalition])) + for coalition in all_coalitions + }, + "_mean_value_cache_even": { + coalition: float(np.mean(v_even_cache[coalition])) + for coalition in all_coalitions + }, + "_mean_value_cache_odd": { + coalition: float(np.mean(v_odd_cache[coalition])) + for coalition in all_coalitions + }, + "coalition_bitmasks": coalition_bitmasks, + "_sign_matrices": [plus_sign_matrix, minus_sign_matrix], + } + + if verbose: + print(f"Baseline : {float(chi2_baseline):.6f}") + print(f"Max |phi_even| : {float(np.max(np.abs(phi_even))):.6f}") + print(f"Max |phi_odd| : {float(np.max(np.abs(phi_odd))):.6f}") + print(f"Sum phi_even : {float(np.sum(phi_even)):.6f}") + print(f"Sum phi_odd : {float(np.sum(phi_odd)):.6f}") + print(f"Elapsed : {elapsed:.1f}s") + self._print_even_odd_validation_checks(checks, per_replica=False) + + return { + "shapley_values": phi_even, + "shapley_values_odd": np.abs(phi_odd), + "shapley_values_odd_signed": phi_odd, + "shapley_values_per_replica": None, + "shapley_values_odd_per_replica": None, + "shapley_std": None, + "shapley_err": None, + "shapley_odd_std": None, + "shapley_odd_err": None, + "mean_even": phi_even, + "std_even_rep": None, + "mean_odd": np.abs(phi_odd), + "std_odd_rep": None, + "baseline": float(chi2_baseline), + "player_labels": self.flavor_labels, + "player_short": self.flavor_short, + "coalitions_evaluated": total_coalitions, + "total_coalitions": total_coalitions, + "theory_evaluations": 1 + 2 * (total_coalitions - 1), + "elapsed_seconds": elapsed, + "checks": checks, + "value_cache_even": v_even_cache, + "value_cache_odd": v_odd_cache, + "value_cache_plus": v_plus_cache, + "value_cache_minus": v_minus_cache, + "chi2_plus_cache": chi2_plus_cache, + "chi2_minus_cache": chi2_minus_cache, + "_mean_value_cache": { + coalition: float(v_even_cache[coalition]) + for coalition in all_coalitions + }, + "_mean_value_cache_even": { + coalition: float(v_even_cache[coalition]) + for coalition in all_coalitions + }, + "_mean_value_cache_odd": { + coalition: float(v_odd_cache[coalition]) + for coalition in all_coalitions + }, + "coalition_bitmasks": coalition_bitmasks, + "_sign_matrices": [plus_sign_matrix, minus_sign_matrix], + } + def _compute_exact_shap_parallel(self, mu, sigma, amplitude, mode, xspace, n_jobs, verbose=True, per_replica=False, random_sign=False, @@ -1121,7 +1508,8 @@ def exact_shap(self, mu, sigma, amplitude, mode='additive', xspace='linear', plot=True, n_jobs=1, diagnostic=False, outlier_n_sigma=3.0, per_replica=False, random_sign=False, - n_sign_samples=1, random_seed=None): + n_sign_samples=1, random_seed=None, + deterministic_sign_symmetrized=True): """Compute exact Shapley values for all flavour players. Uses the ``shapley_values.ExactShapley`` solver with the NNPDF @@ -1162,6 +1550,10 @@ def exact_shap(self, mu, sigma, amplitude, mode='additive', ``random_sign=True``. Defaults to 1. random_seed : int or None Optional seed for reproducible sign-mask sampling. + deterministic_sign_symmetrized : bool + When True (default), use deterministic calibrated up/down dual + games. When False, use the legacy sign-sampling path controlled + by ``random_sign`` and ``n_sign_samples``. Returns ------- @@ -1180,16 +1572,7 @@ def exact_shap(self, mu, sigma, amplitude, mode='additive', if int(n_sign_samples) < 1: raise ValueError(f"n_sign_samples must be >= 1, got {n_sign_samples}") - effective_n_sign_samples = int(n_sign_samples) - if not random_sign: - effective_n_sign_samples = 1 - elif per_replica: - if effective_n_sign_samples != 1: - print( - "Note: per_replica=True uses one fixed sign mask per replica; " - f"ignoring n_sign_samples={effective_n_sign_samples} and using 1." - ) - effective_n_sign_samples = 1 + deterministic_sign_symmetrized = bool(deterministic_sign_symmetrized) basis_name = "flavor" if self.basis == 'flavor' else "evolution" print(f"Perturbation basis : {basis_name}") @@ -1199,60 +1582,75 @@ def exact_shap(self, mu, sigma, amplitude, mode='additive', print(f"PDF member mode : {self.member_mode}") print(f"Parallel workers : {int(n_jobs)}") print(f"Per-replica SVs : {'ON' if per_replica else 'OFF'}") - print(f"Random sign : {'ON' if random_sign else 'OFF'}") - print(f"Sign samples : {effective_n_sign_samples}") - - sign_matrices = [None] - if random_sign: - sign_matrices = self._build_sign_matrices( - self._infer_n_members(), - self.n_flavors, - n_sign_samples=effective_n_sign_samples, - random_seed=random_seed, - unique_rows=bool(per_replica), - ) + if deterministic_sign_symmetrized: + print("Sign game : deterministic calibrated up/down") + if random_sign: + print( + "Note: deterministic calibrated up/down games are enabled; " + "ignoring random_sign=True." + ) + if int(n_sign_samples) != 1: + print( + "Note: deterministic calibrated up/down games do not use " + f"n_sign_samples={int(n_sign_samples)}; forcing to 1." + ) - # per_replica=True requires vector-valued value function; the external - # ExactShapley solver only handles scalars, so always use the parallel - # path (which supports both scalar and vector modes). - if per_replica or int(n_jobs) > 1 or len(sign_matrices) > 1: - results = self._compute_exact_shap_parallel( + effective_random_sign = False + effective_n_sign_samples = 1 + results = self._compute_exact_shap_even_odd_parallel( mu, sigma, amplitude, mode, xspace, n_jobs=int(n_jobs), per_replica=per_replica, - random_sign=random_sign, - sign_matrices=sign_matrices, + verbose=True, ) - # Build coalition_log for diagnostics from _compute_exact_shap_parallel - # (the parallel path does not produce a coalition_log internally; - # re-run with diagnostics via the scalar path below if requested). - coalition_log = None - if diagnostic: - mean_value_cache = results.get("_mean_value_cache", {}) - coalition_log = [ - (coalition, mean_value_cache[coalition]) - for coalition in self._iter_all_coalitions() - if coalition in mean_value_cache - ] + mean_value_cache_for_diag = results.get("_mean_value_cache_even", {}) else: - coalition_log = [] if diagnostic else None - v = self.build_value_function( + print("Sign game : configurable random/fixed signs") + effective_random_sign = bool(random_sign) + if effective_random_sign: + effective_n_sign_samples = int(n_sign_samples) + sign_matrices = self._build_sign_matrices( + n_members=self._infer_n_members(), + n_flavors=self.n_flavors, + n_sign_samples=effective_n_sign_samples, + random_seed=random_seed, + unique_rows=( + self.member_mode == "replicas" + and bool(per_replica) + and int(n_sign_samples) == 1 + ), + ) + else: + if int(n_sign_samples) != 1: + print( + "Note: random_sign=False so n_sign_samples is ignored; " + "forcing to 1." + ) + effective_n_sign_samples = 1 + sign_matrices = [None] + + results = self._compute_exact_shap_parallel( mu, sigma, amplitude, mode, xspace, - _coalition_log=coalition_log, - random_sign=random_sign, - random_sign_matrix=sign_matrices[0], - ) - solver = ExactShapley( - n_players=self.n_flavors, - value_function=v, - player_labels=self.flavor_labels, - player_short=self.flavor_short, + n_jobs=int(n_jobs), + verbose=True, + per_replica=per_replica, + random_sign=effective_random_sign, + sign_matrices=sign_matrices, ) - results = solver.compute(verbose=True, n_jobs=1) - # Ensure keys added by the parallel path are always present. - results.setdefault("shapley_values_per_replica", None) - results.setdefault("shapley_std", None) - results.setdefault("shapley_err", None) + results["_sign_matrices"] = sign_matrices + results.setdefault("shapley_values_odd", None) + results.setdefault("shapley_values_odd_per_replica", None) + results.setdefault("shapley_values_odd_signed", None) + results.setdefault("shapley_values_odd_signed_per_replica", None) + mean_value_cache_for_diag = results.get("_mean_value_cache", {}) + + coalition_log = None + if diagnostic: + coalition_log = [ + (coalition, mean_value_cache_for_diag[coalition]) + for coalition in self._iter_all_coalitions() + if coalition in mean_value_cache_for_diag + ] # Attach coalition log and diagnostics if requested. if diagnostic and coalition_log is not None: @@ -1305,12 +1703,19 @@ def exact_shap(self, mu, sigma, amplitude, mode='additive', results["flavor_short"] = self.flavor_short results["n_jobs"] = int(n_jobs) results["per_replica"] = bool(per_replica) - results["random_sign"] = bool(random_sign) + results["random_sign"] = bool(effective_random_sign) results["member_mode"] = self.member_mode results["n_sign_samples"] = int(effective_n_sign_samples) - results["antithetic_sign"] = bool(random_sign and effective_n_sign_samples > 1) + results["antithetic_sign"] = bool( + effective_random_sign and int(effective_n_sign_samples) > 1 + ) results["random_seed"] = random_seed - results["_sign_matrices"] = sign_matrices if random_sign else None + results["deterministic_sign_symmetrized"] = bool( + deterministic_sign_symmetrized + ) + results["deterministic_calibrated_updown"] = bool( + deterministic_sign_symmetrized + ) # Convenience: scalar uncertainty arrays (None when per_replica=False) # shapley_std[j] = std_k phi_j^(k) (replica-to-replica spread) # shapley_err[j] = shapley_std[j] / sqrt(nrep) (standard error of mean) @@ -1329,6 +1734,7 @@ def exact_shap(self, mu, sigma, amplitude, mode='additive', # Plot fig_pdfs = None fig_bar = None + fig_bar_odd = None if plot: fig_pdfs = self.plot_pdfs( amplitude=amplitude, mu=mu, sigma=sigma, @@ -1351,21 +1757,26 @@ def exact_shap(self, mu, sigma, amplitude, mode='additive', f"mu={mu}, sigma={sigma}, A={amplitude}, " f"mode={mode}, xspace={xspace}" ) - fig_bar = plot_shapley_bar( - results["shapley_values"], - self.flavor_short, - title=bar_title, - ylabel="Shapley Value (delta chi2/N)", - ) - # Overlay error bars when per-replica uncertainties are available. + # Single main bar plot from phi_even only. + # Odd quantities are kept in outputs but not plotted. + sv_even = np.asarray(results["shapley_values"], dtype=float) + fig_bar, ax = plt.subplots(figsize=(12, 6)) + pos_color = "#518500" + neg_color = "#FFBF00" + bar_colors = [pos_color if v >= 0.0 else neg_color for v in sv_even] + ax.bar(self.flavor_short, sv_even, color=bar_colors, alpha=0.85) + ax.axhline(0.0, color="#444444", lw=0.9, alpha=0.9) + ax.set_ylabel("Shapley Value (delta chi2/N)") + ax.set_title(bar_title) + ax.grid(axis="y", ls="--", alpha=0.35) + plt.setp(ax.get_xticklabels(), rotation=45, ha="right") + _sv_std = results.get("shapley_std") if _sv_std is not None: - from matplotlib.lines import Line2D - _ax = fig_bar.axes[0] - _ax.errorbar( + ax.errorbar( self.flavor_short, - results["shapley_values"], - yerr=_sv_std, + sv_even, + yerr=np.asarray(_sv_std, dtype=float), fmt="none", ecolor="black", elinewidth=1.2, @@ -1373,16 +1784,23 @@ def exact_shap(self, mu, sigma, amplitude, mode='additive', capthick=1.2, zorder=5, ) - _handles, _ = _ax.get_legend_handles_labels() - _handles.append( - Line2D([], [], color="black", linewidth=1.2, label="1\u03c3 std") - ) - _ax.legend(handles=_handles, loc="upper right") - fig_bar.tight_layout() + ax.legend( + handles=[ + plt.Rectangle((0, 0), 1, 1, color=pos_color, alpha=0.85, label="SV > 0"), + plt.Rectangle((0, 0), 1, 1, color=neg_color, alpha=0.85, label="SV < 0"), + ], + loc="upper right", + frameon=False, + ) + fig_bar.tight_layout() + + fig_bar_odd = None plt.show() results["fig_pdfs"] = fig_pdfs results["fig_bar"] = fig_bar + results["fig_bar_even"] = fig_bar + results["fig_bar_odd"] = fig_bar_odd return results diff --git a/validphys2/src/validphys/shapley/perturbation.py b/validphys2/src/validphys/shapley/perturbation.py index 9c94bff2ed..13b33d7acb 100644 --- a/validphys2/src/validphys/shapley/perturbation.py +++ b/validphys2/src/validphys/shapley/perturbation.py @@ -7,15 +7,16 @@ Calibrated mode --------------- In 'calibrated' mode the Gaussian amplitude is not a global constant but is -scaled per-flavor by the replica standard deviation evaluated at x ~ mu: +scaled per-flavor from calibrated +1sigma/-1sigma envelopes evaluated at +x ~ mu. The up/down shifts are built independently and can be asymmetric: - amplitude_j = alpha * std_rep[ f_j(x_mu) ] + amplitude_j_plus = alpha * (q84_j(x_mu) - c_j(x_mu)) + amplitude_j_minus = alpha * (c_j(x_mu) - q16_j(x_mu)) -so the perturbation probes a shift of *alpha* times what the fit itself is -uncertain about at that x value. The Gaussian shape is preserved; only its -peak height varies by flavor. This removes the bias of both additive (gluon -is much larger than sea quarks) and multiplicative (gluon is much more -tightly constrained in relative terms) approaches. +where c_j is the central calibrated reference (replica mean), and q84/q16 are +the 84th/16th percentiles over replicas. The Gaussian shape is preserved; only +its peak height varies by flavor and by sign. This avoids assuming a symmetric +down-shift equal to the negative of the up-shift. Ablation mode ------------- @@ -80,9 +81,12 @@ def apply_gaussian_perturbation(gv, local_flavor_idx, mu, sigma, amplitude, mode : str 'additive': f_j -> f_j + A * G(x) 'multiplicative': f_j -> f_j * (1 + A * G(x)) - 'calibrated': f_j -> f_j + (A * sigma_rep_j) * G(x) - where sigma_rep_j = std of replicas at x closest to mu. - A acts as a dimensionless scaling factor (alpha). + 'calibrated': f_j -> f_j + delta_j^(sign) * G(x) + where delta_j^(+) = A * (q84_j - c_j), + delta_j^(-) = A * (c_j - q16_j), + at x closest to mu, with c_j the calibrated replica mean. + This builds distinct calibrated up/down templates and does not + assume delta_j^- = -delta_j^+. 'ablation': f_j -> 0 for all x. mu, sigma, amplitude are ignored. xspace : str @@ -155,15 +159,28 @@ def apply_gaussian_perturbation(gv, local_flavor_idx, mu, sigma, amplitude, sign_matrix = np.ones((nrep, len(local_flavor_idx)), dtype=float) if mode == 'calibrated': - # Per-flavor amplitude: alpha * replica std at x closest to mu. + # Per-flavor amplitudes from calibrated +1sigma / -1sigma envelopes + # at x closest to mu, allowing asymmetric up/down shifts. xgrid_arr = np.asarray(xgrid) idx_mu = int(np.argmin(np.abs(xgrid_arr - mu))) gv_sigma = gv if calibration_gv is None else np.asarray(calibration_gv, dtype=float) for col, fi in enumerate(local_flavor_idx): - sigma_rep = float(gv_sigma[:, fi, idx_mu].std()) - gauss = gaussian_profile(xgrid, mu, sigma, amplitude * sigma_rep, xspace) signs = sign_matrix[:, col][:, np.newaxis] - gv_pert[:, fi, :] += signs * gauss[np.newaxis, :] + calib_vals = np.asarray(gv_sigma[:, fi, idx_mu], dtype=float) + c_ref = float(np.mean(calib_vals)) + q16 = float(np.percentile(calib_vals, 16.0)) + q84 = float(np.percentile(calib_vals, 84.0)) + + amp_plus = float(amplitude) * max(q84 - c_ref, 0.0) + amp_minus = float(amplitude) * max(c_ref - q16, 0.0) + + gauss_plus = gaussian_profile(xgrid, mu, sigma, amp_plus, xspace) + gauss_minus = gaussian_profile(xgrid, mu, sigma, amp_minus, xspace) + + # Build replica-wise signed perturbations using fixed up/down + # templates for this flavor. + delta = np.where(signs >= 0.0, gauss_plus[np.newaxis, :], -gauss_minus[np.newaxis, :]) + gv_pert[:, fi, :] += delta elif mode == 'additive': gauss = gaussian_profile(xgrid, mu, sigma, amplitude, xspace) for col, fi in enumerate(local_flavor_idx): diff --git a/validphys2/src/validphys/shapley/runcards/DIS/DIS.yaml b/validphys2/src/validphys/shapley/runcards/DIS/DIS.yaml new file mode 100644 index 0000000000..dbd56823c0 --- /dev/null +++ b/validphys2/src/validphys/shapley/runcards/DIS/DIS.yaml @@ -0,0 +1,110 @@ +# +# Experiment layout +# ----------------- +# x-scan : 5 log-spaced mu values covering [1e-4, 0.5], alpha=-1.0 +# -> produces phi_j(x) Shapley density on the full global fit +# +# sigma is fixed in log10(x) units (xspace: logx) so the bump width is +# constant in decades across the full x range. + +pdf_name: NNPDF40_nnlo_as_01180 +theory_id: 708 +use_cuts: internal +n_replicas: 100 +output_root: sv_results/DIS +log_root: slurm/logs/DIS +run_name: xscan_all +enforce_sumrules: false +per_replica: true +deterministic_sign_symmetrized: true +random_sign: false +stabilization: + enabled: true + action: exclude_dataset + dataset_delta_chi2_threshold: 1e6 + max_outlier_coalitions: 5 + rerun_stable: true +experiments: + + # --- x-scan + + - name: 1e-4 + basis: [flavor] + perturbation: + mu: 0.0001 + sigma: 0.2 + amplitude: 1.0 + mode: calibrated + xspace: logx + + - name: 1e-3 + basis: [flavor] + perturbation: + mu: 0.001 + sigma: 0.3 + amplitude: 1.0 + mode: calibrated + xspace: logx + + - name: 1e-2 + basis: [flavor] + perturbation: + mu: 0.01 + sigma: 0.3 + amplitude: 1.0 + mode: calibrated + xspace: logx + + - name: 1e-1 + basis: [flavor] + perturbation: + mu: 0.1 + sigma: 0.3 + amplitude: 1.0 + mode: calibrated + xspace: logx + + - name: 5e-1 + basis: [flavor] + perturbation: + mu: 0.5 + sigma: 0.2 + amplitude: 1.0 + mode: calibrated + xspace: logx + - name: 8e-1 + basis: [flavor] + perturbation: + mu: 0.8 + sigma: 0.2 + amplitude: 1.0 + mode: calibrated + xspace: logx + +datasets: + # DIS: Fixed-target + - {dataset: NMC_NC_NOTFIXED_EM-F2, variant: legacy_dw} + - {dataset: NMC_NC_NOTFIXED_P_EM-SIGMARED, variant: legacy} + - {dataset: SLAC_NC_NOTFIXED_P_EM-F2, variant: legacy_dw} + - {dataset: SLAC_NC_NOTFIXED_D_EM-F2, variant: legacy_dw} + - {dataset: BCDMS_NC_NOTFIXED_P_EM-F2, variant: legacy_dw} + - {dataset: BCDMS_NC_NOTFIXED_D_EM-F2, variant: legacy_dw} + - {dataset: CHORUS_CC_NOTFIXED_PB_NU-SIGMARED, variant: legacy_dw} + - {dataset: CHORUS_CC_NOTFIXED_PB_NB-SIGMARED, variant: legacy_dw} + - {dataset: NUTEV_CC_NOTFIXED_FE_NU-SIGMARED, cfac: [MAS], variant: legacy_dw} + - {dataset: NUTEV_CC_NOTFIXED_FE_NB-SIGMARED, cfac: [MAS], variant: legacy_dw} + # DIS: HERA combined + - {dataset: HERA_NC_318GEV_EM-SIGMARED, variant: legacy} + - {dataset: HERA_NC_225GEV_EP-SIGMARED, variant: legacy} + - {dataset: HERA_NC_251GEV_EP-SIGMARED, variant: legacy} + - {dataset: HERA_NC_300GEV_EP-SIGMARED, variant: legacy} + - {dataset: HERA_NC_318GEV_EP-SIGMARED, variant: legacy} + - {dataset: HERA_CC_318GEV_EM-SIGMARED, variant: legacy} + - {dataset: HERA_CC_318GEV_EP-SIGMARED, variant: legacy} + - {dataset: HERA_NC_318GEV_EAVG_CHARM-SIGMARED, variant: legacy} + - {dataset: HERA_NC_318GEV_EAVG_BOTTOM-SIGMARED, variant: legacy} + # DY: Fixed-target + - {dataset: DYE866_Z0_800GEV_DW_RATIO_PDXSECRATIO, variant: legacy} + - {dataset: DYE866_Z0_800GEV_PXSEC, variant: legacy} + - {dataset: DYE605_Z0_38P8GEV_DW_PXSEC, variant: legacy} + - {dataset: DYE906_Z0_120GEV_DW_PDXSECRATIO, cfac: [ACC], variant: legacy} \ No newline at end of file diff --git a/validphys2/src/validphys/shapley/runcards/DIS/HERA.yaml b/validphys2/src/validphys/shapley/runcards/DIS/HERA.yaml index a43258e8b6..4ccfe18160 100644 --- a/validphys2/src/validphys/shapley/runcards/DIS/HERA.yaml +++ b/validphys2/src/validphys/shapley/runcards/DIS/HERA.yaml @@ -14,9 +14,10 @@ n_replicas: 100 output_root: sv_results/DIS log_root: slurm/logs/DIS run_name: xscan_hera -per_replica: true -random_sign: true enforce_sumrules: false +per_replica: true +deterministic_sign_symmetrized: true +random_sign: false stabilization: enabled: true action: exclude_dataset diff --git a/validphys2/src/validphys/shapley/runcards/DIS/NU_fixed.yaml b/validphys2/src/validphys/shapley/runcards/DIS/NU_fixed.yaml index c83f458c02..09fda5c0b7 100644 --- a/validphys2/src/validphys/shapley/runcards/DIS/NU_fixed.yaml +++ b/validphys2/src/validphys/shapley/runcards/DIS/NU_fixed.yaml @@ -14,9 +14,10 @@ n_replicas: 100 output_root: sv_results/DIS log_root: slurm/logs/DIS run_name: xscan_nu_fixed -per_replica: true -random_sign: true enforce_sumrules: false +per_replica: true +deterministic_sign_symmetrized: true +random_sign: false stabilization: enabled: true action: exclude_dataset diff --git a/validphys2/src/validphys/shapley/runcards/DY/DY_other.yaml b/validphys2/src/validphys/shapley/runcards/DY/DY_other.yaml index 095834a3d6..0c3c30f704 100644 --- a/validphys2/src/validphys/shapley/runcards/DY/DY_other.yaml +++ b/validphys2/src/validphys/shapley/runcards/DY/DY_other.yaml @@ -14,9 +14,10 @@ n_replicas: 100 output_root: sv_results/DY log_root: slurm/logs/DY run_name: xscan_DY_other -per_replica: true -random_sign: true enforce_sumrules: false +per_replica: true +deterministic_sign_symmetrized: true +random_sign: false stabilization: enabled: true action: exclude_dataset diff --git a/validphys2/src/validphys/shapley/runcards/DY/DY_pt.yaml b/validphys2/src/validphys/shapley/runcards/DY/DY_pt.yaml index 8160274c59..70b0fabb8b 100644 --- a/validphys2/src/validphys/shapley/runcards/DY/DY_pt.yaml +++ b/validphys2/src/validphys/shapley/runcards/DY/DY_pt.yaml @@ -14,9 +14,10 @@ n_replicas: 100 output_root: sv_results/DY log_root: slurm/logs/DY run_name: xscan_DY_pt -per_replica: true -random_sign: true enforce_sumrules: false +per_replica: true +deterministic_sign_symmetrized: true +random_sign: false stabilization: enabled: true action: exclude_dataset diff --git a/validphys2/src/validphys/shapley/runcards/gluon/JET.yaml b/validphys2/src/validphys/shapley/runcards/gluon/JET.yaml index 87004ca079..4dd0985508 100644 --- a/validphys2/src/validphys/shapley/runcards/gluon/JET.yaml +++ b/validphys2/src/validphys/shapley/runcards/gluon/JET.yaml @@ -14,9 +14,10 @@ n_replicas: 100 output_root: sv_results/gluon log_root: slurm/logs/gluon run_name: xscan_jet -per_replica: true -random_sign: true enforce_sumrules: false +per_replica: true +deterministic_sign_symmetrized: true +random_sign: false stabilization: enabled: true action: exclude_dataset diff --git a/validphys2/src/validphys/shapley/runcards/gluon/tt.yaml b/validphys2/src/validphys/shapley/runcards/gluon/tt.yaml index 892d7433d6..6e70ea5f31 100644 --- a/validphys2/src/validphys/shapley/runcards/gluon/tt.yaml +++ b/validphys2/src/validphys/shapley/runcards/gluon/tt.yaml @@ -14,9 +14,10 @@ n_replicas: 100 output_root: sv_results/gluon log_root: slurm/logs/gluon run_name: xscan_tt -per_replica: true -random_sign: true enforce_sumrules: false +per_replica: true +deterministic_sign_symmetrized: true +random_sign: false stabilization: enabled: true action: exclude_dataset diff --git a/validphys2/src/validphys/shapley/runcards/nnpdf4.0_calibrated.yaml b/validphys2/src/validphys/shapley/runcards/nnpdf4.0_calibrated.yaml index 26fc9d622c..0eb6e0c8cb 100644 --- a/validphys2/src/validphys/shapley/runcards/nnpdf4.0_calibrated.yaml +++ b/validphys2/src/validphys/shapley/runcards/nnpdf4.0_calibrated.yaml @@ -14,13 +14,16 @@ n_replicas: 100 output_root: sv_results/nnpdf40_calibrated log_root: slurm/logs/nnpdf40_calibrated run_name: calibrated_xscan -per_replica: true -random_sign: true #turn to false for replica only UQ +per_replica: true + +deterministic_sign_symmetrized: true +random_sign: false + enforce_sumrules: false stabilization: enabled: true action: exclude_dataset - dataset_delta_chi2_threshold: 1e6 + dataset_delta_chi2_threshold: 1e5 max_outlier_coalitions: 5 rerun_stable: true experiments: diff --git a/validphys2/src/validphys/shapley/runcards/nnpdf4.0_calibrated_dense.yaml b/validphys2/src/validphys/shapley/runcards/nnpdf4.0_calibrated_dense.yaml new file mode 100644 index 0000000000..3e4ebc6175 --- /dev/null +++ b/validphys2/src/validphys/shapley/runcards/nnpdf4.0_calibrated_dense.yaml @@ -0,0 +1,278 @@ +# +# Experiment layout +# ----------------- +# dense x-scan : 50 log-spaced mu values covering [1e-4, 0.9] +# -> produces phi_j(x) heatmap inputs on the full global fit +# +# sigma is fixed in log10(x) units (xspace: logx) so the bump width is +# constant in decades across the full x range. + +pdf_name: NNPDF40_nnlo_as_01180 +theory_id: 708 +use_cuts: internal +n_replicas: 100 +output_root: sv_results/nnpdf40_calibrated +log_root: slurm/logs/nnpdf40_calibrated +run_name: calibrated_xscan_dense_evol +per_replica: false + +deterministic_sign_symmetrized: true +random_sign: false + +enforce_sumrules: false +stabilization: + enabled: true + action: exclude_dataset + dataset_delta_chi2_threshold: 1e5 + max_outlier_coalitions: 5 + rerun_stable: true +experiments: + + # --- Dense x-scan at alpha=1.0 (calibrated flavour basis) --------------- + + - name: mu_01 + basis: [evolution] + perturbation: {mu: 0.0001, sigma: 0.25, amplitude: 1.0, mode: calibrated, xspace: logx} + - name: mu_02 + basis: [evolution] + perturbation: {mu: 0.000120420056524, sigma: 0.25, amplitude: 1.0, mode: calibrated, xspace: logx} + - name: mu_03 + basis: [evolution] + perturbation: {mu: 0.000145009900131, sigma: 0.25, amplitude: 1.0, mode: calibrated, xspace: logx} + - name: mu_04 + basis: [evolution] + perturbation: {mu: 0.000174621003703, sigma: 0.25, amplitude: 1.0, mode: calibrated, xspace: logx} + - name: mu_05 + basis: [evolution] + perturbation: {mu: 0.000210278711361, sigma: 0.25, amplitude: 1.0, mode: calibrated, xspace: logx} + - name: mu_06 + basis: [evolution] + perturbation: {mu: 0.000253217743078, sigma: 0.25, amplitude: 1.0, mode: calibrated, xspace: logx} + - name: mu_07 + basis: [evolution] + perturbation: {mu: 0.000304924949343, sigma: 0.25, amplitude: 1.0, mode: calibrated, xspace: logx} + - name: mu_08 + basis: [evolution] + perturbation: {mu: 0.000367190796353, sigma: 0.25, amplitude: 1.0, mode: calibrated, xspace: logx} + - name: mu_09 + basis: [evolution] + perturbation: {mu: 0.000442171364517, sigma: 0.25, amplitude: 1.0, mode: calibrated, xspace: logx} + - name: mu_10 + basis: [evolution] + perturbation: {mu: 0.000532463007083, sigma: 0.25, amplitude: 1.0, mode: calibrated, xspace: logx} + - name: mu_11 + basis: [evolution] + perturbation: {mu: 0.000641192254096, sigma: 0.25, amplitude: 1.0, mode: calibrated, xspace: logx} + - name: mu_12 + basis: [evolution] + perturbation: {mu: 0.000772124074808, sigma: 0.25, amplitude: 1.0, mode: calibrated, xspace: logx} + - name: mu_13 + basis: [evolution] + perturbation: {mu: 0.000929792247316, sigma: 0.25, amplitude: 1.0, mode: calibrated, xspace: logx} + - name: mu_14 + basis: [evolution] + perturbation: {mu: 0.00111965634977, sigma: 0.25, amplitude: 1.0, mode: calibrated, xspace: logx} + - name: mu_15 + basis: [evolution] + perturbation: {mu: 0.00134829080926, sigma: 0.25, amplitude: 1.0, mode: calibrated, xspace: logx} + - name: mu_16 + basis: [evolution] + perturbation: {mu: 0.00162361255462, sigma: 0.25, amplitude: 1.0, mode: calibrated, xspace: logx} + - name: mu_17 + basis: [evolution] + perturbation: {mu: 0.00195515515599, sigma: 0.25, amplitude: 1.0, mode: calibrated, xspace: logx} + - name: mu_18 + basis: [evolution] + perturbation: {mu: 0.00235439894397, sigma: 0.25, amplitude: 1.0, mode: calibrated, xspace: logx} + - name: mu_19 + basis: [evolution] + perturbation: {mu: 0.00283516853912, sigma: 0.25, amplitude: 1.0, mode: calibrated, xspace: logx} + - name: mu_20 + basis: [evolution] + perturbation: {mu: 0.00341411155735, sigma: 0.25, amplitude: 1.0, mode: calibrated, xspace: logx} + - name: mu_21 + basis: [evolution] + perturbation: {mu: 0.00411127506713, sigma: 0.25, amplitude: 1.0, mode: calibrated, xspace: logx} + - name: mu_22 + basis: [evolution] + perturbation: {mu: 0.00495079975968, sigma: 0.25, amplitude: 1.0, mode: calibrated, xspace: logx} + - name: mu_23 + basis: [evolution] + perturbation: {mu: 0.00596175586898, sigma: 0.25, amplitude: 1.0, mode: calibrated, xspace: logx} + - name: mu_24 + basis: [evolution] + perturbation: {mu: 0.00717914978722, sigma: 0.25, amplitude: 1.0, mode: calibrated, xspace: logx} + - name: mu_25 + basis: [evolution] + perturbation: {mu: 0.00864513623168, sigma: 0.25, amplitude: 1.0, mode: calibrated, xspace: logx} + - name: mu_26 + basis: [evolution] + perturbation: {mu: 0.0104104779367, sigma: 0.25, amplitude: 1.0, mode: calibrated, xspace: logx} + - name: mu_27 + basis: [evolution] + perturbation: {mu: 0.0125363034158, sigma: 0.25, amplitude: 1.0, mode: calibrated, xspace: logx} + - name: mu_28 + basis: [evolution] + perturbation: {mu: 0.0150962236593, sigma: 0.25, amplitude: 1.0, mode: calibrated, xspace: logx} + - name: mu_29 + basis: [evolution] + perturbation: {mu: 0.0181788810634, sigma: 0.25, amplitude: 1.0, mode: calibrated, xspace: logx} + - name: mu_30 + basis: [evolution] + perturbation: {mu: 0.0218910188519, sigma: 0.25, amplitude: 1.0, mode: calibrated, xspace: logx} + - name: mu_31 + basis: [evolution] + perturbation: {mu: 0.0263611772751, sigma: 0.25, amplitude: 1.0, mode: calibrated, xspace: logx} + - name: mu_32 + basis: [evolution] + perturbation: {mu: 0.0317441445749, sigma: 0.25, amplitude: 1.0, mode: calibrated, xspace: logx} + - name: mu_33 + basis: [evolution] + perturbation: {mu: 0.03822631684, sigma: 0.25, amplitude: 1.0, mode: calibrated, xspace: logx} + - name: mu_34 + basis: [evolution] + perturbation: {mu: 0.0460321523456, sigma: 0.25, amplitude: 1.0, mode: calibrated, xspace: logx} + - name: mu_35 + basis: [evolution] + perturbation: {mu: 0.0554319438736, sigma: 0.25, amplitude: 1.0, mode: calibrated, xspace: logx} + - name: mu_36 + basis: [evolution] + perturbation: {mu: 0.0667511781448, sigma: 0.25, amplitude: 1.0, mode: calibrated, xspace: logx} + - name: mu_37 + basis: [evolution] + perturbation: {mu: 0.0803818064521, sigma: 0.25, amplitude: 1.0, mode: calibrated, xspace: logx} + - name: mu_38 + basis: [evolution] + perturbation: {mu: 0.0967958167643, sigma: 0.25, amplitude: 1.0, mode: calibrated, xspace: logx} + - name: mu_39 + basis: [evolution] + perturbation: {mu: 0.11656157726, sigma: 0.25, amplitude: 1.0, mode: calibrated, xspace: logx} + - name: mu_40 + basis: [evolution] + perturbation: {mu: 0.140363517221, sigma: 0.25, amplitude: 1.0, mode: calibrated, xspace: logx} + - name: mu_41 + basis: [evolution] + perturbation: {mu: 0.169025826776, sigma: 0.25, amplitude: 1.0, mode: calibrated, xspace: logx} + - name: mu_42 + basis: [evolution] + perturbation: {mu: 0.203540996143, sigma: 0.25, amplitude: 1.0, mode: calibrated, xspace: logx} + - name: mu_43 + basis: [evolution] + perturbation: {mu: 0.245104182605, sigma: 0.25, amplitude: 1.0, mode: calibrated, xspace: logx} + - name: mu_44 + basis: [evolution] + perturbation: {mu: 0.295154595234, sigma: 0.25, amplitude: 1.0, mode: calibrated, xspace: logx} + - name: mu_45 + basis: [evolution] + perturbation: {mu: 0.355425330413, sigma: 0.25, amplitude: 1.0, mode: calibrated, xspace: logx} + - name: mu_46 + basis: [evolution] + perturbation: {mu: 0.428003383782, sigma: 0.25, amplitude: 1.0, mode: calibrated, xspace: logx} + - name: mu_47 + basis: [evolution] + perturbation: {mu: 0.515401916674, sigma: 0.25, amplitude: 1.0, mode: calibrated, xspace: logx} + - name: mu_48 + basis: [evolution] + perturbation: {mu: 0.620647279382, sigma: 0.25, amplitude: 1.0, mode: calibrated, xspace: logx} + - name: mu_49 + basis: [evolution] + perturbation: {mu: 0.747383804644, sigma: 0.25, amplitude: 1.0, mode: calibrated, xspace: logx} + - name: mu_50 + basis: [evolution] + perturbation: {mu: 0.9, sigma: 0.25, amplitude: 1.0, mode: calibrated, xspace: logx} + +datasets: + # DIS: Fixed-target + - {dataset: NMC_NC_NOTFIXED_EM-F2, variant: legacy_dw} + - {dataset: NMC_NC_NOTFIXED_P_EM-SIGMARED, variant: legacy} + - {dataset: SLAC_NC_NOTFIXED_P_EM-F2, variant: legacy_dw} + - {dataset: SLAC_NC_NOTFIXED_D_EM-F2, variant: legacy_dw} + - {dataset: BCDMS_NC_NOTFIXED_P_EM-F2, variant: legacy_dw} + - {dataset: BCDMS_NC_NOTFIXED_D_EM-F2, variant: legacy_dw} + - {dataset: CHORUS_CC_NOTFIXED_PB_NU-SIGMARED, variant: legacy_dw} + - {dataset: CHORUS_CC_NOTFIXED_PB_NB-SIGMARED, variant: legacy_dw} + - {dataset: NUTEV_CC_NOTFIXED_FE_NU-SIGMARED, cfac: [MAS], variant: legacy_dw} + - {dataset: NUTEV_CC_NOTFIXED_FE_NB-SIGMARED, cfac: [MAS], variant: legacy_dw} + # DIS: HERA combined + - {dataset: HERA_NC_318GEV_EM-SIGMARED, variant: legacy} + - {dataset: HERA_NC_225GEV_EP-SIGMARED, variant: legacy} + - {dataset: HERA_NC_251GEV_EP-SIGMARED, variant: legacy} + - {dataset: HERA_NC_300GEV_EP-SIGMARED, variant: legacy} + - {dataset: HERA_NC_318GEV_EP-SIGMARED, variant: legacy} + - {dataset: HERA_CC_318GEV_EM-SIGMARED, variant: legacy} + - {dataset: HERA_CC_318GEV_EP-SIGMARED, variant: legacy} + - {dataset: HERA_NC_318GEV_EAVG_CHARM-SIGMARED, variant: legacy} + - {dataset: HERA_NC_318GEV_EAVG_BOTTOM-SIGMARED, variant: legacy} + # DY: Fixed-target + - {dataset: DYE866_Z0_800GEV_DW_RATIO_PDXSECRATIO, variant: legacy} + - {dataset: DYE866_Z0_800GEV_PXSEC, variant: legacy} + - {dataset: DYE605_Z0_38P8GEV_DW_PXSEC, variant: legacy} + - {dataset: DYE906_Z0_120GEV_DW_PDXSECRATIO, cfac: [ACC], variant: legacy} + # DY: Tevatron + - {dataset: CDF_Z0_1P96TEV_ZRAP, variant: legacy} + - {dataset: D0_Z0_1P96TEV_ZRAP, variant: legacy} + - {dataset: D0_WPWM_1P96TEV_ASY, variant: legacy} + # DY: ATLAS + - {dataset: ATLAS_WPWM_7TEV_36PB_ETA, variant: legacy} + - {dataset: ATLAS_Z0_7TEV_36PB_ETA, variant: legacy} + - {dataset: ATLAS_Z0_7TEV_49FB_HIMASS, variant: legacy} + - {dataset: ATLAS_Z0_7TEV_LOMASS_M, variant: legacy} + - {dataset: ATLAS_WPWM_7TEV_46FB_CC-ETA, variant: legacy} + - {dataset: ATLAS_Z0_7TEV_46FB_CC-Y, variant: legacy} + - {dataset: ATLAS_Z0_7TEV_46FB_CF-Y, variant: legacy} + - {dataset: ATLAS_Z0_8TEV_HIMASS_M-Y, variant: legacy} + - {dataset: ATLAS_Z0_8TEV_LOWMASS_M-Y, variant: legacy} + - {dataset: ATLAS_Z0_13TEV_TOT, cfac: [NRM], variant: legacy} + - {dataset: ATLAS_WPWM_13TEV_TOT, cfac: [NRM], variant: legacy} + - {dataset: ATLAS_WJ_8TEV_WP-PT, variant: legacy} + - {dataset: ATLAS_WJ_8TEV_WM-PT, variant: legacy} + - {dataset: ATLAS_Z0J_8TEV_PT-M, variant: legacy_10} + - {dataset: ATLAS_Z0J_8TEV_PT-Y, variant: legacy_10} + # DY: CMS + - CMS_WPWM_7TEV_ELECTRON_ASY + - {dataset: CMS_WPWM_7TEV_MUON_ASY, variant: legacy} + - CMS_Z0_7TEV_DIMUON_2D + - {dataset: CMS_WPWM_8TEV_MUON_Y, variant: legacy} + - {dataset: CMS_Z0J_8TEV_PT-Y, cfac: [NRM], variant: legacy_10} + # DY: LHCb + - LHCB_Z0_7TEV_DIELECTRON_Y + - LHCB_Z0_8TEV_DIELECTRON_Y + - {dataset: LHCB_WPWM_7TEV_MUON_Y, cfac: [NRM]} + - {dataset: LHCB_Z0_7TEV_MUON_Y, cfac: [NRM]} + - {dataset: LHCB_WPWM_8TEV_MUON_Y, cfac: [NRM]} + - {dataset: LHCB_Z0_8TEV_MUON_Y, cfac: [NRM]} + - LHCB_Z0_13TEV_DIMUON-Y + - LHCB_Z0_13TEV_DIELECTRON-Y + # Top: ttbar total cross-sections + - {dataset: ATLAS_TTBAR_7TEV_TOT_X-SEC, variant: legacy} + - {dataset: ATLAS_TTBAR_8TEV_TOT_X-SEC, variant: legacy} + - {dataset: ATLAS_TTBAR_13TEV_TOT_X-SEC, variant: legacy} + - {dataset: CMS_TTBAR_7TEV_TOT_X-SEC, variant: legacy} + - {dataset: CMS_TTBAR_8TEV_TOT_X-SEC, variant: legacy} + - {dataset: CMS_TTBAR_13TEV_TOT_X-SEC, variant: legacy} + - {dataset: CMS_TTBAR_5TEV_TOT_X-SEC, variant: legacy} + # Top: ttbar differential + - {dataset: ATLAS_TTBAR_8TEV_LJ_DIF_YT-NORM, variant: legacy} + - {dataset: ATLAS_TTBAR_8TEV_LJ_DIF_YTTBAR-NORM, variant: legacy} + - {dataset: ATLAS_TTBAR_8TEV_2L_DIF_YTTBAR-NORM, variant: legacy} + - {dataset: CMS_TTBAR_8TEV_LJ_DIF_YTTBAR-NORM, variant: legacy} + - {dataset: CMS_TTBAR_8TEV_2L_DIF_MTTBAR-YT-NORM, variant: legacy} + - {dataset: CMS_TTBAR_13TEV_2L_DIF_YT, variant: legacy} + - {dataset: CMS_TTBAR_13TEV_LJ_2016_DIF_YT, variant: legacy} + # Jets + - {dataset: ATLAS_1JET_8TEV_R06_PTY, variant: legacy_decorrelated} + - {dataset: ATLAS_2JET_7TEV_R06_M12Y, variant: legacy} + - {dataset: CMS_2JET_7TEV_M12-Y, variant: legacy} + - {dataset: CMS_1JET_8TEV_PTY, variant: legacy} + # Prompt photon + - {dataset: ATLAS_PH_13TEV_XSEC, cfac: [EWK], variant: legacy} + # Single top + - {dataset: ATLAS_SINGLETOP_7TEV_TCHANNEL-XSEC, variant: legacy} + - {dataset: ATLAS_SINGLETOP_13TEV_TCHANNEL-XSEC, variant: legacy} + - {dataset: ATLAS_SINGLETOP_7TEV_T-Y-NORM, variant: legacy} + - {dataset: ATLAS_SINGLETOP_7TEV_TBAR-Y-NORM, variant: legacy} + - {dataset: ATLAS_SINGLETOP_8TEV_T-RAP-NORM, variant: legacy} + - {dataset: ATLAS_SINGLETOP_8TEV_TBAR-RAP-NORM, variant: legacy} + - {dataset: CMS_SINGLETOP_7TEV_TCHANNEL-XSEC, variant: legacy} + - {dataset: CMS_SINGLETOP_8TEV_TCHANNEL-XSEC, variant: legacy} + - {dataset: CMS_SINGLETOP_13TEV_TCHANNEL-XSEC, variant: legacy} diff --git a/validphys2/src/validphys/shapley/runcards/nnpdf4.0_calibrated_evol.yaml b/validphys2/src/validphys/shapley/runcards/nnpdf4.0_calibrated_evol.yaml index 90dc6b78da..0688a34da5 100644 --- a/validphys2/src/validphys/shapley/runcards/nnpdf4.0_calibrated_evol.yaml +++ b/validphys2/src/validphys/shapley/runcards/nnpdf4.0_calibrated_evol.yaml @@ -13,11 +13,12 @@ use_cuts: internal n_replicas: 100 output_root: sv_results/nnpdf40_calibrated log_root: slurm/logs/nnpdf40_calibrated -run_name: calibrated_xscan_ev_ +run_name: calibrated_xscan_ev enforce_sumrules: false -per_replica: true -random_sign: true +per_replica: true +deterministic_sign_symmetrized: true +random_sign: false stabilization: enabled: true action: exclude_dataset diff --git a/validphys2/src/validphys/shapley/scripts/vp_shapley.py b/validphys2/src/validphys/shapley/scripts/vp_shapley.py index f0dc2f4a7c..eb538464ff 100644 --- a/validphys2/src/validphys/shapley/scripts/vp_shapley.py +++ b/validphys2/src/validphys/shapley/scripts/vp_shapley.py @@ -18,6 +18,7 @@ matplotlib.use('Agg') import matplotlib.pyplot as plt import matplotlib.transforms as mtransforms +from matplotlib.colors import LogNorm, SymLogNorm import numpy as np import yaml @@ -34,14 +35,14 @@ "#E45756", "#F58518", "#EECA3B", - "#71BD00", + "#71BD00B5", "#72B7B2", "#4C78A8", "#B279A2", - "#9D755D", - "#FF9DA6", - "#BAB0AC", + "#6F4C9B", + "#BAB0AC" ] + _SERIES_MARKERS = ["o", "s", "D", "^", "v", "P", "X", "<", ">", "h"] _SOFT_POSITIVE_COLOR = "#518500" _SOFT_NEGATIVE_COLOR = "#FFBF00" @@ -360,6 +361,7 @@ def _plot_sv_scan_comparison( label=flav, zorder=3, ) + dx_pt = float(dodge_offsets_pt[i]) if dx_pt != 0.0: shift = mtransforms.ScaledTranslation( @@ -397,6 +399,7 @@ def _plot_sv_scan_comparison( ncol=1, borderaxespad=0.0, ) + fig.tight_layout(rect=[0, 0, 0.82, 1]) png_path = output_dir / f"{output_stem}_{basis}.png" @@ -429,6 +432,8 @@ def _plot_sv_bar_comparison( exp_names_ordered, output_dir, experiment_meta, + output_stem="shapley_comparison_bars", + title_tag="even", ): """Multi-panel bar comparisons across experiments.""" n = len(exp_names_ordered) @@ -468,11 +473,14 @@ def _plot_sv_bar_comparison( for ax in axes_flat[n:]: ax.set_visible(False) - fig.suptitle(f"Shapley bar comparison ({basis} basis)", y=0.995) + fig.suptitle( + f"Shapley bar comparison ({basis} basis, {title_tag})", y=0.995 + ) + fig.tight_layout(rect=[0, 0, 1, 0.98]) - png_path = output_dir / f"shapley_comparison_bars_{basis}.png" - pdf_path = output_dir / f"shapley_comparison_bars_{basis}.pdf" + png_path = output_dir / f"{output_stem}_{basis}.png" + pdf_path = output_dir / f"{output_stem}_{basis}.pdf" fig.savefig(png_path, dpi=220, bbox_inches="tight") fig.savefig(pdf_path, bbox_inches="tight") plt.close(fig) @@ -503,69 +511,291 @@ def _save_comparison_plots(all_experiment_results, output_dir, experiment_meta): exp_names_ordered = [exp_names[i] for i in order_bins] for basis in basis_names: - labels = None - for exp_name in exp_names: - if basis in all_experiment_results[exp_name]: - labels = list(all_experiment_results[exp_name][basis]["shapley_values"].keys()) - break - if labels is None: - continue + basis_entries = [ + all_experiment_results[exp_name].get(basis, {}) + for exp_name in exp_names + if basis in all_experiment_results[exp_name] + ] + deterministic_basis = bool(basis_entries) and all( + bool(entry.get("deterministic_sign_symmetrized", False)) + for entry in basis_entries + ) + replica_basis = bool(basis_entries) and all( + bool(entry.get("per_replica", False)) + for entry in basis_entries + ) + if deterministic_basis and replica_basis: + mode_tag = "det_rep" + elif deterministic_basis: + mode_tag = "det" + elif replica_basis: + mode_tag = "rep" + else: + mode_tag = "pert" + + def _plot_game(value_key, std_key, err_key, stem_tag, title_tag): + labels = None + for exp_name in exp_names: + if basis in all_experiment_results[exp_name]: + labels = list( + (all_experiment_results[exp_name][basis].get(value_key) or {}).keys() + ) + if labels: + break + if labels is None: + return + + sv_rows = [] + err_rows = [] + for exp_name in exp_names: + basis_results = all_experiment_results[exp_name].get(basis, {}) + sv_map = basis_results.get(value_key, {}) or {} + err_map = ( + basis_results.get(std_key) + or basis_results.get(err_key) + or {} + ) + sv_rows.append( + np.array([float(sv_map.get(lbl, 0.0)) for lbl in labels]) + ) + err_rows.append( + np.array([float(err_map.get(lbl, np.nan)) for lbl in labels]) + if err_map else np.full(len(labels), np.nan) + ) - sv_rows = [] - err_rows = [] - for exp_name in exp_names: - basis_results = all_experiment_results[exp_name].get(basis, {}) - sv_map = basis_results.get("shapley_values", {}) - err_map = ( - basis_results.get("shapley_std") - or basis_results.get("shapley_err") - or {} + sv_matrix_bins = np.asarray(sv_rows, dtype=float)[order_bins, :] + err_matrix_bins = np.asarray(err_rows, dtype=float)[order_bins, :] + _plot_sv_scan_comparison( + sv_matrix=sv_matrix_bins, + err_matrix=err_matrix_bins, + labels=labels, + basis=basis, + output_dir=output_dir, + axis_info=axis_info_bins, + output_stem=f"shapley_comparison_{stem_tag}", + title_suffix=f"{title_tag}, binned x, dodged points", + dodge_step_pt=4.5, + use_dodge=True, ) - sv_rows.append(np.array([float(sv_map.get(lbl, 0.0)) for lbl in labels])) - err_rows.append( - np.array([float(err_map.get(lbl, np.nan)) for lbl in labels]) - if err_map else np.full(len(labels), np.nan) + + order_truex = axis_info_truex["order"] + sv_matrix_truex = np.asarray(sv_rows, dtype=float)[order_truex, :] + err_matrix_truex = np.asarray(err_rows, dtype=float)[order_truex, :] + _plot_sv_scan_comparison( + sv_matrix=sv_matrix_truex, + err_matrix=err_matrix_truex, + labels=labels, + basis=basis, + output_dir=output_dir, + axis_info=axis_info_truex, + output_stem=f"shapley_comparison_truex_{stem_tag}", + title_suffix=f"{title_tag}, true x, overlapping", + use_dodge=False, ) - sv_matrix_bins = np.asarray(sv_rows, dtype=float)[order_bins, :] - err_matrix_bins = np.asarray(err_rows, dtype=float)[order_bins, :] - _plot_sv_scan_comparison( - sv_matrix=sv_matrix_bins, - err_matrix=err_matrix_bins, - labels=labels, - basis=basis, - output_dir=output_dir, - axis_info=axis_info_bins, - output_stem="shapley_comparison", - title_suffix="binned x, dodged points", - dodge_step_pt=4.5, - use_dodge=True, - ) - order_truex = axis_info_truex["order"] - sv_matrix_truex = np.asarray(sv_rows, dtype=float)[order_truex, :] - err_matrix_truex = np.asarray(err_rows, dtype=float)[order_truex, :] - _plot_sv_scan_comparison( - sv_matrix=sv_matrix_truex, - err_matrix=err_matrix_truex, - labels=labels, - basis=basis, - output_dir=output_dir, - axis_info=axis_info_truex, - output_stem="shapley_comparison_truex", - title_suffix="true x, overlapping", - use_dodge=False, + _plot_sv_bar_comparison( + sv_matrix=sv_matrix_bins, + err_matrix=err_matrix_bins, + labels=labels, + basis=basis, + exp_names_ordered=exp_names_ordered, + output_dir=output_dir, + experiment_meta=experiment_meta, + output_stem=f"shapley_comparison_bars_{stem_tag}", + title_tag=title_tag, + ) + + _plot_game( + value_key="shapley_values", + std_key="shapley_std", + err_key="shapley_err", + stem_tag=mode_tag, + title_tag=mode_tag, ) - _plot_sv_bar_comparison( - sv_matrix=sv_matrix_bins, - err_matrix=err_matrix_bins, - labels=labels, - basis=basis, - exp_names_ordered=exp_names_ordered, + + _save_dense_flavor_heatmap( + all_experiment_results=all_experiment_results, output_dir=output_dir, experiment_meta=experiment_meta, + basis=basis, + mode_tag=mode_tag, ) +def _compute_log_bin_edges(xvals): + """Compute log-spaced bin edges around sorted positive x centers.""" + x = np.asarray(xvals, dtype=float) + if x.ndim != 1 or x.size == 0: + raise ValueError("xvals must be a non-empty 1D array") + if not np.all(x > 0.0): + raise ValueError("xvals must be strictly positive for log edges") + + if x.size == 1: + return np.asarray([x[0] / np.sqrt(10.0), x[0] * np.sqrt(10.0)], dtype=float) + + logx = np.log10(x) + mids = 0.5 * (logx[:-1] + logx[1:]) + edges = np.empty(x.size + 1, dtype=float) + edges[1:-1] = mids + edges[0] = logx[0] - (mids[0] - logx[0]) + edges[-1] = logx[-1] + (logx[-1] - mids[-1]) + return np.power(10.0, edges) + + +def _save_dense_flavor_heatmap( + all_experiment_results, + output_dir, + experiment_meta, + basis, + mode_tag="pert", +): + """Save dense flavor x-scan heatmap (+ global |phi| band).""" + # Keep this output focused on dense scans so existing coarse workflows stay unchanged. + if len(all_experiment_results) < 10: + return + + exp_names = list(all_experiment_results.keys()) + usable = [] + for exp_name in exp_names: + basis_results = all_experiment_results.get(exp_name, {}).get(basis) + if not basis_results: + continue + pert = (experiment_meta.get(exp_name) or {}).get("perturbation", {}) + try: + mu = float(pert.get("mu")) + except (TypeError, ValueError): + continue + + phi_even_map = basis_results.get("phi_even") or basis_results.get("shapley_values") or {} + if not phi_even_map: + continue + usable.append((exp_name, mu, phi_even_map)) + + if len(usable) < 2: + return + + usable.sort(key=lambda item: item[1]) + mu_sorted = np.asarray([item[1] for item in usable], dtype=float) + labels = list(usable[0][2].keys()) + n_labels = len(labels) + + phi_matrix = np.full((n_labels, len(usable)), np.nan, dtype=float) + for col, (_, _, phi_map) in enumerate(usable): + for row, label in enumerate(labels): + val = phi_map.get(label) + if val is not None: + phi_matrix[row, col] = float(val) + + global_importance = np.nanmean(np.abs(phi_matrix), axis=0) + if not np.any(np.isfinite(phi_matrix)): + return + + x_edges = _compute_log_bin_edges(mu_sorted) + y_edges_top = np.arange(n_labels + 1, dtype=float) + y_edges_bottom = np.array([0.0, 1.0], dtype=float) + + with matplotlib.rc_context( + { + "font.size": 11, + "axes.labelsize": 12, + "axes.titlesize": 13, + "xtick.labelsize": 10, + "ytick.labelsize": 10, + } + ): + fig, (ax_top, ax_bottom) = plt.subplots( + 2, + 1, + figsize=(12.5, 6.6), + sharex=True, + gridspec_kw={"height_ratios": [9.0, 1.35], "hspace": 0.08}, + ) + + finite_abs = np.abs(phi_matrix[np.isfinite(phi_matrix)]) + absmax = float(np.max(finite_abs)) if finite_abs.size else 0.0 + if absmax <= 0.0: + absmax = 1e-12 + nonzero_abs = finite_abs[finite_abs > 0.0] + if nonzero_abs.size: + # Symlog keeps sign while expanding contrast around small magnitudes. + linthresh = float(np.percentile(nonzero_abs, 25.0)) + linthresh = max(min(linthresh, absmax), 1e-12) + else: + linthresh = 1e-12 + + top_mesh = ax_top.pcolormesh( + x_edges, + y_edges_top, + phi_matrix, + cmap="RdBu_r", + norm=SymLogNorm( + linthresh=linthresh, + linscale=1.0, + vmin=-absmax, + vmax=absmax, + base=10.0, + ), + shading="auto", + ) + + global_2d = global_importance[np.newaxis, :] + gmax = float(np.nanmax(global_2d)) if np.any(np.isfinite(global_2d)) else 0.0 + if gmax <= 0.0: + gmax = 1e-12 + pos_global = global_2d[np.isfinite(global_2d) & (global_2d > 0.0)] + gmin = float(np.min(pos_global)) if pos_global.size else 1e-12 + gmin = min(gmin, gmax) + bot_mesh = ax_bottom.pcolormesh( + x_edges, + y_edges_bottom, + global_2d, + cmap="YlGnBu", + norm=LogNorm(vmin=max(gmin, 1e-12), vmax=max(gmax, gmin, 1e-12)), + shading="auto", + ) + + ax_top.set_xscale("log") + ax_bottom.set_xscale("log") + ax_top.set_xlim(float(x_edges[0]), float(x_edges[-1])) + + ax_top.set_yticks(np.arange(n_labels, dtype=float) + 0.5) + ax_top.set_yticklabels(labels) + ax_top.invert_yaxis() + ax_top.set_ylabel("flavor") + top_tag = f"signed {mode_tag}" + ax_top.set_title(f"Dense x-scan heatmap ({top_tag})") + + ax_bottom.set_yticks([0.5]) + ax_bottom.set_yticklabels(["global"]) + ax_bottom.invert_yaxis() + ax_bottom.set_ylabel("band") + + # Use true mu geometry (log-scaled x edges). To keep labels readable, + # only show a subset of exact mu tick labels. + n_ticks = min(10, len(mu_sorted)) + tick_idx = np.unique(np.linspace(0, len(mu_sorted) - 1, num=n_ticks, dtype=int)) + tick_vals = mu_sorted[tick_idx] + ax_bottom.set_xticks(tick_vals) + ax_bottom.set_xticklabels([_format_axis_tick(v) for v in tick_vals], rotation=30, ha="right") + ax_bottom.set_xlabel("perturbation center x (mu)") + + cbar_top = fig.colorbar(top_mesh, ax=ax_top, pad=0.015) + cbar_top.set_label(f"signed {mode_tag} (symlog)") + cbar_bottom = fig.colorbar(bot_mesh, ax=ax_bottom, pad=0.015) + cbar_bottom.set_label("mean_j |phi_j(x)| (log)") + + fig.subplots_adjust(left=0.08, right=0.92, bottom=0.14, top=0.94, hspace=0.08) + + stem = f"shapley_dense_heatmap_{mode_tag}" + png_path = output_dir / f"{stem}_{basis}.png" + pdf_path = output_dir / f"{stem}_{basis}.pdf" + fig.savefig(png_path, dpi=220, bbox_inches="tight") + fig.savefig(pdf_path, bbox_inches="tight") + plt.close(fig) + print(f"Saved comparison plot: {png_path}") + print(f"Saved comparison plot: {pdf_path}") + + def _save_diagnostic_files(diag, output_dir, basis): """Write per-coalition chi2 CSV, marginal-contribution CSV, and stats JSON. @@ -1006,34 +1236,38 @@ def run_analysis(cfg, output_dir, setup_context, n_jobs_override=None, per_replica = bool( pert.get("per_replica", cfg.get("per_replica", False)) ) - # Random sign: draw a fixed sign for each replica/flavour for the run. + deterministic_sign_symmetrized = bool( + pert.get( + "deterministic_sign_symmetrized", + cfg.get("deterministic_sign_symmetrized", True), + ) + ) random_sign = bool( pert.get("random_sign", cfg.get("random_sign", False)) ) n_sign_samples = int( pert.get("n_sign_samples", cfg.get("n_sign_samples", 1)) ) + if deterministic_sign_symmetrized and random_sign: + print( + "Note: ignoring random_sign=True; using deterministic calibrated up/down games." + ) + if deterministic_sign_symmetrized and n_sign_samples != 1: + print( + "Note: ignoring n_sign_samples=" + f"{n_sign_samples}; deterministic dual game uses one fixed definition." + ) random_seed = pert.get("random_seed", cfg.get("random_seed")) - expected_member_mode = "replicas" if per_replica else "central" explicit_member_mode = pert.get("member_mode", cfg.get("member_mode")) if explicit_member_mode is not None: member_mode = str(explicit_member_mode).strip().lower() - if member_mode != expected_member_mode: + if member_mode not in {"replicas", "central"}: raise ValueError( - "member_mode is redundant with per_replica and must match it: " - f"expected '{expected_member_mode}', got '{member_mode}'." + "member_mode must be 'replicas' or 'central'; " + f"got '{member_mode}'." ) else: - member_mode = expected_member_mode - if not random_sign: - n_sign_samples = 1 - elif per_replica: - if n_sign_samples != 1: - print( - "Note: per_replica=True uses one fixed sign mask per replica; " - f"ignoring n_sign_samples={n_sign_samples} and using 1." - ) - n_sign_samples = 1 + member_mode = "replicas" if per_replica else "central" enforce_sumrules = cfg.get("enforce_sumrules", False) n_jobs = int(cfg.get("n_jobs", 1)) if n_jobs_override is not None: @@ -1098,6 +1332,7 @@ def run_analysis(cfg, output_dir, setup_context, n_jobs_override=None, per_replica=per_replica, random_sign=random_sign, n_sign_samples=n_sign_samples, random_seed=random_seed, + deterministic_sign_symmetrized=deterministic_sign_symmetrized, ) stabilization_report = None stabilization_json = None @@ -1147,6 +1382,7 @@ def run_analysis(cfg, output_dir, setup_context, n_jobs_override=None, per_replica=per_replica, random_sign=random_sign, n_sign_samples=n_sign_samples, random_seed=random_seed, + deterministic_sign_symmetrized=deterministic_sign_symmetrized, ) stable_rerun_performed = True observables_used = kept @@ -1174,21 +1410,44 @@ def run_analysis(cfg, output_dir, setup_context, n_jobs_override=None, labels = results_final["flavor_short"] sv = results_final["shapley_values"] + sv_odd = results_final.get("shapley_values_odd") csv_path = output_dir / f"shapley_values_{basis}.csv" _write_shapley_csv(csv_path, labels, sv) print(f"Saved: {csv_path}") + if sv_odd is not None: + csv_odd_path = output_dir / f"shapley_values_odd_{basis}.csv" + _write_shapley_csv(csv_odd_path, labels, sv_odd) + print(f"Saved: {csv_odd_path}") # Sampling-axis outputs. sv_per_replica = results_final.get("shapley_values_per_replica") + sv_odd_per_replica = results_final.get("shapley_values_odd_per_replica") + sv_odd_signed_per_replica = results_final.get("shapley_values_odd_signed_per_replica") sv_per_sample = results_final.get("shapley_values_per_sign_sample") sv_std = results_final.get("shapley_std") sv_err = results_final.get("shapley_err") + sv_odd_std = results_final.get("shapley_odd_std") + sv_odd_err = results_final.get("shapley_odd_err") sv_sign_std = results_final.get("shapley_sign_std") sv_sign_err = results_final.get("shapley_sign_err") if per_replica and sv_per_replica is not None: per_rep_path = output_dir / f"shapley_values_per_replica_{basis}.csv" _write_shapley_per_replica_csv(per_rep_path, labels, sv_per_replica) print(f"Saved: {per_rep_path}") + if per_replica and sv_odd_per_replica is not None: + per_rep_odd_path = output_dir / f"shapley_values_odd_per_replica_{basis}.csv" + _write_shapley_per_replica_csv( + per_rep_odd_path, labels, sv_odd_per_replica + ) + print(f"Saved: {per_rep_odd_path}") + if per_replica and sv_odd_signed_per_replica is not None: + per_rep_odd_signed_path = ( + output_dir / f"shapley_values_odd_signed_per_replica_{basis}.csv" + ) + _write_shapley_per_replica_csv( + per_rep_odd_signed_path, labels, sv_odd_signed_per_replica + ) + print(f"Saved: {per_rep_odd_signed_path}") if sv_per_sample is not None: per_sample_path = output_dir / f"shapley_values_per_sign_sample_{basis}.csv" _write_shapley_per_sample_csv(per_sample_path, labels, sv_per_sample) @@ -1207,6 +1466,7 @@ def run_analysis(cfg, output_dir, setup_context, n_jobs_override=None, f"{lbl},{float(mean_v):.8f},{float(std_v):.8f},{float(err_v):.8f}\n" ) print(f"Saved: {unc_path}") + # Odd metric is the sign-sensitivity S_abs = <|phi_odd|>; no odd variance file. if sv_sign_std is not None: sign_unc_path = output_dir / f"shapley_sign_uncertainties_{basis}.csv" with open(sign_unc_path, "w") as f: @@ -1235,9 +1495,31 @@ def run_analysis(cfg, output_dir, setup_context, n_jobs_override=None, all_results[basis] = { "shapley_values": {l: float(v) for l, v in zip(labels, sv)}, + "phi_even": {l: float(v) for l, v in zip(labels, sv)}, + "phi_odd": ( + {l: float(v) for l, v in zip(labels, sv_odd)} + if sv_odd is not None else None + ), + "phi_odd_signed": ( + {l: float(v) for l, v in zip(labels, results_final.get("shapley_values_odd_signed", []))} + if results_final.get("shapley_values_odd_signed") is not None else None + ), + "sign_sensitivity_abs": ( + {l: float(v) for l, v in zip(labels, sv_odd)} + if sv_odd is not None else None + ), "shapley_values_per_replica": _serialize_shapley_per_replica( labels, sv_per_replica ), + "phi_even_per_replica": _serialize_shapley_per_replica( + labels, sv_per_replica + ), + "phi_odd_per_replica": _serialize_shapley_per_replica( + labels, sv_odd_per_replica + ), + "phi_odd_signed_per_replica": _serialize_shapley_per_replica( + labels, sv_odd_signed_per_replica + ), "shapley_values_per_sign_sample": _serialize_shapley_per_sample( labels, sv_per_sample ), @@ -1245,10 +1527,30 @@ def run_analysis(cfg, output_dir, setup_context, n_jobs_override=None, {l: float(v) for l, v in zip(labels, sv_std)} if sv_std is not None else None ), + "std_even_rep": ( + {l: float(v) for l, v in zip(labels, sv_std)} + if sv_std is not None else None + ), "shapley_err": ( {l: float(v) for l, v in zip(labels, sv_err)} if sv_err is not None else None ), + "shapley_values_odd": ( + {l: float(v) for l, v in zip(labels, sv_odd)} + if sv_odd is not None else None + ), + "shapley_odd_std": ( + {l: float(v) for l, v in zip(labels, sv_odd_std)} + if sv_odd_std is not None else None + ), + "std_odd_rep": ( + {l: float(v) for l, v in zip(labels, sv_odd_std)} + if sv_odd_std is not None else None + ), + "shapley_odd_err": ( + {l: float(v) for l, v in zip(labels, sv_odd_err)} + if sv_odd_err is not None else None + ), "shapley_sign_std": ( {l: float(v) for l, v in zip(labels, sv_sign_std)} if sv_sign_std is not None else None @@ -1264,9 +1566,19 @@ def run_analysis(cfg, output_dir, setup_context, n_jobs_override=None, "antithetic_sign": bool( results_final.get("random_sign") and results_final.get("n_sign_samples", 1) > 1 ), + "deterministic_sign_symmetrized": bool( + results_final.get( + "deterministic_sign_symmetrized", + deterministic_sign_symmetrized, + ) + ), "random_seed": random_seed, "baseline_chi2": float(results_final["baseline_chi2"]), + "validation_checks": results_final.get("checks"), "coalitions_evaluated": results_final["coalitions_evaluated"], + "theory_evaluations": int( + results_final.get("theory_evaluations", results_final["coalitions_evaluated"]) + ), "elapsed_seconds": round(elapsed, 1), "n_jobs": int(results_final.get("n_jobs", n_jobs)), "n_datasets_used": len(observables_used), @@ -1298,6 +1610,7 @@ def run_analysis(cfg, output_dir, setup_context, n_jobs_override=None, "member_mode": member_mode, "n_sign_samples": int(n_sign_samples), "antithetic_sign": bool(random_sign and int(n_sign_samples) > 1), + "deterministic_sign_symmetrized": bool(deterministic_sign_symmetrized), "random_seed": random_seed, }, "enforce_sumrules": enforce_sumrules, diff --git a/validphys2/src/validphys/shapley/slurm/run_vp_shapley.slurm b/validphys2/src/validphys/shapley/slurm/run_vp_shapley.slurm index 309c92fe7e..70e3a17115 100644 --- a/validphys2/src/validphys/shapley/slurm/run_vp_shapley.slurm +++ b/validphys2/src/validphys/shapley/slurm/run_vp_shapley.slurm @@ -2,7 +2,7 @@ #SBATCH --job-name=vp_shapley #SBATCH --account=inf26_pml4hep_0 #SBATCH --partition=dcgp_usr_prod -#SBATCH --time=08:00:00 +#SBATCH --time=04:00:00 #SBATCH --output=/leonardo/home/userexternal/rbonnetg/projects/nnpdf/validphys2/src/validphys/shapley/slurm/logs/slurm-%j.out #SBATCH --error=/leonardo/home/userexternal/rbonnetg/projects/nnpdf/validphys2/src/validphys/shapley/slurm/logs/slurm-%j.err From 2255f1915030c99f01dc7c690e4771d3c5ba5945 Mon Sep 17 00:00:00 2001 From: evagroenendijk Date: Fri, 10 Apr 2026 13:57:46 +0200 Subject: [PATCH 20/21] Add runcards for DY and DIS in flavour basis --- .../shapley/runcards/DIS/DIS-FT.YAML | 95 ++++++++++++++++ .../validphys/shapley/runcards/DIS/HERA.yaml | 2 +- .../validphys/shapley/runcards/DY/DY_pt.yaml | 2 +- .../validphys/shapley/runcards/DY/DY_rap.yaml | 106 ++++++++++++++++++ 4 files changed, 203 insertions(+), 2 deletions(-) create mode 100644 validphys2/src/validphys/shapley/runcards/DIS/DIS-FT.YAML create mode 100644 validphys2/src/validphys/shapley/runcards/DY/DY_rap.yaml diff --git a/validphys2/src/validphys/shapley/runcards/DIS/DIS-FT.YAML b/validphys2/src/validphys/shapley/runcards/DIS/DIS-FT.YAML new file mode 100644 index 0000000000..0818ffa78b --- /dev/null +++ b/validphys2/src/validphys/shapley/runcards/DIS/DIS-FT.YAML @@ -0,0 +1,95 @@ +# +# Experiment layout +# ----------------- +# x-scan : 5 log-spaced mu values covering [1e-4, 0.5], alpha=-1.0 +# -> produces phi_j(x) Shapley density on the full global fit +# +# sigma is fixed in log10(x) units (xspace: logx) so the bump width is +# constant in decades across the full x range. + +pdf_name: NNPDF40_nnlo_as_01180 +theory_id: 708 +use_cuts: internal +n_replicas: 100 +output_root: sv_results/DIS +log_root: slurm/logs/DIS +run_name: xscan_all +enforce_sumrules: true +per_replica: true +deterministic_sign_symmetrized: true +random_sign: false +stabilization: + enabled: true + action: exclude_dataset + dataset_delta_chi2_threshold: 1e6 + max_outlier_coalitions: 5 + rerun_stable: true +experiments: + + # --- x-scan + + - name: 1e-4 + basis: [flavor] + perturbation: + mu: 0.0001 + sigma: 0.2 + amplitude: 1.0 + mode: calibrated + xspace: logx + + - name: 1e-3 + basis: [flavor] + perturbation: + mu: 0.001 + sigma: 0.3 + amplitude: 1.0 + mode: calibrated + xspace: logx + + - name: 1e-2 + basis: [flavor] + perturbation: + mu: 0.01 + sigma: 0.3 + amplitude: 1.0 + mode: calibrated + xspace: logx + + - name: 1e-1 + basis: [flavor] + perturbation: + mu: 0.1 + sigma: 0.3 + amplitude: 1.0 + mode: calibrated + xspace: logx + + - name: 5e-1 + basis: [flavor] + perturbation: + mu: 0.5 + sigma: 0.2 + amplitude: 1.0 + mode: calibrated + xspace: logx + - name: 8e-1 + basis: [flavor] + perturbation: + mu: 0.8 + sigma: 0.2 + amplitude: 1.0 + mode: calibrated + xspace: logx + +datasets: + # DIS: Fixed-target + - {dataset: NMC_NC_NOTFIXED_EM-F2, variant: legacy_dw} + - {dataset: NMC_NC_NOTFIXED_P_EM-SIGMARED, variant: legacy} + - {dataset: SLAC_NC_NOTFIXED_P_EM-F2, variant: legacy_dw} + - {dataset: SLAC_NC_NOTFIXED_D_EM-F2, variant: legacy_dw} + - {dataset: BCDMS_NC_NOTFIXED_P_EM-F2, variant: legacy_dw} + - {dataset: BCDMS_NC_NOTFIXED_D_EM-F2, variant: legacy_dw} + - {dataset: CHORUS_CC_NOTFIXED_PB_NU-SIGMARED, variant: legacy_dw} + - {dataset: CHORUS_CC_NOTFIXED_PB_NB-SIGMARED, variant: legacy_dw} + - {dataset: NUTEV_CC_NOTFIXED_FE_NU-SIGMARED, cfac: [MAS], variant: legacy_dw} + - {dataset: NUTEV_CC_NOTFIXED_FE_NB-SIGMARED, cfac: [MAS], variant: legacy_dw} \ No newline at end of file diff --git a/validphys2/src/validphys/shapley/runcards/DIS/HERA.yaml b/validphys2/src/validphys/shapley/runcards/DIS/HERA.yaml index 4ccfe18160..f72565f3dd 100644 --- a/validphys2/src/validphys/shapley/runcards/DIS/HERA.yaml +++ b/validphys2/src/validphys/shapley/runcards/DIS/HERA.yaml @@ -14,7 +14,7 @@ n_replicas: 100 output_root: sv_results/DIS log_root: slurm/logs/DIS run_name: xscan_hera -enforce_sumrules: false +enforce_sumrules: true per_replica: true deterministic_sign_symmetrized: true random_sign: false diff --git a/validphys2/src/validphys/shapley/runcards/DY/DY_pt.yaml b/validphys2/src/validphys/shapley/runcards/DY/DY_pt.yaml index 70b0fabb8b..2f87c31628 100644 --- a/validphys2/src/validphys/shapley/runcards/DY/DY_pt.yaml +++ b/validphys2/src/validphys/shapley/runcards/DY/DY_pt.yaml @@ -14,7 +14,7 @@ n_replicas: 100 output_root: sv_results/DY log_root: slurm/logs/DY run_name: xscan_DY_pt -enforce_sumrules: false +enforce_sumrules: true per_replica: true deterministic_sign_symmetrized: true random_sign: false diff --git a/validphys2/src/validphys/shapley/runcards/DY/DY_rap.yaml b/validphys2/src/validphys/shapley/runcards/DY/DY_rap.yaml new file mode 100644 index 0000000000..59b6845b6c --- /dev/null +++ b/validphys2/src/validphys/shapley/runcards/DY/DY_rap.yaml @@ -0,0 +1,106 @@ +# +# Experiment layout +# ----------------- +# x-scan : 5 log-spaced mu values covering [1e-4, 0.5], alpha=-1.0 +# -> produces phi_j(x) Shapley density on the full global fit +# +# sigma is fixed in log10(x) units (xspace: logx) so the bump width is +# constant in decades across the full x range. + +pdf_name: NNPDF40_nnlo_as_01180 +theory_id: 708 +use_cuts: internal +n_replicas: 100 +output_root: sv_results/DY_rap +log_root: slurm/logs/DY_rap +run_name: xscan_DY_other +enforce_sumrules: true +per_replica: true +deterministic_sign_symmetrized: true +random_sign: false +stabilization: + enabled: true + action: exclude_dataset + dataset_delta_chi2_threshold: 1e6 + max_outlier_coalitions: 5 + rerun_stable: true +experiments: + + # --- x-scan + + - name: 1e-4 + basis: [flavor] + perturbation: + mu: 0.0001 + sigma: 0.2 + amplitude: 1.0 + mode: calibrated + xspace: logx + + - name: 1e-3 + basis: [flavor] + perturbation: + mu: 0.001 + sigma: 0.3 + amplitude: 1.0 + mode: calibrated + xspace: logx + + - name: 1e-2 + basis: [flavor] + perturbation: + mu: 0.01 + sigma: 0.3 + amplitude: 1.0 + mode: calibrated + xspace: logx + + - name: 1e-1 + basis: [flavor] + perturbation: + mu: 0.1 + sigma: 0.3 + amplitude: 1.0 + mode: calibrated + xspace: logx + + - name: 5e-1 + basis: [flavor] + perturbation: + mu: 0.5 + sigma: 0.2 + amplitude: 1.0 + mode: calibrated + xspace: logx + - name: 8e-1 + basis: [flavor] + perturbation: + mu: 0.8 + sigma: 0.2 + amplitude: 1.0 + mode: calibrated + xspace: logx + +datasets: + + - {dataset: CDF_Z0_1P96TEV_ZRAP, variant: legacy} + - {dataset: D0_Z0_1P96TEV_ZRAP, variant: legacy} + # DY: ATLAS + - {dataset: ATLAS_WPWM_7TEV_36PB_ETA, variant: legacy} + - {dataset: ATLAS_Z0_7TEV_36PB_ETA, variant: legacy} + - {dataset: ATLAS_WPWM_7TEV_46FB_CC-ETA, variant: legacy} + - {dataset: ATLAS_Z0_7TEV_46FB_CC-Y, variant: legacy} + - {dataset: ATLAS_Z0_7TEV_46FB_CF-Y, variant: legacy} + - {dataset: ATLAS_Z0_8TEV_HIMASS_M-Y, variant: legacy} + - {dataset: ATLAS_Z0_8TEV_LOWMASS_M-Y, variant: legacy} + # DY: CMS + - {dataset: CMS_WPWM_8TEV_MUON_Y, variant: legacy} + # DY: LHCb + - LHCB_Z0_7TEV_DIELECTRON_Y + - LHCB_Z0_8TEV_DIELECTRON_Y + - {dataset: LHCB_WPWM_7TEV_MUON_Y, cfac: [NRM]} + - {dataset: LHCB_Z0_7TEV_MUON_Y, cfac: [NRM]} + - {dataset: LHCB_WPWM_8TEV_MUON_Y, cfac: [NRM]} + - {dataset: LHCB_Z0_8TEV_MUON_Y, cfac: [NRM]} + - LHCB_Z0_13TEV_DIMUON-Y + - LHCB_Z0_13TEV_DIELECTRON-Y \ No newline at end of file From fb1c8f462548ed3ea0eff17d7a4650aeec56467a Mon Sep 17 00:00:00 2001 From: evagroenendijk Date: Fri, 10 Apr 2026 15:51:49 +0200 Subject: [PATCH 21/21] Runcards for CC and NC DIS in evolution basis --- .../shapley/runcards/DIS/DIS-FT_CC_ev.yaml | 90 ++++++++++++++++++ .../shapley/runcards/DIS/DIS-FT_NC_ev.yaml | 92 +++++++++++++++++++ 2 files changed, 182 insertions(+) create mode 100644 validphys2/src/validphys/shapley/runcards/DIS/DIS-FT_CC_ev.yaml create mode 100644 validphys2/src/validphys/shapley/runcards/DIS/DIS-FT_NC_ev.yaml diff --git a/validphys2/src/validphys/shapley/runcards/DIS/DIS-FT_CC_ev.yaml b/validphys2/src/validphys/shapley/runcards/DIS/DIS-FT_CC_ev.yaml new file mode 100644 index 0000000000..923674a8c2 --- /dev/null +++ b/validphys2/src/validphys/shapley/runcards/DIS/DIS-FT_CC_ev.yaml @@ -0,0 +1,90 @@ +# +# Experiment layout +# ----------------- +# x-scan : 5 log-spaced mu values covering [1e-4, 0.5], alpha=-1.0 +# -> produces phi_j(x) Shapley density on the full global fit +# +# sigma is fixed in log10(x) units (xspace: logx) so the bump width is +# constant in decades across the full x range. + +pdf_name: NNPDF40_nnlo_as_01180 +theory_id: 708 +use_cuts: internal +n_replicas: 100 +output_root: sv_results/DIS-FT_CC_ev +log_root: slurm/logs/DIS-FT_CC_ev +run_name: xscan_all +enforce_sumrules: true +per_replica: true +deterministic_sign_symmetrized: true +random_sign: false +stabilization: + enabled: true + action: exclude_dataset + dataset_delta_chi2_threshold: 1e6 + max_outlier_coalitions: 5 + rerun_stable: true +experiments: + + # --- x-scan + + - name: 1e-4 + basis: [evolution] + perturbation: + mu: 0.0001 + sigma: 0.2 + amplitude: 1.0 + mode: calibrated + xspace: logx + + - name: 1e-3 + basis: [evolution] + perturbation: + mu: 0.001 + sigma: 0.3 + amplitude: 1.0 + mode: calibrated + xspace: logx + + - name: 1e-2 + basis: [evolution] + perturbation: + mu: 0.01 + sigma: 0.3 + amplitude: 1.0 + mode: calibrated + xspace: logx + + - name: 1e-1 + basis: [evolution] + perturbation: + mu: 0.1 + sigma: 0.3 + amplitude: 1.0 + mode: calibrated + xspace: logx + + - name: 5e-1 + basis: [evolution] + perturbation: + mu: 0.5 + sigma: 0.2 + amplitude: 1.0 + mode: calibrated + xspace: logx + + - name: 8e-1 + basis: [evolution] + perturbation: + mu: 0.8 + sigma: 0.2 + amplitude: 1.0 + mode: calibrated + xspace: logx + +datasets: + # DIS: Fixed-target + - {dataset: CHORUS_CC_NOTFIXED_PB_NU-SIGMARED, variant: legacy_dw} + - {dataset: CHORUS_CC_NOTFIXED_PB_NB-SIGMARED, variant: legacy_dw} + - {dataset: NUTEV_CC_NOTFIXED_FE_NU-SIGMARED, cfac: [MAS], variant: legacy_dw} + - {dataset: NUTEV_CC_NOTFIXED_FE_NB-SIGMARED, cfac: [MAS], variant: legacy_dw} \ No newline at end of file diff --git a/validphys2/src/validphys/shapley/runcards/DIS/DIS-FT_NC_ev.yaml b/validphys2/src/validphys/shapley/runcards/DIS/DIS-FT_NC_ev.yaml new file mode 100644 index 0000000000..b477514954 --- /dev/null +++ b/validphys2/src/validphys/shapley/runcards/DIS/DIS-FT_NC_ev.yaml @@ -0,0 +1,92 @@ +# +# Experiment layout +# ----------------- +# x-scan : 5 log-spaced mu values covering [1e-4, 0.5], alpha=-1.0 +# -> produces phi_j(x) Shapley density on the full global fit +# +# sigma is fixed in log10(x) units (xspace: logx) so the bump width is +# constant in decades across the full x range. + +pdf_name: NNPDF40_nnlo_as_01180 +theory_id: 708 +use_cuts: internal +n_replicas: 100 +output_root: sv_results/DIS-FT_NC_ev +log_root: slurm/logs/DIS-FT_NC_ev +run_name: xscan_all +enforce_sumrules: true +per_replica: true +deterministic_sign_symmetrized: true +random_sign: false +stabilization: + enabled: true + action: exclude_dataset + dataset_delta_chi2_threshold: 1e6 + max_outlier_coalitions: 5 + rerun_stable: true +experiments: + + # --- x-scan + + - name: 1e-4 + basis: [evolution] + perturbation: + mu: 0.0001 + sigma: 0.2 + amplitude: 1.0 + mode: calibrated + xspace: logx + + - name: 1e-3 + basis: [evolution] + perturbation: + mu: 0.001 + sigma: 0.3 + amplitude: 1.0 + mode: calibrated + xspace: logx + + - name: 1e-2 + basis: [evolution] + perturbation: + mu: 0.01 + sigma: 0.3 + amplitude: 1.0 + mode: calibrated + xspace: logx + + - name: 1e-1 + basis: [evolution] + perturbation: + mu: 0.1 + sigma: 0.3 + amplitude: 1.0 + mode: calibrated + xspace: logx + + - name: 5e-1 + basis: [evolution] + perturbation: + mu: 0.5 + sigma: 0.2 + amplitude: 1.0 + mode: calibrated + xspace: logx + + - name: 8e-1 + basis: [evolution] + perturbation: + mu: 0.8 + sigma: 0.2 + amplitude: 1.0 + mode: calibrated + xspace: logx + +datasets: + # DIS: Fixed-target + - {dataset: NMC_NC_NOTFIXED_EM-F2, variant: legacy_dw} + - {dataset: NMC_NC_NOTFIXED_P_EM-SIGMARED, variant: legacy} + - {dataset: SLAC_NC_NOTFIXED_P_EM-F2, variant: legacy_dw} + - {dataset: SLAC_NC_NOTFIXED_D_EM-F2, variant: legacy_dw} + - {dataset: BCDMS_NC_NOTFIXED_P_EM-F2, variant: legacy_dw} + - {dataset: BCDMS_NC_NOTFIXED_D_EM-F2, variant: legacy_dw} \ No newline at end of file