Misc estimator fixes

csrank/choicefunction/baseline.py

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

csrank/choicefunction/cmpnet_choice.py

@@ -179,3 +179,4 @@ def fit(
         else:
             super().fit(X, Y, epochs, callbacks, validation_split, verbose, **kwd)
             self.threshold_ = 0.5
+        return self

csrank/choicefunction/fate_choice.py

@@ -180,3 +180,4 @@ def fit(
         else:
             super().fit(X, Y, **kwargs)
             self.threshold_ = 0.5
+        return self

csrank/choicefunction/fatelinear_choice.py

@@ -98,3 +98,4 @@ def fit(
         else:
             super().fit(X, Y, epochs, callbacks, validation_split, verbose, **kwd)
             self.threshold_ = 0.5
+        return self

csrank/choicefunction/feta_choice.py

@@ -311,6 +311,7 @@ def fit(
         else:
             super().fit(X, Y, epochs, callbacks, validation_split, verbose, **kwd)
             self.threshold_ = 0.5
+        return self
 
     def sub_sampling(self, X, Y):
         if self.n_objects_fit_ <= self.max_number_of_objects:

csrank/choicefunction/fetalinear_choice.py

@@ -96,3 +96,4 @@ def fit(
         else:
             super().fit(X, Y, epochs, callbacks, validation_split, verbose, **kwd)
             self.threshold_ = 0.5
+        return self

csrank/choicefunction/generalized_linear_model.py

@@ -256,6 +256,7 @@ def fit(
                 **kwargs,
             )
             self.threshold_ = 0.5
+        return self
 
     def _fit(
         self,

csrank/choicefunction/pairwise_choice.py

@@ -114,3 +114,4 @@ def fit(self, X, Y, tune_size=0.1, thin_thresholds=1, verbose=0, **kwd):
         else:
             super().fit(X, Y, **kwd)
             self.threshold_ = 0.5
+        return self

csrank/choicefunction/ranknet_choice.py

@@ -166,3 +166,4 @@ def fit(
         else:
             super().fit(X, Y, epochs, callbacks, validation_split, verbose, **kwd)
             self.threshold_ = 0.5
+        return self

csrank/core/cmpnet_core.py

@@ -157,12 +157,15 @@ def fit(
         """
         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)
 
-        logger.debug("Instances created {}".format(x1.shape[0]))
         self._construct_layers()
         self.model_ = self.construct_model()
 
+        if self.n_objects_fit_ < 2:
+            # Nothing to learn here, no pairwise comparisons can be generated.
+            return self
+        x1, x2, y_double = self._convert_instances_(X, Y)
+        logger.debug("Instances created {}".format(x1.shape[0]))
         logger.debug("Finished Creating the model, now fitting started")
         self.model_.fit(
             [x1, x2],
@@ -175,6 +178,7 @@ def fit(
             **kwd,
         )
         logger.debug("Fitting Complete")
+        return self
 
     def predict_pair(self, a, b, **kwargs):
         return self.model_.predict([a, b], **kwargs)

csrank/core/fate_linear.py

@@ -112,6 +112,7 @@ def fit(
             self.bias1_ = tf_session.run(self.b1)
             self.weight2_ = tf_session.run(self.W2)
             self.bias2_ = tf_session.run(self.b2)
+        return self
 
     def _fit_(self, X, Y, epochs, n_instances, tf_session, verbose):
         try:

csrank/core/fate_network.py

@@ -140,7 +140,9 @@ def join_input_layers(self, input_layer, *layers, n_layers, n_objects):
             for j in range(self.n_hidden_joint_layers):
                 joint = self.joint_layers[j](joint)
             scores.append(self.scorer(joint))
-        scores = concatenate(scores, name="final_scores")
+        scores = (
+            concatenate(scores, name="final_scores") if len(scores) > 1 else scores[0]
+        )
         logger.debug("Done")
 
         return scores
@@ -518,6 +520,7 @@ def fit(
             refit=refit,
             **kwargs,
         )
+        return self
 
     def fit_generator(
         self,

csrank/core/feta_linear.py

@@ -162,6 +162,10 @@ def fit(
         self._pre_fit()
         # Global Variables Initializer
         n_instances, self.n_objects_fit_, self.n_object_features_fit_ = X.shape
+        if self.n_objects_fit_ < 2:
+            # Nothing to learn here, model cannot be constructed without any
+            # instance pairs.
+            return self
         self._construct_model_(self.n_objects_fit_)
         init = tf.global_variables_initializer()
 
@@ -179,6 +183,7 @@ def fit(
             self.weight2_ = tf_session.run(self.W2)
             self.bias2_ = tf_session.run(self.b2)
             self.W_last_ = tf_session.run(self.W_out_)
+        return self
 
     def _fit_(self, X, Y, epochs, n_instances, tf_session, verbose):
         try:

csrank/core/feta_network.py

@@ -303,6 +303,9 @@ def fit(
         logger.debug("Enter fit function...")
 
         X, Y = self.sub_sampling(X, Y)
+        if self.n_objects_fit_ < 2:
+            # Nothing to learn, can't construct a model.
+            return self
         self.model_ = self.construct_model()
         logger.debug("Starting gradient descent...")
 
@@ -316,6 +319,7 @@ def fit(
             verbose=verbose,
             **kwd,
         )
+        return self
 
     def sub_sampling(self, X, Y):
         if self.n_objects_fit_ > self.max_number_of_objects:

csrank/core/pairwise_svm.py

@@ -75,7 +75,6 @@ def fit(self, X, Y, **kwargs):
         """
         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:
             self.model_ = LogisticRegression(
                 C=self.C,
@@ -93,6 +92,10 @@ def fit(self, X, Y, **kwargs):
             )
             logger.info("Linear SVC model ")
 
+        if self.n_objects_fit_ < 2:
+            # Nothing to learn, cannot create pairwise instances.
+            return self
+        x_train, y_single = self._convert_instances_(X, Y)
         if self.normalize:
             std_scalar = StandardScaler()
             x_train = std_scalar.fit_transform(x_train)
@@ -103,6 +106,7 @@ def fit(self, X, Y, **kwargs):
         if self.fit_intercept:
             self.weights_ = np.append(self.weights_, self.model_.intercept_)
         logger.debug("Fitting Complete")
+        return self
 
     def _predict_scores_fixed(self, X, **kwargs):
         assert X.shape[-1] == self.n_object_features_fit_

csrank/core/ranknet_core.py

@@ -147,15 +147,19 @@ def fit(
         """
         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._construct_layers()
 
         # Model with input as two objects and output as probability of x1>x2
         self.model_ = self.construct_model()
+
+        if self.n_objects_fit_ < 2:
+            # Nothing to learn, cannot create pairwise comparisons.
+            return self
+        X1, X2, Y_single = self._convert_instances_(X, Y)
+
+        logger.debug("Instances created {}".format(X1.shape[0]))
         logger.debug("Finished Creating the model, now fitting started")
 
         self.model_.fit(
@@ -170,6 +174,7 @@ def fit(
         )
 
         logger.debug("Fitting Complete")
+        return self
 
     @property
     def scoring_model(self):

csrank/dataset_reader/objectranking/util.py

@@ -109,7 +109,9 @@ def complete_linear_regression_dataset(X, rankings):
     Y_single = []
     for features, rank in zip(X, rankings):
         X1.extend(features)
-        norm_ranks = rank / np.max(rank, axis=0)
+        min_rank = np.min(rank, axis=0)
+        max_rank = np.max(rank, axis=0)
+        norm_ranks = (rank - min_rank + 1) / (max_rank - min_rank + 1)
         Y_single.extend(norm_ranks)
     X1 = np.array(X1)
     Y_single = np.array(Y_single)

csrank/discretechoice/baseline.py

@@ -24,6 +24,7 @@ def _pre_fit(self):
 
     def fit(self, X, Y, **kwd):
         self._pre_fit()
+        return self
 
     def _predict_scores_fixed(self, X, **kwargs):
         n_instances, n_objects, n_features = X.shape

csrank/discretechoice/generalized_nested_logit.py

@@ -337,6 +337,7 @@ def fit(
             self.n_nests = self.n_objects_fit_ + int(self.n_objects_fit_ / 2)
         self.construct_model(X, Y)
         fit_pymc3_model(self, sampler, draws, tune, vi_params, **kwargs)
+        return self
 
     def _predict_scores_fixed(self, X, **kwargs):
         mean_trace = dict(pm.summary(self.trace_)["mean"])

csrank/discretechoice/mixed_logit_model.py

@@ -218,6 +218,7 @@ def 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)
+        return self
 
     def _predict_scores_fixed(self, X, **kwargs):
         summary = dict(pm.summary(self.trace_)["mean"])

csrank/discretechoice/model_selector.py

@@ -105,6 +105,7 @@ def fit(self, X, Y):
                         self.parameter_ind[j][1],
                     )
                     self.fit_learner(X, Y, key)
+        return self
 
     def fit_learner(self, X, Y, key):
         learner = self.learner_cls(**self.model_params)

csrank/discretechoice/multinomial_logit_model.py

@@ -217,6 +217,7 @@ def 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)
+        return self
 
     def _predict_scores_fixed(self, X, **kwargs):
         d = dict(pm.summary(self.trace_)["mean"])

csrank/discretechoice/nested_logit_model.py

@@ -392,6 +392,7 @@ def fit(
         self.random_state_ = check_random_state(self.random_state)
         self.construct_model(X, Y)
         fit_pymc3_model(self, sampler, draws, tune, vi_params, **kwargs)
+        return self
 
     def _predict_scores_fixed(self, X, **kwargs):
         y_nests = self.create_nests(X)

csrank/discretechoice/paired_combinatorial_logit.py

@@ -332,6 +332,7 @@ def fit(
         self.n_nests = len(self.nests_indices)
         self.construct_model(X, Y)
         fit_pymc3_model(self, sampler, draws, tune, vi_params, **kwargs)
+        return self
 
     def _predict_scores_fixed(self, X, **kwargs):
         mean_trace = dict(pm.summary(self.trace_)["mean"])

csrank/discretechoice/pairwise_discrete_choice.py

@@ -76,4 +76,4 @@ def _convert_instances_(self, X, Y):
     def fit(self, X, Y, **kwd):
         self._pre_fit()
         _n_instances, self.n_objects_fit_, self.n_object_features_fit_ = X.shape
-        super().fit(X, Y, **kwd)
+        return super().fit(X, Y, **kwd)

csrank/dyadranking/fate_dyad_ranker.py

@@ -6,6 +6,7 @@
 class FATEDyadRanker(FATENetwork, DyadRanker):
     def fit(self, Xo, Xc, Y, **kwargs):
         self._pre_fit()
+        return self
 
     def predict_scores(self, Xo, Xc, **kwargs):
         return self.model_.predict([Xo, Xc], **kwargs)

csrank/layers.py

@@ -134,7 +134,8 @@ def _create_model(self, shape):
             set_mappings.append((i, curr))
 
         # TODO: is feature_repr used outside?
-        feature_repr = average([x for (j, x) in set_mappings])
+        x_values = [x for (j, x) in set_mappings]
+        feature_repr = average(x_values) if len(x_values) > 1 else x_values[0]
 
         self.cached_models[n_objects] = Model(inputs=input_layer, outputs=feature_repr)
 

csrank/objectranking/baseline.py

@@ -16,14 +16,15 @@ def __init__(self, random_state=None, **kwargs):
             :param kwargs: Keyword arguments for the algorithms
         """
 
-        self.random_state = (random_state,)
+        self.random_state = random_state
 
     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()
+        return self
 
     def _predict_scores_fixed(self, X, **kwargs):
         n_instances, n_objects, n_features = X.shape

csrank/objectranking/expected_rank_regression.py

@@ -127,6 +127,7 @@ def fit(self, X, Y, **kwargs):
         if self.fit_intercept:
             self.weights_ = np.append(self.weights_, self.model_.intercept_)
         logger.debug("Fitting Complete")
+        return self
 
     def _predict_scores_fixed(self, X, **kwargs):
         n_instances, n_objects, n_features = X.shape

csrank/objectranking/list_net.py

@@ -199,6 +199,7 @@ def fit(
             **kwd,
         )
         logger.debug("Fitting Complete")
+        return self
 
     def construct_model(self):
         """
@@ -215,7 +216,7 @@ def construct_model(self):
         for hidden_layer in self.hidden_layers:
             hid = [hidden_layer(x) for x in hid]
         outputs = [self.output_node(x) for x in hid]
-        merged = concatenate(outputs)
+        merged = concatenate(outputs) if len(outputs) > 1 else outputs[0]
         model = Model(inputs=self.input_layer, outputs=merged)
         model.compile(
             loss=self.loss_function,

csrank/objectranking/rank_svm.py

@@ -60,7 +60,7 @@ def __init__(
     def fit(self, X, Y, **kwargs):
         self._pre_fit()
         _n_instances, self.n_objects_fit_, self.n_object_features_fit_ = X.shape
-        super().fit(X, Y, **kwargs)
+        return super().fit(X, Y, **kwargs)
 
     def _convert_instances_(self, X, Y):
         logger.debug("Creating the Dataset")

csrank/tests/test_fate.py

@@ -27,7 +27,7 @@ def predict(self, *args, **kwargs):
             pass
 
         def fit(self, *args, **kwargs):
-            pass
+            return self
 
     grc = MockClass()
     grc._initialize_optimizer()