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

n3fit/tests/test_layers.py

@@ -1,6 +1,6 @@
 """
-    Tests for the layers of n3fit
-    This module checks that the layers do what they would do with numpy
+Tests for the layers of n3fit
+This module checks that the layers do what they would do with numpy
 """
 
 import dataclasses
@@ -139,7 +139,7 @@ def test_DIS_basis():
         reference = np.zeros(FLAVS, dtype=bool)
         for i in comb:
             reference[i] = True
-        assert np.alltrue(result == reference)
+        np.testing.assert_allclose(result, reference)
 
 
 def test_DY_basis():
@@ -153,7 +153,7 @@ def test_DY_basis():
         reference = np.zeros((FLAVS, FLAVS))
         for i, j in comb:
             reference[i, j] = True
-        assert np.alltrue(result == reference)
+        np.testing.assert_allclose(result, reference)
 
 
 def test_DIS():
@@ -232,7 +232,7 @@ def test_rotation_flavour():
     pdf = op.numpy_to_tensor(pdf)
     rotmat = layers.FlavourToEvolution(flav_info, "FLAVOUR")
     res_layer = rotmat(pdf)
-    assert np.alltrue(res_np == res_layer)
+    np.testing.assert_allclose(res_np, res_layer)
 
 
 def test_rotation_evol():
@@ -257,7 +257,7 @@ def test_rotation_evol():
     pdf = op.numpy_to_tensor(pdf)
     rotmat = layers.FlavourToEvolution(flav_info, "EVOL")
     res_layer = rotmat(pdf)
-    assert np.alltrue(res_np == res_layer)
+    np.testing.assert_allclose(res_np, res_layer)
 
 
 def test_mask():

n3fit/tests/test_modelgen.py

@@ -1,50 +1,99 @@
 """
-    Test for the model generation
+Test for the model generation
 
-    These tests check that the generated NN are as expected
-    It checks that both the number of layers and the shape
-    of the weights of the layers are what is expected
+These tests check that the generated NN are as expected
+It checks that both the number of layers and the shape
+of the weights of the layers are what is expected
 """
 
-from n3fit.backends import NN_PREFIX
-from n3fit.model_gen import generate_nn
+from dataclasses import asdict
+
+import pytest
+
+from n3fit.backends import Input
+from n3fit.model_gen import ReplicaSettings, _generate_nn
+from nnpdf_data.utils import parse_input
 
 INSIZE = 16
-OUT_SIZES = (4, 3)
-BASIS_SIZE = 3
-
-COMMON_ARGS = {
-    "nodes_in": INSIZE,
-    "nodes": OUT_SIZES,
-    "activations": ["sigmoid", "tanh"],
-    "initializer_name": "glorot_uniform",
-    "replica_seeds": [0],
-    "dropout": 0.0,
-    "regularizer": None,
-    "regularizer_args": {},
-    "last_layer_nodes": BASIS_SIZE,
-}
+OUT_SIZES = (4, 7, 3)
+BASIS_SIZE = OUT_SIZES[-1]
+
+
+def _common_generation(architecture, dropout=0.0):
+    """Generate a NN with shared configuration with only
+    some free parameters"""
+    config = {
+        "architecture": architecture,
+        "nodes": OUT_SIZES,
+        "activations": ["sigmoid", "sigmoid", "tanh"],
+        "initializer": "glorot_uniform",
+        "seed": 27,
+        "dropout_rate": dropout,
+        "regularizer": None,
+        "regularizer_args": {},
+    }
+    xin = Input(shape=(None, INSIZE), batch_size=1)
+    return _generate_nn(xin, **config)
 
 
 def test_generate_dense_network():
-    nn = generate_nn("dense", **COMMON_ARGS)
+    nn_w_dropout = _common_generation("dense", dropout=0.4)
+    nn = _common_generation("dense")
 
     # The number of layers should be input layer + len(OUT_SIZES)
     assert len(nn.layers) == len(OUT_SIZES) + 1
+    # And one more with dropout
+    assert len(nn_w_dropout.layers) == len(OUT_SIZES) + 2
+
     # Check that the number of parameters is as expected
-    expected_sizes = [(INSIZE, OUT_SIZES[0]), (OUT_SIZES[0]), (*OUT_SIZES,), (OUT_SIZES[1])]
+    expected_sizes = [(INSIZE, OUT_SIZES[0])]
+    for i, oz in enumerate(OUT_SIZES[:-1]):
+        expected_sizes.append((oz,))
+        expected_sizes.append((oz, OUT_SIZES[i + 1]))
+    expected_sizes.append((OUT_SIZES[-1],))
     for weight, esize in zip(nn.weights, expected_sizes):
         assert weight.shape == esize
 
 
 def test_generate_dense_per_flavour_network():
-    nn = generate_nn("dense_per_flavour", **COMMON_ARGS).get_layer(f"{NN_PREFIX}_0")
+    nn = _common_generation("dense_per_flavour")
 
     # The number of layers should be input + BASIS_SIZE*len(OUT_SIZES) + concatenate
     assert len(nn.layers) == BASIS_SIZE * len(OUT_SIZES) + 2
     # The shape for this network of denses for flavours will depend on the basis_size
     expected_sizes = []
     expected_sizes += BASIS_SIZE * [(INSIZE, OUT_SIZES[0]), (OUT_SIZES[0],)]
-    expected_sizes += BASIS_SIZE * [(OUT_SIZES[0], 1), (1,)]
+    for i, oz in enumerate(OUT_SIZES[1:-1]):
+        expected_sizes += BASIS_SIZE * [(OUT_SIZES[i], oz), (oz,)]
+    expected_sizes += BASIS_SIZE * [(oz, 1), (1,)]
+
     for weight, esize in zip(nn.weights, expected_sizes):
         assert weight.shape == esize
+
+
+def test_replica_settings():
+    """Checks that the _ReplicaSettings object works as expected and
+    that it matches the input of _generate_nn"""
+    config = {
+        "seed": 8,
+        "nodes": [4, 10],
+        "activations": ["linear"] * 2,
+        "architecture": "dense",
+        "initializer": "glorot_uniform",
+        "dropout_rate": 0.4,
+    }
+
+    rsettings = parse_input(config, ReplicaSettings)
+
+    with pytest.raises(ValueError):
+        ctmp = {**config, "regularizer_args": {"some": 4}}
+        ReplicaSettings(**ctmp)
+
+    with pytest.raises(ValueError):
+        ctmp = {**config, "nodes": [2]}
+        ReplicaSettings(**ctmp)
+
+    x = Input(shape=(None, 2))
+    nn = _generate_nn(x, 0, **asdict(rsettings))
+
+    nn.layers == (1 + len(rsettings.nodes) + 1 * rsettings.dropout_rate)

n3fit/tests/test_multireplica.py

@@ -1,28 +1,23 @@
 import numpy as np
 
-from n3fit.model_gen import generate_pdf_model
+from n3fit.model_gen import ReplicaSettings, generate_pdf_model
+
+EPS = 1e-9
+FAKE_FL = [
+    {"fl": i, "largex": [0.5, 1.5], "smallx": [1.5, 2.5]}
+    for i in ["u", "ubar", "d", "dbar", "c", "g", "s", "sbar"]
+]
 
 
 def test_replica_split():
     """Check that multi replica pdf and concatenated single output pdfs agree"""
     num_replicas = 3
     replica_axis = 1
-    fake_fl = [
-        {"fl": i, "largex": [0.5, 1.5], "smallx": [1.5, 2.5]}
-        for i in ["u", "ubar", "d", "dbar", "c", "g", "s", "sbar"]
-    ]
-    pdf_model = generate_pdf_model(
-        nodes=[8],
-        activations=["linear"],
-        seed=34,
-        flav_info=fake_fl,
-        fitbasis="FLAVOUR",
-        num_replicas=num_replicas,
-    )
+    rps = num_replicas * [ReplicaSettings(nodes=[8], activations=["linear"], seed=34)]
+    pdf_model = generate_pdf_model(rps, flav_info=FAKE_FL, fitbasis="FLAVOUR")
     rng = np.random.default_rng(seed=34)
-    eps = 1e-9
-    pdf_input = np.maximum(rng.random((1, 5, 1)), eps)
-    int_input = np.maximum(rng.random((1, 2_000, 1)), eps)
+    pdf_input = np.maximum(rng.random((1, 5, 1)), EPS)
+    int_input = np.maximum(rng.random((1, 2_000, 1)), EPS)
 
     fake_input = {
         'pdf_input': np.sort(pdf_input, axis=1),
@@ -36,3 +31,44 @@ def test_replica_split():
     output_split_stacked = np.stack(output_split, axis=replica_axis)
 
     np.testing.assert_allclose(output_full, output_split_stacked, rtol=1e-5)
+
+
+def test_multimodel(seed=42, xlen=5):
+    """Check that we can run different models, with different settings,
+    in one go.
+
+    This tests runs 3 replicas with 1, 2, and 3 layers respectively.
+    """
+    nodes = [20, 10, 8]
+    activations = ["tanh", "sigmoid", "linear"]
+    init_array = ["glorot_normal", "glorot_uniform", "random_uniform"]
+
+    rps = []
+    for i, initialization in enumerate(init_array):
+        idx = i + 1
+        rps.append(
+            ReplicaSettings(
+                nodes=nodes[-idx:],
+                activations=activations[-idx:],
+                seed=seed + idx,
+                initializer=initialization,
+            )
+        )
+
+    rng = np.random.default_rng(seed=seed)
+    pdf_input = np.maximum(rng.random((1, xlen, 1)), EPS)
+    int_input = np.maximum(rng.random((1, 2000, 1)), EPS)
+    fake_input = {
+        'pdf_input': np.sort(pdf_input, axis=1),
+        'xgrid_integration': np.sort(int_input, axis=1),
+    }
+
+    pdf_model = generate_pdf_model(rps, flav_info=FAKE_FL, fitbasis="FLAVOUR")
+    output_full = pdf_model(fake_input)
+    # Check that the output size is what we expect
+    np.testing.assert_array_equal(output_full.shape, (1, len(rps), xlen, 14))
+    # And now check that the split model has the right layers
+    single_replicas = pdf_model.split_replicas()
+
+    for i, model in enumerate(single_replicas):
+        len(model.get_layer("all_NNs").weights) == 2 * (i + 1)

n3fit/tests/test_penalties.py

@@ -1,10 +1,11 @@
 """
-    Test the penalties for n3fit hyperopt
+Test the penalties for n3fit hyperopt
 """
+
 from types import SimpleNamespace
 
 from n3fit.hyper_optimization.penalties import integrability, patience, saturation
-from n3fit.model_gen import generate_pdf_model
+from n3fit.model_gen import ReplicaSettings, generate_pdf_model
 
 
 def test_saturation():
@@ -13,9 +14,8 @@ def test_saturation():
         {"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=0, flav_info=fake_fl, fitbasis="FLAVOUR"
-    )
+    rps = [ReplicaSettings(nodes=[8], activations=["linear"], seed=0)]
+    pdf_model = generate_pdf_model(rps, flav_info=fake_fl, fitbasis="FLAVOUR")
     assert isinstance(saturation(pdf_model, 5)[0], float)
 
 
@@ -34,7 +34,6 @@ def test_integrability_numbers():
         {"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=0, flav_info=fake_fl, fitbasis="FLAVOUR"
-    )
+    rps = [ReplicaSettings(nodes=[8], activations=["linear"], seed=0)]
+    pdf_model = generate_pdf_model(rps, flav_info=fake_fl, fitbasis="FLAVOUR")
     assert isinstance(integrability(pdf_model), float)

n3fit/tests/test_preprocessing.py

@@ -102,8 +102,8 @@ def test_constraint():
     # Check that now everything satisfies the constraint again
     for w in prepro.weights:
         if w.trainable:
-            assert np.alltrue(w.constraint.min_value <= w.numpy())
-            assert np.alltrue(w.numpy() <= w.constraint.max_value)
+            assert np.all(w.constraint.min_value <= w.numpy())
+            assert np.all(w.numpy() <= w.constraint.max_value)
 
     # Check that other replicas were not affected
     for wa, wb in zip(weights_after[1:], weights_before[1:]):

n3fit/tests/test_vpinterface.py

@@ -1,12 +1,12 @@
 """
-    Test the n3fit-validphys interface
+Test the n3fit-validphys interface
 """
 
 from hypothesis import example, given, settings
 from hypothesis.strategies import integers
 import numpy as np
 
-from n3fit.model_gen import generate_pdf_model
+from n3fit.model_gen import ReplicaSettings, generate_pdf_model
 from n3fit.vpinterface import N3PDF, compute_arclength, integrability_numbers
 from validphys.pdfgrids import distance_grids, xplotting_grid
 
@@ -19,14 +19,9 @@ def generate_n3pdf(layers=1, members=1, name="n3fit"):
     ]
     nodes = list(np.random.randint(1, 10, size=layers)) + [8]
     activations = ["tanh"] * layers + ["linear"]
-    pdf_model = generate_pdf_model(
-        nodes=nodes,
-        activations=activations,
-        seed=np.random.randint(100),
-        flav_info=fake_fl,
-        num_replicas=members,
-        fitbasis="FLAVOUR",
-    ).split_replicas()
+    seeds = np.random.randint(100, size=members)
+    rps = [ReplicaSettings(nodes=nodes, activations=activations, seed=seed) for seed in seeds]
+    pdf_model = generate_pdf_model(rps, flav_info=fake_fl, fitbasis="FLAVOUR").split_replicas()
     return N3PDF(pdf_model, name=name)
 
 

n3fit/vpinterface.py

@@ -6,32 +6,36 @@ Example
 
 >>> import numpy as np
 >>> from n3fit.vpinterface import N3PDF
->>> from n3fit.model_gen import pdfNN_layer_generator
+>>> from n3fit.model_gen import generate_pdf_model, ReplicaSettings
 >>> from validphys.pdfgrids import xplotting_grid
->>> fake_fl = [{'fl' : i, 'largex' : [0,1], 'smallx': [1,2]} for i in ['u', 'ubar', 'd', 'dbar', 'c', 'cbar', 's', 'sbar']]
+>>> fake_fl = [{'fl' : i, 'largex' : [0,1], 'smallx': [1,2]} for i in ['u', 'ubar', 'd', 'dbar', 'c', 's', 'sbar', 'g']]
 >>> fake_x = np.linspace(1e-3,0.8,3)
->>> pdf_model = pdfNN_layer_generator(nodes=[8], activations=['linear'], seed=0, flav_info=fake_fl)
->>> n3pdf = N3PDF(pdf_model)
+>>> rps = [ReplicaSettings(nodes=[8], activations=["linear"], seed=4)]*4
+>>> pdf_model = generate_pdf_model(rps, flav_info=fake_fl, fitbasis='FLAVOUR')
+>>> n3pdf = N3PDF(pdf_model.split_replicas())
 >>> res = xplotting_grid(n3pdf, 1.6, fake_x)
 >>> res.grid_values.error_members().shape
-(1, 8, 3)
-
+(4, 8, 3)
+# (nreplicas, flavours, x-grid)
 
 """
 
 from collections.abc import Iterable
+from dataclasses import dataclass
 from functools import cached_property
 import logging
 
 import numpy as np
-import numpy.linalg as la
+import pandas as pd
+import scipy.linalg as la
 
 from validphys.arclength import arc_lengths, integrability_number
+from validphys.calcutils import calc_chi2, calc_phi
+from validphys.convolution import central_predictions, predictions
 from validphys.core import PDF, MCStats
-from validphys.covmats import covmat_from_systematics, sqrt_covmat
+from validphys.covmats import dataset_inputs_covmat_from_systematics
 from validphys.lhapdfset import LHAPDFSet
 from validphys.pdfbases import ALL_FLAVOURS, check_basis
-from validphys.results import abs_chi2_data, phi_data, results
 
 log = logging.getLogger(__name__)
 # Order of the evolution basis output from n3fit
@@ -53,6 +57,13 @@ EVOL_LIST = [
 ]
 
 
+@dataclass
+class HyperoptMetrics:
+    chi2: float
+    phi2: float
+    logp: float
+
+
 class N3Stats(MCStats):
     """The PDFs from n3fit are MC PDFs
     however, since there is no grid, the CV has to be computed manually"""
@@ -67,13 +78,14 @@ class N3Stats(MCStats):
 class N3LHAPDFSet(LHAPDFSet):
     """Extension of LHAPDFSet using n3fit models"""
 
-    def __init__(self, name, pdf_models, Q=1.65):
+    def __init__(self, name, pdf_models, Q=1.65, is_t0=False):
         log.debug("Creating LHAPDF-like n3fit PDF")
         self._error_type = "replicas"
         self._name = name
         self._lhapdf_set = pdf_models
         self._flavors = None
         self._fitting_q = Q
+        self._is_t0 = is_t0
         self.basis = check_basis("evolution", EVOL_LIST)["basis"]
 
     def xfxQ(self, x, Q, n, fl):
@@ -124,12 +136,12 @@ class N3LHAPDFSet(LHAPDFSet):
         # Register the grid with the photon
         self._register_photon(mod_xgrid)
 
-        if replica is None or replica == 0:
+        if replica is None or replica == 0 or self._is_t0:
             # We need generate output values for all replicas
             result = np.concatenate(
                 [m.predict({"pdf_input": mod_xgrid}) for m in self._lhapdf_set], axis=0
             )
-            if replica == 0:
+            if replica == 0 or self._is_t0:
                 # We want _only_ the central value
                 result = np.mean(result, axis=0, keepdims=True)
         else:
@@ -227,6 +239,10 @@ class N3PDF(PDF):
         """If the function needs an LHAPDF object, return a N3LHAPDFSet"""
         return self._lhapdf_set
 
+    def load_t0(self):
+        """Load the central PDF object"""
+        return N3LHAPDFSet(self.name, self._models, Q=self._Q, is_t0=True)
+
     def get_nn_weights(self):
         """Outputs all weights of the NN as numpy.ndarrays"""
         return [model.get_weights() for model in self._models]
@@ -326,7 +342,6 @@ def compute_arclength(self, q0=1.65, basis="evolution", flavours=None):
     """
     Given the layer with the fit basis computes the arc length
     using the corresponding validphys action
-
     Parameters
     ----------
         pdf_function: function
@@ -337,7 +352,6 @@ def compute_arclength(self, q0=1.65, basis="evolution", flavours=None):
             basis in which to compute the arc length
         flavours: list
             output flavours
-
     Example
     -------
     >>> from n3fit.vpinterface import N3PDF, compute_arclength
@@ -353,10 +367,9 @@ def compute_arclength(self, q0=1.65, basis="evolution", flavours=None):
     return ret.stats.central_value()
 
 
-def compute_phi(n3pdf, experimental_data):
-    """Compute phi using validphys functions.
-
-    For more info on how phi is calculated; see Eq.(4.6) of 10.1007/JHEP04(2015)040
+def compute_hyperopt_metrics(n3pdf, experimental_data) -> HyperoptMetrics:
+    """Compute the different hyperopt quantities from which one defines
+    the hyperopt metric.
 
     Parameters
     ----------
@@ -367,43 +380,74 @@ def compute_phi(n3pdf, experimental_data):
 
     Returns
     -------
-        sum_phi: float
-            Sum of phi over all experimental group datasets
+        HyperoptMetrics: :class:`n3fit.vpinterface.HyperoptMetrics`
+            dataclass holding the values of chi2, phi2 and logp
 
     Example
     -------
-    >>> from n3fit.vpinterface import N3PDF, compute_phi
-    >>> from n3fit.model_gen import generate_pdf_model
+    >>> from n3fit.vpinterface import N3PDF, compute_hyperopt_metrics
+    >>> from n3fit.model_gen import generate_pdf_model, ReplicaSettings
     >>> from validphys.loader import Loader
     >>> 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=0, num_replicas=2, flav_info=fake_fl, fitbasis="FLAVOUR")
+    >>> rps = [ReplicaSettings(nodes=[8], activations=["linear"], seed=i) for i in [0,1]]
+    >>> pdf_model = generate_pdf_model(rps, flav_info=fake_fl, fitbasis="FLAVOUR")
     >>> n3pdf = N3PDF(pdf_model.split_replicas())
-    >>> ds = Loader().check_dataset("NMC_NC_NOTFIXED_P_EM-SIGMARED", theoryid=399, cuts="internal")
+    >>> ds = Loader().check_dataset("NMC_NC_NOTFIXED_P_EM-SIGMARED", theoryid=40_000_000, cuts="internal", variant="legacy")
     >>> data_group_spec = Loader().check_experiment("My DataGroupSpec", [ds])
-    >>> phi = compute_phi(n3pdf, [data_group_spec])
+    >>> hyperopt_losses = compute_hyperopt_metrics(n3pdf, [data_group_spec])
     """
-    sum_phi = 0.0
-    ndat_tot = 0
+    exp_cv = []
+    th_cvs = []
+    th_rep = []
+    cds_list = []
+
     # Loop over the list of `DataGroupSpec` objects
     for datagroupspec in experimental_data:
         # datagroupspec is an instance of `DataGroupSpec`
-
         # Loop over `DataGroupSpec` datasets
         for datasetspec in datagroupspec.datasets:
             # datasetspec is an instance of `DataSetSpec`
-
-            # get covariant matrix for each `DataSetSpec`
-            covmat = covmat_from_systematics(datasetspec.load_commondata(), datasetspec)
-
-            # get experiment info (`DataResult`) and theory predictions (`ThPredictionsResult`)
-            res = results(datasetspec, n3pdf, covmat, sqrt_covmat(covmat))
-
-            # calculate standard chi2 (all_chi2) and chi2 using PDF central values (central_chi2)
-            chi2 = abs_chi2_data(res)
-
-            # calculate phi and store phi**2
-            phi, ndat = phi_data(chi2)
-            sum_phi += ndat * phi**2
-            ndat_tot += ndat
-
-    return np.sqrt(sum_phi / ndat_tot)
+            # update list of CommonData and corresponding central values
+            cd = datasetspec.load_commondata()
+            cds_list.append(cd)
+            exp_cv.append(cd.central_values)
+            # update list of th pred, for the central value and for each replica
+            th_cvs.append(central_predictions(datasetspec, n3pdf))
+            th_rep.append(predictions(datasetspec, n3pdf))
+
+    pred_cvs = pd.concat(th_cvs, axis=0, ignore_index=True)
+    pred_rep = pd.concat(th_rep, axis=0, ignore_index=True)
+    expr_cvs = pd.concat(exp_cv, axis=0, ignore_index=True)
+    diffs = pred_cvs.values.flatten() - expr_cvs.values.flatten()
+    diffs_reps = pred_rep.values - expr_cvs.values[:, np.newaxis]
+
+    exp_cov = dataset_inputs_covmat_from_systematics(cds_list, use_weights_in_covmat=False)
+    exp_covmat_col = la.cholesky(exp_cov, lower=True)
+
+    # If there is only one replica, we don't account for PDF covmat
+    if pred_rep.shape[1] == 1:
+        total_covmat = exp_cov
+    else:
+        pdf_cov = np.cov(pred_rep.values)
+        assert exp_cov.shape == pdf_cov.shape
+        total_covmat = exp_cov + pdf_cov
+
+    # Compute the log_det
+    # Normalize the total covmat to central values of experimental data
+    norm_total_covmat = total_covmat / np.outer(
+        expr_cvs.values.flatten(), expr_cvs.values.flatten()
+    )
+    norm_total_covmat_chol = la.cholesky(norm_total_covmat, lower=True)
+    log_det_total_cov = 2 * np.sum(np.log(np.diag(norm_total_covmat_chol)))
+
+    # Compute the chi2
+    total_covmat_chol = la.cholesky(total_covmat, lower=True)
+    chi2 = calc_chi2(sqrtcov=total_covmat_chol, diffs=diffs)
+
+    # Compute phi2
+    phi2 = calc_phi(sqrtcov=exp_covmat_col, diffs=diffs_reps)
+
+    ndat = len(diffs)
+    logp = -0.5 * (len(diffs) * np.log(2 * np.pi) + log_det_total_cov + chi2)
+
+    return HyperoptMetrics(chi2=chi2 / ndat, phi2=phi2, logp=-logp / ndat)

{nnpdf-4.1.0.dist-info → nnpdf-4.1.1.dist-info}/METADATA

@@ -1,8 +1,9 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: nnpdf
-Version: 4.1.0
+Version: 4.1.1
 Summary: An open-source machine learning framework for global analyses of parton distributions.
 License: GPL-3.0-or-later
+License-File: LICENSE
 Author: NNPDF Collaboration
 Requires-Python: >=3.9
 Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
@@ -14,9 +15,11 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Scientific/Engineering
 Classifier: Topic :: Scientific/Engineering :: Physics
 Provides-Extra: docs
+Provides-Extra: jax
 Provides-Extra: nolha
 Provides-Extra: parallelhyperopt
 Provides-Extra: qed
@@ -26,9 +29,10 @@ Requires-Dist: eko (>=0.15.1,<0.16.0)
 Requires-Dist: fiatlux ; extra == "qed"
 Requires-Dist: hyperopt
 Requires-Dist: hypothesis ; extra == "tests"
+Requires-Dist: jax ; extra == "jax"
 Requires-Dist: joblib
 Requires-Dist: keras (>=3.1,<4.0)
-Requires-Dist: lhapdf-management (>=0.5,<0.6) ; extra == "nolha"
+Requires-Dist: lhapdf-management (>=0.6,<0.7) ; extra == "nolha"
 Requires-Dist: matplotlib (>=3.9,<4.0)
 Requires-Dist: numpy
 Requires-Dist: packaging
@@ -62,7 +66,9 @@ Description-Content-Type: text/markdown
 [![Docs](https://github.com/NNPDF/nnpdf/actions/workflows/upload_docs.yml/badge.svg)](https://github.com/NNPDF/nnpdf/actions/workflows/upload_docs.yml)
 [![Commondata](https://github.com/NNPDF/nnpdf/actions/workflows/check_newcd.yml/badge.svg)](https://github.com/NNPDF/nnpdf/actions/workflows/check_newcd.yml)
 
+[![EPJC](https://img.shields.io/badge/Eur.Phys.J.C-81%20(2021)%2010-958?color=%231A43BF)](https://link.springer.com/article/10.1140/epjc/s10052-021-09747-9)
 [![DOI](https://zenodo.org/badge/118135201.svg)](https://zenodo.org/badge/latestdoi/118135201)
+[![HSF](https://hepsoftwarefoundation.org/images/HSF-logo/HSF-Affiliated.svg)](https://hepsoftwarefoundation.org/projects/projects)
 
 # NNPDF: An open-source machine learning framework for global analyses of parton distributions