Move stateful initialization to a pre_fit function

csrank/choicefunction/baseline.py

@@ -18,7 +18,7 @@ def __init__(self, **kwargs):
         """
 
     def fit(self, X, Y, **kwd):
-        pass
+        self._pre_fit()
 
     def _predict_scores_fixed(self, X, Y, **kwargs):
         return np.zeros_like(Y) + Y.mean()

csrank/choicefunction/cmpnet_choice.py

@@ -154,6 +154,7 @@ def fit(
             **kwd :
                 Keyword arguments for the fit function
         """
+        self._pre_fit()
         if tune_size > 0:
             X_train, X_val, Y_train, Y_val = train_test_split(
                 X, Y, test_size=tune_size, random_state=self.random_state

csrank/choicefunction/fate_choice.py

@@ -163,6 +163,7 @@ def fit(
                 documentation of :func:`~csrank.core.FATENetwork.fit` for more
                 information.
         """
+        self._pre_fit()
         if tune_size > 0:
             X_train, X_val, Y_train, Y_val = train_test_split(
                 X, Y, test_size=tune_size, random_state=self.random_state

csrank/choicefunction/fatelinear_choice.py

@@ -73,6 +73,7 @@ def fit(
         verbose=0,
         **kwd,
     ):
+        self._pre_fit()
         if tune_size > 0:
             X_train, X_val, Y_train, Y_val = train_test_split(
                 X, Y, test_size=tune_size, random_state=self.random_state

csrank/choicefunction/feta_choice.py

@@ -286,6 +286,7 @@ def fit(
             **kwd :
                 Keyword arguments for the fit function
         """
+        self._pre_fit()
         if tune_size > 0:
             X_train, X_val, Y_train, Y_val = train_test_split(
                 X, Y, test_size=tune_size, random_state=self.random_state

csrank/choicefunction/fetalinear_choice.py

@@ -71,6 +71,7 @@ def fit(
         verbose=0,
         **kwd,
     ):
+        self._pre_fit()
         if tune_size > 0:
             X_train, X_val, Y_train, Y_val = train_test_split(
                 X, Y, test_size=tune_size, random_state=self.random_state

csrank/choicefunction/generalized_linear_model.py

@@ -158,6 +158,10 @@ def construct_model(self, X, Y):
             BinaryCrossEntropyLikelihood("yl", p=self.p_, observed=self.Yt_)
         logger.info("Model construction completed")
 
+    def _pre_fit(self):
+        super()._pre_fit()
+        self.random_state_ = check_random_state(self.random_state)
+
     def fit(
         self,
         X,
@@ -217,7 +221,7 @@ def fit(
             **kwargs :
                 Keyword arguments for the fit function
         """
-        self.random_state_ = check_random_state(self.random_state)
+        self._pre_fit()
         if tune_size > 0:
             X_train, X_val, Y_train, Y_val = train_test_split(
                 X, Y, test_size=tune_size, random_state=self.random_state_

csrank/choicefunction/pairwise_choice.py

@@ -96,6 +96,7 @@ def fit(self, X, Y, tune_size=0.1, thin_thresholds=1, verbose=0, **kwd):
                 Keyword arguments for the fit function
 
         """
+        self._pre_fit()
         _n_instances, self.n_objects_fit_, self.n_object_features_fit_ = X.shape
         if tune_size > 0:
             X_train, X_val, Y_train, Y_val = train_test_split(

csrank/choicefunction/ranknet_choice.py

@@ -141,6 +141,7 @@ def fit(
             **kwd :
                 Keyword arguments for the fit function
         """
+        self._pre_fit()
         if tune_size > 0:
             X_train, X_val, Y_train, Y_val = train_test_split(
                 X, Y, test_size=tune_size, random_state=self.random_state

csrank/core/cmpnet_core.py

@@ -95,8 +95,6 @@ def construct_model(self):
             model: keras :class:`Model`
                 Neural network to learn the CmpNet utility score
         """
-        self._initialize_optimizer()
-        self._initialize_regularizer()
         x1x2 = concatenate([self.x1, self.x2])
         x2x1 = concatenate([self.x2, self.x1])
         logger.debug("Creating the model")
@@ -116,6 +114,12 @@ def construct_model(self):
         )
         return model
 
+    def _pre_fit(self):
+        super()._pre_fit()
+        self.random_state_ = check_random_state(self.random_state)
+        self._initialize_optimizer()
+        self._initialize_regularizer()
+
     def fit(
         self, X, Y, epochs=10, callbacks=None, validation_split=0.1, verbose=0, **kwd
     ):
@@ -151,8 +155,7 @@ def fit(
             **kwd :
                 Keyword arguments for the fit function
         """
-        self.random_state_ = check_random_state(self.random_state)
-        self._initialize_regularizer()
+        self._pre_fit()
         _n_instances, self.n_objects_fit_, self.n_object_features_fit_ = X.shape
         x1, x2, y_double = self._convert_instances_(X, Y)
 

csrank/core/fate_linear.py

@@ -86,10 +86,14 @@ def step_decay(self, epoch):
             self.loss_
         )
 
+    def _pre_fit(self):
+        super()._pre_fit()
+        self.random_state_ = check_random_state(self.random_state)
+
     def fit(
         self, X, Y, epochs=10, callbacks=None, validation_split=0.1, verbose=0, **kwd
     ):
-        self.random_state_ = check_random_state(self.random_state)
+        self._pre_fit()
         # Global Variables Initializer
         n_instances, self.n_objects_fit_, self.n_object_features_fit_ = X.shape
         self._construct_model_(self.n_objects_fit_)

csrank/core/fate_network.py

@@ -70,9 +70,6 @@ def __init__(
         self.kernel_regularizer = kernel_regularizer
         self.batch_size = batch_size
         self.optimizer = optimizer
-        self._initialize_optimizer()
-        self._initialize_regularizer()
-        self._construct_layers()
         self._store_kwargs(
             kwargs, {"optimizer__", "kernel_regularizer__", "hidden_dense_layer__"}
         )
@@ -148,6 +145,12 @@ def join_input_layers(self, input_layer, *layers, n_layers, n_objects):
 
         return scores
 
+    def _pre_fit(self):
+        super()._pre_fit()
+        self._initialize_optimizer()
+        self._initialize_regularizer()
+        self._construct_layers()
+
 
 class FATENetwork(FATENetworkCore):
     def __init__(self, n_hidden_set_layers=1, n_hidden_set_units=1, **kwargs):
@@ -168,12 +171,6 @@ def __init__(self, n_hidden_set_layers=1, n_hidden_set_units=1, **kwargs):
 
         self.n_hidden_set_layers = n_hidden_set_layers
         self.n_hidden_set_units = n_hidden_set_units
-        self.set_layer = None
-        self._create_set_layers(
-            activation=self.activation,
-            kernel_initializer=self.kernel_initializer,
-            kernel_regularizer=self.kernel_regularizer_,
-        )
 
     def _create_set_layers(self, **kwargs):
         """
@@ -186,11 +183,11 @@ def _create_set_layers(self, **kwargs):
             )
         )
         if self.n_hidden_set_layers >= 1:
-            self.set_layer = DeepSet(
+            self.set_layer_ = DeepSet(
                 units=self.n_hidden_set_units, layers=self.n_hidden_set_layers, **kwargs
             )
         else:
-            self.set_layer = None
+            self.set_layer_ = None
 
     @staticmethod
     def _bucket_frequencies(X, min_bucket_size=32):
@@ -308,6 +305,7 @@ def _fit(
             **kwargs :
                 Keyword arguments for the fit function
         """
+        self._pre_fit()
         if optimizer is not None:
             self.optimizer = optimizer
         if isinstance(X, dict):
@@ -422,7 +420,7 @@ def construct_model(self, n_features, n_objects):
 
         """
         input_layer = Input(shape=(n_objects, n_features), name="input_node")
-        set_repr = self.set_layer(input_layer)
+        set_repr = self.set_layer_(input_layer)
         scores = self.join_input_layers(
             input_layer,
             set_repr,
@@ -438,6 +436,17 @@ def construct_model(self, n_features, n_objects):
         )
         return model
 
+    def _pre_fit(self):
+        super()._pre_fit()
+        self.random_state_ = check_random_state(self.random_state)
+        self._initialize_optimizer()
+        self._initialize_regularizer()
+        self._create_set_layers(
+            activation=self.activation,
+            kernel_initializer=self.kernel_initializer,
+            kernel_regularizer=self.kernel_regularizer_,
+        )
+
     def fit(
         self,
         X,
@@ -494,10 +503,7 @@ def fit(
             **kwargs :
                 Keyword arguments for the fit function
         """
-        self.random_state_ = check_random_state(self.random_state)
         _n_instances, self.n_objects_fit_, self.n_object_features_fit_ = X.shape
-        self._initialize_optimizer()
-        self._initialize_regularizer()
         self._fit(
             X=X,
             Y=Y,
@@ -596,9 +602,9 @@ def _get_context_representation(self, X, kwargs):
             shape=(n_objects, self.n_object_features_fit_), name="input_node"
         )
         if self.n_hidden_set_layers >= 1:
-            self.set_layer(input_layer_scorer)
-            fr = self.set_layer.cached_models[n_objects].predict(X, **kwargs)
-            del self.set_layer.cached_models[n_objects]
+            self.set_layer_(input_layer_scorer)
+            fr = self.set_layer_.cached_models[n_objects].predict(X, **kwargs)
+            del self.set_layer_.cached_models[n_objects]
             X_n = np.empty(
                 (fr.shape[0], n_objects, fr.shape[1] + self.n_object_features_fit_),
                 dtype="float",

csrank/core/feta_linear.py

@@ -136,6 +136,10 @@ def step_decay(self, epoch):
             self.loss
         )
 
+    def _pre_fit(self):
+        super()._pre_fit()
+        self.random_state_ = check_random_state(self.random_state)
+
     def fit(
         self, X, Y, epochs=10, callbacks=None, validation_split=0.1, verbose=0, **kwd
     ):
@@ -155,7 +159,7 @@ def fit(
             predict the target variables and adjust its parameters by gradient
             descent `epochs` times.
         """
-        self.random_state_ = check_random_state(self.random_state)
+        self._pre_fit()
         # Global Variables Initializer
         n_instances, self.n_objects_fit_, self.n_object_features_fit_ = X.shape
         self._construct_model_(self.n_objects_fit_)

csrank/core/feta_network.py

@@ -264,6 +264,12 @@ def create_input_lambda(i):
         )
         return model
 
+    def _pre_fit(self):
+        super()._pre_fit()
+        self._initialize_optimizer()
+        self._initialize_regularizer()
+        self.random_state_ = check_random_state(self.random_state)
+
     def fit(
         self, X, Y, epochs=10, callbacks=None, validation_split=0.1, verbose=0, **kwd
     ):
@@ -290,13 +296,11 @@ def fit(
             **kwd :
                 Keyword arguments for the fit function
         """
+        self._pre_fit()
         _n_instances, self.n_objects_fit_, self.n_object_features_fit_ = X.shape
-        self._initialize_optimizer()
-        self._initialize_regularizer()
         self._construct_layers()
 
         logger.debug("Enter fit function...")
-        self.random_state_ = check_random_state(self.random_state)
 
         X, Y = self.sub_sampling(X, Y)
         self.model_ = self.construct_model()

csrank/core/pairwise_svm.py

@@ -54,6 +54,10 @@ def __init__(
         self.random_state = random_state
         self.fit_intercept = fit_intercept
 
+    def _pre_fit(self):
+        super()._pre_fit()
+        self.random_state_ = check_random_state(self.random_state)
+
     def fit(self, X, Y, **kwargs):
         """
             Fit a generic preference learning model on a provided set of queries.
@@ -69,7 +73,7 @@ def fit(self, X, Y, **kwargs):
                 Keyword arguments for the fit function
 
         """
-        self.random_state_ = check_random_state(self.random_state)
+        self._pre_fit()
         _n_instances, self.n_objects_fit_, self.n_object_features_fit_ = X.shape
         x_train, y_single = self._convert_instances_(X, Y)
         if self.use_logistic_regression:

csrank/core/ranknet_core.py

@@ -107,6 +107,12 @@ def construct_model(self):
     def _convert_instances_(self, X, Y):
         raise NotImplementedError
 
+    def _pre_fit(self):
+        super()._pre_fit()
+        self.random_state_ = check_random_state(self.random_state)
+        self._initialize_optimizer()
+        self._initialize_regularizer()
+
     def fit(
         self, X, Y, epochs=10, callbacks=None, validation_split=0.1, verbose=0, **kwd
     ):
@@ -139,15 +145,13 @@ def fit(
             **kwd :
                 Keyword arguments for the fit function
         """
-        self.random_state_ = check_random_state(self.random_state)
+        self._pre_fit()
         _n_instances, self.n_objects_fit_, self.n_object_features_fit_ = X.shape
         X1, X2, Y_single = self._convert_instances_(X, Y)
 
         logger.debug("Instances created {}".format(X1.shape[0]))
         logger.debug("Creating the model")
 
-        self._initialize_optimizer()
-        self._initialize_regularizer()
         self._construct_layers()
 
         # Model with input as two objects and output as probability of x1>x2

csrank/discretechoice/baseline.py

@@ -18,9 +18,13 @@ def __init__(self, random_state=None, **kwargs):
 
         self.random_state = random_state
 
-    def fit(self, X, Y, **kwd):
+    def _pre_fit(self):
+        super()._pre_fit()
         self.random_state_ = check_random_state(self.random_state)
 
+    def fit(self, X, Y, **kwd):
+        self._pre_fit()
+
     def _predict_scores_fixed(self, X, **kwargs):
         n_instances, n_objects, n_features = X.shape
         return self.random_state_.rand(n_instances, n_objects)

csrank/discretechoice/generalized_nested_logit.py

@@ -328,6 +328,7 @@ def fit(
             **kwargs :
                 Keyword arguments for the fit function of :meth:`pymc3.fit`or :meth:`pymc3.sample`
         """
+        self._pre_fit()
         _n_instances, self.n_objects_fit_, self.n_object_features_fit_ = X.shape
         if self.n_nests is None:
             # TODO this looks like a bug to me, but it was already done this way

csrank/discretechoice/mixed_logit_model.py

@@ -214,6 +214,7 @@ def fit(
             **kwargs :
                 Keyword arguments for the fit function of :meth:`pymc3.fit`or :meth:`pymc3.sample`
         """
+        self._pre_fit()
         _n_instances, self.n_objects_fit_, self.n_object_features_fit_ = X.shape
         self.construct_model(X, Y)
         fit_pymc3_model(self, sampler, draws, tune, vi_params, **kwargs)

csrank/discretechoice/model_selector.py

@@ -58,6 +58,7 @@ def __init__(
         self.models = dict()
 
     def fit(self, X, Y):
+        self._pre_fit()
         model_args = dict()
         for param_key in self.parameter_keys:
             model_args[param_key] = self.uniform_prior

csrank/discretechoice/multinomial_logit_model.py

@@ -213,6 +213,7 @@ def fit(
             **kwargs :
                 Keyword arguments for the fit function of :meth:`pymc3.fit`or :meth:`pymc3.sample`
         """
+        self._pre_fit()
         _n_instances, self.n_objects_fit_, self.n_object_features_fit_ = X.shape
         self.construct_model(X, Y)
         fit_pymc3_model(self, sampler, draws, tune, vi_params, **kwargs)

csrank/discretechoice/nested_logit_model.py

@@ -385,6 +385,7 @@ def fit(
             **kwargs :
                 Keyword arguments for the fit function of :meth:`pymc3.fit`or :meth:`pymc3.sample`
         """
+        self._pre_fit()
         _n_instances, self.n_objects_fit_, self.n_object_features_fit_ = X.shape
         if self.n_nests is None:
             self.n_nests = int(self.n_objects_fit_ / 2)