Apply black, isort to modified files

n3fit/src/n3fit/backends/keras_backend/operations.py

@@ -210,11 +210,13 @@ def flatten(x):
     """Flatten tensor x"""
     return tf.reshape(x, (-1,))
 
+
 @tf.function
 def reshape(x, shape):
-    """ reshape tensor x """
+    """reshape tensor x"""
     return tf.reshape(x, shape)
 
+
 def boolean_mask(*args, **kwargs):
     """
     Applies a boolean mask to a tensor

n3fit/src/n3fit/checks.py

@@ -362,11 +362,11 @@ def check_consistent_parallel(parameters, parallel_models, same_trvl_per_replica
     """
     if not parallel_models:
         return
-#    if not same_trvl_per_replica:
-#        raise CheckError(
-#            "Replicas cannot be run in parallel with different training/validation "
-#            " masks, please set `same_trvl_per_replica` to True in the runcard"
-#        )
+    #    if not same_trvl_per_replica:
+    #        raise CheckError(
+    #            "Replicas cannot be run in parallel with different training/validation "
+    #            " masks, please set `same_trvl_per_replica` to True in the runcard"
+    #        )
     if parameters.get("layer_type") != "dense":
         raise CheckError("Parallelization has only been tested with layer_type=='dense'")
 

n3fit/src/n3fit/layers/losses.py

@@ -8,6 +8,7 @@
 
 """
 import numpy as np
+
 from n3fit.backends import MetaLayer
 from n3fit.backends import operations as op
 
@@ -55,9 +56,7 @@ def build(self, input_shape):
         """Transform the inverse covmat and the mask into
         weights of the layers"""
         init = MetaLayer.init_constant(self._invcovmat)
-        self.kernel = self.builder_helper(
-            "invcovmat", self._invcovmat.shape, init, trainable=False
-        )
+        self.kernel = self.builder_helper("invcovmat", self._invcovmat.shape, init, trainable=False)
         mask_shape = (1, 1, self._ndata)
         if self._mask is None:
             init_mask = MetaLayer.init_constant(np.ones(mask_shape))
@@ -84,7 +83,7 @@ def call(self, y_pred, **kwargs):
         tmp_raw = self._y_true - y_pred
         # TODO: most of the time this is a y * I multiplication and can be skipped
         # benchmark how much time (if any) is lost in this in actual fits for the benefit of faster kfolds
-#        import pdb; pdb.set_trace()
+        #        import pdb; pdb.set_trace()
         tmp = op.op_multiply([tmp_raw, self.mask])
         if self._diag:
             return LossInvcovmat.contract_covmat_diag(self.kernel, tmp)

n3fit/src/n3fit/layers/mask.py

@@ -1,6 +1,8 @@
+from numpy import count_nonzero
+
 from n3fit.backends import MetaLayer
 from n3fit.backends import operations as op
-from numpy import count_nonzero
+
 
 class Mask(MetaLayer):
     """
@@ -40,9 +42,7 @@ def __init__(self, bool_mask=None, c=None, axis=None, **kwargs):
     def build(self, input_shape):
         if self.c is not None:
             initializer = MetaLayer.init_constant(value=self.c)
-            self.kernel = self.builder_helper(
-                "mask", (1,), initializer, trainable=False
-            )
+            self.kernel = self.builder_helper("mask", (1,), initializer, trainable=False)
         super(Mask, self).build(input_shape)
 
     def call(self, ret):

n3fit/src/n3fit/model_gen.py

@@ -23,15 +23,16 @@
     AddPhoton,
     FkRotation,
     FlavourToEvolution,
+    Mask,
     ObsRotation,
     Preprocessing,
-    Mask,
     losses,
 )
 from n3fit.layers.observable import is_unique
 from n3fit.msr import generate_msr_model_and_grid
 from validphys.photon.compute import Photon
 
+
 @dataclass
 class ObservableWrapper:
     """Wraps many observables into an experimental layer once the PDF model is prepared
@@ -62,8 +63,13 @@ def _generate_loss(self, mask=None):
         was initialized with"""
         if self.invcovmat is not None:
             loss = losses.LossInvcovmat(
-                self.invcovmat, self.data, mask, covmat=self.covmat, name=self.name,
-                diag=(self.rotation is not None))
+                self.invcovmat,
+                self.data,
+                mask,
+                covmat=self.covmat,
+                name=self.name,
+                diag=(self.rotation is not None),
+            )
         elif self.positivity:
             loss = losses.LossPositivity(name=self.name, c=self.multiplier)
         elif self.integrability:
@@ -104,14 +110,15 @@ def __call__(self, pdf_layer, mask=None):
         return loss_f(experiment_prediction)
 
 
-def observable_generator(spec_dict,
-                         mask_array=None,
-                         training_data=None,
-                         validation_data=None,
-                         invcovmat_tr=None,
-                         invcovmat_vl=None,
-                         positivity_initial=1.0,
-                         integrability=False
+def observable_generator(
+    spec_dict,
+    mask_array=None,
+    training_data=None,
+    validation_data=None,
+    invcovmat_tr=None,
+    invcovmat_vl=None,
+    positivity_initial=1.0,
+    integrability=False,
 ):  # pylint: disable=too-many-locals
     """
     This function generates the observable models for each experiment.
@@ -182,10 +189,8 @@ def observable_generator(spec_dict,
         #   these will then be used to check how many different pdf inputs are needed
         #   (and convolutions if given the case)
         obs_layer = Obs_Layer(
-            dataset.fktables_data,
-            dataset.fktables(),
-            operation_name,
-            name=f"dat_{dataset_name}")
+            dataset.fktables_data, dataset.fktables(), operation_name, name=f"dat_{dataset_name}"
+        )
 
         # If the observable layer found that all input grids are equal, the splitting will be None
         # otherwise the different xgrids need to be stored separately

n3fit/src/n3fit/model_trainer.py

@@ -215,13 +215,7 @@ def __init__(
             "folds": [],
             "posdatasets": [],
         }
-        self.experimental = {
-            "output": [],
-            "expdata": [],
-            "ndata": 0,
-            "model": None,
-            "folds": [],
-        }
+        self.experimental = {"output": [], "expdata": [], "ndata": 0, "model": None, "folds": []}
         self.tr_masks = []
 
         self._fill_the_dictionaries()
@@ -539,12 +533,14 @@ def _generate_observables(
             invcovmat = np.stack([e[index]["invcovmat"] for e in self.exp_info])
             invcovmat_vl = np.stack([e[index]["invcovmat_vl"] for e in self.exp_info])
 
-            exp_layer = model_gen.observable_generator(exp_dict,
-                                                       mask_array=replica_masks,
-                                                       training_data=training_data,
-                                                       validation_data=validation_data,
-                                                       invcovmat_tr=invcovmat,
-                                                       invcovmat_vl=invcovmat_vl)
+            exp_layer = model_gen.observable_generator(
+                exp_dict,
+                mask_array=replica_masks,
+                training_data=training_data,
+                validation_data=validation_data,
+                invcovmat_tr=invcovmat,
+                invcovmat_vl=invcovmat_vl,
+            )
 
             # Save the input(s) corresponding to this experiment
             self.input_list.append(exp_layer["inputs"])
@@ -566,13 +562,17 @@ def _generate_observables(
                 all_pos_initial, all_pos_multiplier, max_lambda, positivity_steps
             )
             replica_masks = np.stack([pos_dict["trmask"] for i in range(len(self.exp_info))])
-            training_data = np.stack([pos_dict["expdata"].flatten() for i in range(len(self.exp_info))])
+            training_data = np.stack(
+                [pos_dict["expdata"].flatten() for i in range(len(self.exp_info))]
+            )
 
-            pos_layer = model_gen.observable_generator(pos_dict,
-                                                       positivity_initial=pos_initial,
-                                                       mask_array=replica_masks,
-                                                       training_data=training_data,
-                                                       validation_data=training_data)
+            pos_layer = model_gen.observable_generator(
+                pos_dict,
+                positivity_initial=pos_initial,
+                mask_array=replica_masks,
+                training_data=training_data,
+                validation_data=training_data,
+            )
             # The input list is still common
             self.input_list.append(pos_layer["inputs"])
 

n3fit/src/n3fit/performfit.py

@@ -170,9 +170,7 @@ def performfit(
         #    all_experiments[i_exp]['expdata'] = np.concatenate(training_data, axis=0)
         #    all_experiments[i_exp]['expdata_vl'] = np.concatenate(validation_data, axis=0)
         log.info(
-            "Starting parallel fits from replica %d to %d",
-            replicas[0],
-            replicas[0] + n_models - 1,
+            "Starting parallel fits from replica %d to %d", replicas[0], replicas[0] + n_models - 1
         )
         replicas_info = [(replicas, replica_experiments, nnseeds)]
     else:
@@ -271,12 +269,7 @@ def performfit(
         q0 = theoryid.get_description().get("Q0")
         pdf_instances = [N3PDF(pdf_model, fit_basis=basis, Q=q0) for pdf_model in pdf_models]
         writer_wrapper = WriterWrapper(
-            replica_idxs,
-            pdf_instances,
-            stopping_object,
-            all_chi2s,
-            theoryid,
-            final_time,
+            replica_idxs, pdf_instances, stopping_object, all_chi2s, theoryid, final_time
         )
         writer_wrapper.write_data(replica_path, output_path.name, save)
 

validphys2/src/validphys/commondata.py

@@ -6,9 +6,11 @@
 :py:mod:`validphys.coredata`
 
 """
+import functools
+
 from reportengine import collect
 from validphys.commondataparser import load_commondata
-import functools
+
 
 @functools.lru_cache
 def loaded_commondata_with_cuts(commondata, cuts):

validphys2/src/validphys/config.py

@@ -15,6 +15,7 @@
 import numbers
 import pathlib
 
+from frozendict import frozendict
 import pandas as pd
 
 from reportengine import configparser, report
@@ -45,13 +46,12 @@
 )
 from validphys.paramfits.config import ParamfitsConfig
 from validphys.plotoptions import get_info
-from validphys.utils import freeze_args
-from frozendict import frozendict
 import validphys.scalevariations
-
+from validphys.utils import freeze_args
 
 log = logging.getLogger(__name__)
 
+
 class Environment(Environment):
     """Container for information to be filled at run time"""
 

validphys2/src/validphys/core.py

@@ -508,18 +508,12 @@ def __init__(self, name, commondataspec, fkspec, maxlambda, thspec):
         cuts = Cuts(commondataspec, None)
         self.maxlambda = maxlambda
         super().__init__(
-            name=name,
-            commondata=commondataspec,
-            fkspecs=fkspec,
-            thspec=thspec,
-            cuts=cuts,
+            name=name, commondata=commondataspec, fkspecs=fkspec, thspec=thspec, cuts=cuts
         )
 
     def to_unweighted(self):
         log.warning(
-            "Trying to unweight %s, %s are always unweighted",
-            self.__class__.__name__,
-            self.name,
+            "Trying to unweight %s, %s are always unweighted", self.__class__.__name__, self.name
         )
         return self
 
@@ -591,9 +585,7 @@ def to_unweighted(self):
         """Return a copy of the group with the weights for all experiments set
         to one. Note that the results cannot be used as a namespace."""
         return self.__class__(
-            name=self.name,
-            datasets=[ds.to_unweighted() for ds in self.datasets],
-            dsinputs=None,
+            name=self.name, datasets=[ds.to_unweighted() for ds in self.datasets], dsinputs=None
         )
 
 
@@ -856,11 +848,7 @@ def moment(self, order):
         return np.sum(np.power((data[1::2] - data[2::2]) / self.rescale_factor / 2, order), axis=0)
 
 
-STAT_TYPES = dict(
-    symmhessian=SymmHessianStats,
-    hessian=HessianStats,
-    replicas=MCStats,
-)
+STAT_TYPES = dict(symmhessian=SymmHessianStats, hessian=HessianStats, replicas=MCStats)
 
 
 class Filter:

validphys2/src/validphys/covmats.py

@@ -1,8 +1,8 @@
 """Module for handling logic and manipulation of covariance and correlation
 matrices on different levels of abstraction
 """
-import logging
 import functools
+import logging
 
 import numpy as np
 import pandas as pd
@@ -375,10 +375,7 @@ def dataset_inputs_t0_exp_covmat_separate(
     return covmat
 
 
-def dataset_inputs_total_covmat_separate(
-    dataset_inputs_exp_covmat_separate,
-    loaded_theory_covmat,
-):
+def dataset_inputs_total_covmat_separate(dataset_inputs_exp_covmat_separate, loaded_theory_covmat):
     """
     Function to compute the covmat to be used for the sampling by make_replica.
     In this case the t0 prescription is not used for the experimental covmat and the multiplicative
@@ -412,10 +409,7 @@ def dataset_inputs_exp_covmat_separate(
     return covmat
 
 
-def dataset_inputs_t0_total_covmat(
-    dataset_inputs_t0_exp_covmat,
-    loaded_theory_covmat,
-):
+def dataset_inputs_t0_total_covmat(dataset_inputs_t0_exp_covmat, loaded_theory_covmat):
     """
     Function to compute the covmat to be used for the sampling by make_replica and for the chi2
     by fitting_data_dict. In this case the t0 prescription is used for the experimental covmat
@@ -450,10 +444,7 @@ def dataset_inputs_t0_exp_covmat(
     return covmat
 
 
-def dataset_inputs_total_covmat(
-    dataset_inputs_exp_covmat,
-    loaded_theory_covmat,
-):
+def dataset_inputs_total_covmat(dataset_inputs_exp_covmat, loaded_theory_covmat):
     """
     Function to compute the covmat to be used for the sampling by make_replica and for the chi2
     by fitting_data_dict. In this case the t0 prescription is not used for the experimental covmat
@@ -591,7 +582,7 @@ def sqrt_covmat(covariance_matrix):
     dimensions = covariance_matrix.shape
 
     if covariance_matrix.size == 0:
-        return np.zeros((0,0))
+        return np.zeros((0, 0))
     elif dimensions[0] != dimensions[1]:
         raise ValueError(
             "The input covariance matrix should be square but "
@@ -743,9 +734,9 @@ def pdferr_plus_covmat(dataset, pdf, covmat_t0_considered):
     elif pdf.error_type == 'hessian':
         rescale_fac = pdf._rescale_factor()
         hessian_eigenvectors = th.error_members
-        
+
         # see core.HessianStats
-        X = (hessian_eigenvectors[:,0::2] - hessian_eigenvectors[:,1::2])*0.5
+        X = (hessian_eigenvectors[:, 0::2] - hessian_eigenvectors[:, 1::2]) * 0.5
         # need to rescale the Hessian eigenvectors in case the eigenvector confidence interval is not 68%
         X = X / rescale_fac
         pdf_cov = X @ X.T
@@ -954,10 +945,4 @@ def _dataset_inputs_covmat_t0_considered(dataset_inputs_covmat_t0_considered, fi
 
 datasets_covmat = collect('covariance_matrix', ('data',))
 
-datasets_covariance_matrix = collect(
-    'covariance_matrix',
-    (
-        'experiments',
-        'experiment',
-    ),
-)
+datasets_covariance_matrix = collect('covariance_matrix', ('experiments', 'experiment'))