nnpdf 4.1.0__py3-none-any.whl → 4.1.1__py3-none-any.whl

n3fit/model_trainer.py

@@ -20,11 +20,10 @@ from n3fit.backends import NN_LAYER_ALL_REPLICAS, MetaModel, callbacks, clear_ba
 from n3fit.backends import operations as op
 from n3fit.hyper_optimization.hyper_scan import HYPEROPT_STATUSES
 import n3fit.hyper_optimization.penalties
-import n3fit.hyper_optimization.rewards
 from n3fit.hyper_optimization.rewards import HyperLoss
 from n3fit.scaler import generate_scaler
 from n3fit.stopping import Stopping
-from n3fit.vpinterface import N3PDF, compute_phi
+from n3fit.vpinterface import N3PDF, compute_hyperopt_metrics
 from validphys.core import DataGroupSpec
 from validphys.photon.compute import Photon
 
@@ -652,71 +651,6 @@ class ModelTrainer:
         if interpolation_points:
             self._scaler = generate_scaler(self.input_list, interpolation_points)
 
-    def _generate_pdf(
-        self,
-        nodes_per_layer,
-        activation_per_layer,
-        initializer,
-        layer_type,
-        dropout,
-        regularizer,
-        regularizer_args,
-        seed,
-        photons,
-    ):
-        """
-        Defines the internal variable layer_pdf
-        this layer takes any input (x) and returns the pdf value for that x
-
-        if the sumrule is being imposed, it also updates input_list with the
-        integrator_input tensor used to calculate the sumrule
-
-        Parameters:
-        -----------
-            nodes_per_layer: list
-                list of nodes each layer has
-            activation_per_layer: list
-                list of the activation function for each layer
-            initializer: str
-                initializer for the weights of the NN
-            layer_type: str
-                type of layer to be used
-            dropout: float
-                dropout to add at the end of the NN
-            regularizer: str
-                choice of regularizer to add to the dense layers of the NN
-            regularizer_args: dict
-                dictionary of arguments for the regularizer
-            seed: int
-                seed for the NN
-            photons: :py:class:`validphys.photon.compute.Photon`
-                function to compute the photon PDF
-        see model_gen.pdfNN_layer_generator for more information
-
-        Returns
-        -------
-            pdf_model: MetaModel
-                pdf model
-        """
-        log.info("Generating PDF models")
-        pdf_model = model_gen.generate_pdf_model(
-            nodes=nodes_per_layer,
-            activations=activation_per_layer,
-            layer_type=layer_type,
-            flav_info=self.flavinfo,
-            fitbasis=self.fitbasis,
-            seed=seed,
-            initializer_name=initializer,
-            dropout=dropout,
-            regularizer=regularizer,
-            regularizer_args=regularizer_args,
-            impose_sumrule=self.impose_sumrule,
-            scaler=self._scaler,
-            num_replicas=len(self.replicas),
-            photons=photons,
-        )
-        return pdf_model
-
     def _prepare_reporting(self, partition):
         """Parses the information received by the :py:class:`n3fit.ModelTrainer.ModelTrainer`
         to select the bits necessary for reporting the chi2.
@@ -847,9 +781,23 @@ class ModelTrainer:
         exp_chi2 = self.experimental["model"].compute_losses()["loss"] / self.experimental["ndata"]
         return train_chi2, val_chi2, exp_chi2
 
-    def _filter_datagroupspec(self, datasets_partition):
-        """Takes a list of all input exp datasets as :class:`validphys.core.DataGroupSpec`
-        and select `DataSetSpec`s whose names are in datasets_partition.
+    def _filter_datagroupspec(self, datasets_partition, filter_in=True):
+        """Takes a list of strings with dataset names to either filter in or out
+        and returns instances of :class:`validphys.core.DataGroupSpec` which contain
+        either only the "in" datasets or all datasets minus the "out".
+        To control whether the dataset_partition should be selected or deselected
+        the ``filter_in`` variable must be set to either True (select) or False (deselect)
+
+        The use case of this function is to return a modified experiment group object
+        following the same criteria that is used during the training, but with only
+        a subset of datasets being considered.
+
+        Parameters
+        ----------
+            datasets_partition: List[str]
+                List with names of the datasets you want to select or deselect.
+            filter_in: bool
+                Whether the datasets should be selected in (True, default) or out (False)
 
         Parameters
         ----------
@@ -874,7 +822,7 @@ class ModelTrainer:
             # Now, loop over them
             for dataset in datagroup.datasets:
                 # Include `DataSetSpec`s whose names are in datasets_partition
-                if dataset.name in datasets_partition:
+                if (dataset.name in datasets_partition) == filter_in:
                     filtered_datasetspec.append(dataset)
 
             # List of filtered experiments as `DataGroupSpec`
@@ -939,8 +887,10 @@ class ModelTrainer:
         # And lists to save hyperopt utilities
         pdfs_per_fold = []
         exp_models = []
-        # phi evaluated over training/validation exp data
-        trvl_phi_per_fold = []
+        # Hyperopt metrics evaluated over training/validation exp data
+        trvl_chi2_per_fold = []
+        trvl_phi2_per_fold = []
+        trvl_logp_per_fold = []
 
         # Generate the grid in x, note this is the same for all partitions
         xinput = self._xgrid_generation()
@@ -952,29 +902,43 @@ class ModelTrainer:
             )
         else:
             photons = None
+
+        # Prepare the settings for all replica
+        replicas_settings = []
+        for seed in self._nn_seeds:
+            # WIP here the sampling will happen when necessary
+            tmp = model_gen.ReplicaSettings(
+                seed=seed,
+                nodes=params["nodes_per_layer"],
+                activations=params["activation_per_layer"],
+                initializer=params["initializer"],
+                architecture=params["layer_type"],
+                dropout_rate=params["dropout"],
+                regularizer=params.get("regularizer"),
+                regularizer_args=params.get("regularizer_args"),
+            )
+            replicas_settings.append(tmp)
+
         ### Training loop
         for k, partition in enumerate(self.kpartitions):
-            # Each partition of the kfolding needs to have its own separate model
-            # and the seed needs to be updated accordingly
-            seeds = self._nn_seeds
+
             if k > 0:
-                # generate random integers for each k-fold from the input `nnseeds`
-                # we generate new seeds to avoid the integer overflow that may
-                # occur when doing k*nnseeds
-                rngs = [np.random.default_rng(seed=seed) for seed in seeds]
-                seeds = [generator.integers(1, pow(2, 30)) * k for generator in rngs]
+                # When hyperoptimizing every patition takes the exact same model,
+                # only the seed needs to be updated,.
+                # Generate random integers for each k-fold from the input `nnseeds`
+                # this helps avoid the integer overflow that may occur when doing k*nnseeds
+                for seed, settings in zip(self._nn_seeds, replicas_settings):
+                    rng = np.random.default_rng(seed=seed)
+                    settings.seed = rng.integers(1, pow(2, 30)) * k
 
             # Generate the pdf model
-            pdf_model = self._generate_pdf(
-                params["nodes_per_layer"],
-                params["activation_per_layer"],
-                params["initializer"],
-                params["layer_type"],
-                params["dropout"],
-                params.get("regularizer", None),  # regularizer optional
-                params.get("regularizer_args", None),
-                seeds,
-                photons,
+            pdf_model = model_gen.generate_pdf_model(
+                replicas_settings=replicas_settings,
+                flav_info=self.flavinfo,
+                fitbasis=self.fitbasis,
+                impose_sumrule=self.impose_sumrule,
+                scaler=self._scaler,
+                photons=photons,
             )
 
             if photons:
@@ -1052,7 +1016,8 @@ class ModelTrainer:
                 # Extracting the necessary data to compute phi
                 # First, create a list of `validphys.core.DataGroupSpec`
                 # containing only exp datasets within the held out fold
-                experimental_data = self._filter_datagroupspec(partition["datasets"])
+                folded_datasets = partition["datasets"]
+                experimental_data = self._filter_datagroupspec(folded_datasets)
 
                 vplike_pdf = N3PDF(pdf_model.split_replicas())
                 if self.boundary_condition is not None:
@@ -1061,7 +1026,7 @@ class ModelTrainer:
                 # Compute per replica hyper losses
                 hyper_loss = self._hyper_loss.compute_loss(
                     penalties=penalties,
-                    kfold_loss=experimental_loss,
+                    experimental_loss=experimental_loss,
                     validation_loss=validation_loss,
                     pdf_object=vplike_pdf,
                     experimental_data=experimental_data,
@@ -1070,20 +1035,17 @@ class ModelTrainer:
 
                 # Create another list of `validphys.core.DataGroupSpec`
                 # containing now exp datasets that are included in the training/validation dataset
-                trvl_partitions = list(self.kpartitions)
-                trvl_partitions.pop(k)
-                trvl_exp_names = [
-                    exp_name for item in trvl_partitions for exp_name in item['datasets']
-                ]
-                trvl_data = self._filter_datagroupspec(trvl_exp_names)
-                # evaluate phi on training/validation exp set
-                trvl_phi = compute_phi(vplike_pdf, trvl_data)
+                trvl_data = self._filter_datagroupspec(folded_datasets, filter_in=False)
+                # Evaluate the hyperopt metrics on the training/validation experimental sets
+                hyper_metrics = compute_hyperopt_metrics(vplike_pdf, trvl_data)
 
                 # Now save all information from this fold
                 l_hyper.append(hyper_loss)
                 l_valid.append(validation_loss)
                 l_exper.append(experimental_loss)
-                trvl_phi_per_fold.append(trvl_phi)
+                trvl_chi2_per_fold.append(hyper_metrics.chi2)
+                trvl_phi2_per_fold.append(hyper_metrics.phi2)
+                trvl_logp_per_fold.append(hyper_metrics.logp)
                 pdfs_per_fold.append(pdf_model)
                 exp_models.append(models["experimental"])
 
@@ -1123,10 +1085,14 @@ class ModelTrainer:
                 "experimental_loss": np.average(l_exper),
                 "kfold_meta": {
                     "validation_losses": l_valid,
-                    "trvl_losses_phi": np.array(trvl_phi_per_fold),
+                    "trvl_losses_chi2": np.array(trvl_chi2_per_fold),
+                    "trvl_losses_phi2": np.array(trvl_phi2_per_fold),
+                    "trvl_losses_logp": np.array(trvl_logp_per_fold),
                     "experimental_losses": l_exper,
-                    "hyper_losses": np.array(self._hyper_loss.chi2_matrix),
-                    "hyper_losses_phi": np.array(self._hyper_loss.phi2_vector),
+                    "hyper_losses": np.array(self._hyper_loss.exp_chi2_matrix),
+                    "hyper_losses_chi2": np.array(self._hyper_loss.hyper_chi2_vector),
+                    "hyper_losses_phi2": np.array(self._hyper_loss.hyper_phi2_vector),
+                    "hyper_losses_logp": np.array(self._hyper_loss.hyper_logp_vector),
                     "penalties": {
                         name: np.array(values)
                         for name, values in self._hyper_loss.penalties.items()

n3fit/performfit.py

@@ -215,16 +215,11 @@ def performfit(
         if hyperopt:
             from n3fit.hyper_optimization.hyper_scan import hyper_scan_wrapper
 
-            # Note that hyperopt will not run in parallel or with more than one model _for now_
             replica_path_set = replica_path / f"replica_{replica_idxs[0]}"
-            true_best = hyper_scan_wrapper(
+            hyper_scan_wrapper(
                 replica_path_set, the_model_trainer, hyperscanner, max_evals=hyperopt
             )
-            print("##################")
-            print("Best model found: ")
-            for k, i in true_best.items():
-                print(f" {k} : {i} ")
-
+            log.info("The hyperparameter scan is successfully finished.")
             # In general after we do the hyperoptimization we do not care about the fit
             # so just let this die here
             break

n3fit/tests/regressions/quickcard_1.json

@@ -56,40 +56,24 @@
   "chi2": 5.2825517654418945,
   "pos_state": "POS_VETO",
   "arc_lengths": [
-    1.3156869164725282,
+    1.3156869164725287,
     1.2594413771361879,
-    3.6314384756133826,
-    1.0790116253109998,
+    3.6314384756133817,
+    1.0790116253110003,
     2.536624366983763
   ],
   "integrability": [
-    0.009921472228597905,
-    0.009921472228597877,
-    4.279186089674314e-07,
-    0.14216890558600426,
-    0.01550695078913129
+    0.009921472228597898,
+    0.12521867826580985,
+    4.2791860974111806e-07,
+    0.14216890558600428,
+    0.015506950789131738
   ],
-  "timing": {
-    "walltime": {
-      "Total": 18.872443675994873,
-      "start": 0.0,
-      "replica_set": 0.23057246208190918,
-      "replica_fitted": 18.87218737602234,
-      "replica_set_to_replica_fitted": 18.64161491394043
-    },
-    "cputime": {
-      "Total": 22.741160551,
-      "start": 0.0,
-      "replica_set": 0.22935973400000087,
-      "replica_fitted": 22.740922403,
-      "replica_set_to_replica_fitted": 22.511562669
-    }
-  },
   "version": {
-    "keras": "3.9.0 backend='tensorflow'",
+    "keras": "3.10.0 backend='tensorflow'",
     "tensorflow": "2.19.0",
-    "numpy": "1.26.4",
-    "nnpdf": "4.0.10.post204.dev0+8cb29d878",
-    "validphys": "4.0.10.post204.dev0+8cb29d878"
+    "numpy": "2.1.3",
+    "nnpdf": "4.1.0.post14.dev0+2ee907633",
+    "validphys": "4.1.0.post14.dev0+2ee907633"
   }
 }

n3fit/tests/regressions/quickcard_3.json

@@ -56,40 +56,24 @@
   "chi2": 136.70420837402344,
   "pos_state": "POS_VETO",
   "arc_lengths": [
-    1.9702585245218012,
+    1.9702585245217996,
     1.3170459341375724,
-    1.270081035506918,
+    1.2700810355069196,
     9.476632893725345,
-    1.3188127820152968
+    1.3188127820152953
   ],
   "integrability": [
-    0.01508276944514414,
-    0.015082769445143501,
-    0.0028370417712720586,
-    0.05940935388207458,
-    0.00011781920693543224
+    0.015082769445141472,
+    0.0022062192147116466,
+    0.002837041771279303,
+    0.05940935388207447,
+    0.00011781920693965109
   ],
-  "timing": {
-    "walltime": {
-      "Total": 18.97901725769043,
-      "start": 0.0,
-      "replica_set": 0.23014259338378906,
-      "replica_fitted": 18.978914976119995,
-      "replica_set_to_replica_fitted": 18.748772382736206
-    },
-    "cputime": {
-      "Total": 22.706904895,
-      "start": 0.0,
-      "replica_set": 0.22894110699999892,
-      "replica_fitted": 22.706801655,
-      "replica_set_to_replica_fitted": 22.477860548000002
-    }
-  },
   "version": {
-    "keras": "3.9.0 backend='tensorflow'",
+    "keras": "3.10.0 backend='tensorflow'",
     "tensorflow": "2.19.0",
-    "numpy": "1.26.4",
-    "nnpdf": "4.0.10.post204.dev0+8cb29d878",
-    "validphys": "4.0.10.post204.dev0+8cb29d878"
+    "numpy": "2.1.3",
+    "nnpdf": "4.1.0.post14.dev0+2ee907633",
+    "validphys": "4.1.0.post14.dev0+2ee907633"
   }
 }

n3fit/tests/regressions/quickcard_pol_1.json

@@ -32,40 +32,24 @@
   "chi2": 2.1472965372150274,
   "pos_state": "POS_PASS",
   "arc_lengths": [
-    1.021167697265657,
+    1.0211676972656567,
     1.03088406913582,
     0.9899487587939698,
     0.9899487587939698,
     0.9899487587939698
   ],
   "integrability": [
-    1.8041124150158794e-16,
-    5.551115123125783e-17,
-    5.551115123125783e-17,
-    0.0018142980190617164,
-    2.498001805406602e-16
+    2.0404275905319958e-16,
+    0.014307497425732396,
+    6.661338147750939e-16,
+    0.0018142980190616331,
+    1.6653345369377348e-16
   ],
-  "timing": {
-    "walltime": {
-      "Total": 13.375839710235596,
-      "start": 0.0,
-      "replica_set": 0.2339179515838623,
-      "replica_fitted": 13.375744104385376,
-      "replica_set_to_replica_fitted": 13.141826152801514
-    },
-    "cputime": {
-      "Total": 15.078210552000002,
-      "start": 0.0,
-      "replica_set": 0.2326924410000002,
-      "replica_fitted": 15.078113471000002,
-      "replica_set_to_replica_fitted": 14.84542103
-    }
-  },
   "version": {
-    "keras": "3.9.0 backend='tensorflow'",
+    "keras": "3.10.0 backend='tensorflow'",
     "tensorflow": "2.19.0",
-    "numpy": "1.26.4",
-    "nnpdf": "4.0.10.post204.dev0+8cb29d878",
-    "validphys": "4.0.10.post204.dev0+8cb29d878"
+    "numpy": "2.1.3",
+    "nnpdf": "4.1.0.post14.dev0+2ee907633",
+    "validphys": "4.1.0.post14.dev0+2ee907633"
   }
 }

n3fit/tests/regressions/quickcard_pol_3.json

@@ -39,33 +39,17 @@
     0.9899487587939698
   ],
   "integrability": [
-    6.453171330633722e-16,
-    1.3877787807814457e-16,
-    1.6653345369377348e-16,
-    0.020738880443015445,
-    3.3306690738754696e-16
+    4.919598825159773e-17,
+    0.001721592012243471,
+    1.457167719820518e-16,
+    0.02073888044301566,
+    3.469446951953614e-17
   ],
-  "timing": {
-    "walltime": {
-      "Total": 16.941243171691895,
-      "start": 0.0,
-      "replica_set": 0.23375344276428223,
-      "replica_fitted": 16.94113063812256,
-      "replica_set_to_replica_fitted": 16.707377195358276
-    },
-    "cputime": {
-      "Total": 19.081625535,
-      "start": 0.0,
-      "replica_set": 0.23221380699999994,
-      "replica_fitted": 19.081511472,
-      "replica_set_to_replica_fitted": 18.849297665
-    }
-  },
   "version": {
-    "keras": "3.9.0 backend='tensorflow'",
+    "keras": "3.10.0 backend='tensorflow'",
     "tensorflow": "2.19.0",
-    "numpy": "1.26.4",
-    "nnpdf": "4.0.10.post204.dev0+8cb29d878",
-    "validphys": "4.0.10.post204.dev0+8cb29d878"
+    "numpy": "2.1.3",
+    "nnpdf": "4.1.0.post14.dev0+2ee907633",
+    "validphys": "4.1.0.post14.dev0+2ee907633"
   }
 }

n3fit/tests/regressions/quickcard_qed_1.json

@@ -56,40 +56,24 @@
   "chi2": 29.660354614257812,
   "pos_state": "POS_VETO",
   "arc_lengths": [
-    1.177279515316311,
+    1.1772795153163105,
     1.9596727108470247,
     2.0659497326907528,
     1.0157677891950458,
-    1.3618257886720615
+    1.3618257886720613
   ],
   "integrability": [
-    0.005202697648201693,
-    0.005202697648200694,
-    0.00035197582474189026,
-    0.10865128412842784,
-    0.0005445390415855789
+    0.005202697648200688,
+    0.06640676688402825,
+    0.00035197582474033595,
+    0.10865128412842817,
+    0.0005445390415856899
   ],
-  "timing": {
-    "walltime": {
-      "Total": 30.97916316986084,
-      "start": 0.0,
-      "replica_set": 0.23157668113708496,
-      "replica_fitted": 30.97898554801941,
-      "replica_set_to_replica_fitted": 30.747408866882324
-    },
-    "cputime": {
-      "Total": 34.14771338,
-      "start": 0.0,
-      "replica_set": 0.23023607500000054,
-      "replica_fitted": 34.147534493,
-      "replica_set_to_replica_fitted": 33.917298418
-    }
-  },
   "version": {
-    "keras": "3.9.0 backend='tensorflow'",
+    "keras": "3.10.0 backend='tensorflow'",
     "tensorflow": "2.19.0",
-    "numpy": "1.26.4",
-    "nnpdf": "4.0.10.post204.dev0+8cb29d878",
-    "validphys": "4.0.10.post204.dev0+8cb29d878"
+    "numpy": "2.1.3",
+    "nnpdf": "4.1.0.post14.dev0+2ee907633",
+    "validphys": "4.1.0.post14.dev0+2ee907633"
   }
 }

n3fit/tests/regressions/quickcard_qed_3.json

@@ -56,40 +56,24 @@
   "chi2": 6.850959300994873,
   "pos_state": "POS_VETO",
   "arc_lengths": [
-    1.3254256368644568,
+    1.3254256368644552,
     1.4540914108436402,
     2.885420751255539,
-    1.8141600138524392,
-    1.046721750173377
+    1.8141600138524403,
+    1.0467217501733774
   ],
   "integrability": [
-    0.033585004275664354,
-    0.03358500427566452,
-    0.00019570513268241108,
+    0.03358500427566258,
+    0.00010966376294052615,
+    0.00019570513267841427,
     0.06445826729759663,
-    0.03394107008353098
+    0.03394107008352876
   ],
-  "timing": {
-    "walltime": {
-      "Total": 31.162365198135376,
-      "start": 0.0,
-      "replica_set": 0.22889018058776855,
-      "replica_fitted": 31.162174224853516,
-      "replica_set_to_replica_fitted": 30.933284044265747
-    },
-    "cputime": {
-      "Total": 34.290361569999995,
-      "start": 0.0,
-      "replica_set": 0.2273777430000008,
-      "replica_fitted": 34.290169555,
-      "replica_set_to_replica_fitted": 34.062791812
-    }
-  },
   "version": {
-    "keras": "3.9.0 backend='tensorflow'",
+    "keras": "3.10.0 backend='tensorflow'",
     "tensorflow": "2.19.0",
-    "numpy": "1.26.4",
-    "nnpdf": "4.0.10.post204.dev0+8cb29d878",
-    "validphys": "4.0.10.post204.dev0+8cb29d878"
+    "numpy": "2.1.3",
+    "nnpdf": "4.1.0.post14.dev0+2ee907633",
+    "validphys": "4.1.0.post14.dev0+2ee907633"
   }
 }

n3fit/tests/test_hyperopt.py

@@ -14,26 +14,20 @@ from numpy.testing import assert_approx_equal
 import pytest
 
 from n3fit.hyper_optimization.rewards import HyperLoss
-from n3fit.model_gen import generate_pdf_model
+from n3fit.model_gen import ReplicaSettings, generate_pdf_model
 from n3fit.vpinterface import N3PDF
 from validphys.loader import Loader
 from validphys.tests.conftest import THEORYID
 
 
-def generate_pdf(seed, num_replicas):
+def generate_pdf(seeds):
     """Generate generic pdf model."""
     fake_fl = [
         {"fl": i, "largex": [0, 1], "smallx": [1, 2]}
         for i in ["u", "ubar", "d", "dbar", "c", "g", "s", "sbar"]
     ]
-    pdf_model = generate_pdf_model(
-        nodes=[8],
-        activations=["linear"],
-        seed=seed,
-        num_replicas=num_replicas,
-        flav_info=fake_fl,
-        fitbasis="FLAVOUR",
-    )
+    rp = [ReplicaSettings(nodes=[8], activations=["linear"], seed=seed) for seed in seeds]
+    pdf_model = generate_pdf_model(rp, flav_info=fake_fl, fitbasis="FLAVOUR")
     return pdf_model
 
 
@@ -63,7 +57,7 @@ def test_compute_per_fold_loss(loss_type, replica_statistic, expected_per_fold_l
     This example assumes a 2 replica calculation with 3 added penalties.
     """
     # generate 2 replica pdf model
-    pdf_model = generate_pdf(seed=[1, 2], num_replicas=2)
+    pdf_model = generate_pdf(seeds=[1, 2])
     # add 3 penalties for a 2 replica model
     penalties = {
         'saturation': np.array([0.0, 0.0]),
@@ -81,7 +75,7 @@ def test_compute_per_fold_loss(loss_type, replica_statistic, expected_per_fold_l
     pdf_object = N3PDF(pdf_model.split_replicas())
     predicted_per_fold_loss = loss.compute_loss(
         penalties,
-        kfold_loss=experimental_loss,
+        experimental_loss=experimental_loss,
         validation_loss=experimental_loss,
         pdf_object=pdf_object,
         experimental_data=experimental_data,