Updated explicit_evaler.py to use Datasets instead of Dataframes (now correct)

Also updated the ExplicitEvaler construction calls in the other files

Author: Max

lkauto/explicit/explicit_evaler.py

@@ -3,8 +3,8 @@
 import numpy as np
 import pandas as pd
 
-from typing import Iterator
-from lenskit.data import Dataset
+from typing import Iterator, Union
+from lenskit.data import Dataset, ItemListCollection
 from lenskit.pipeline import predict_pipeline, topn_pipeline
 from lenskit.batch import recommend
 from lenskit.metrics import RunAnalysis
@@ -56,12 +56,10 @@ class ExplicitEvaler:
     """
 
     def __init__(self,
-                 data: Dataset,
-                 train: pd.DataFrame,
+                 train: Dataset,
                  optimization_metric,
                  filer: Filer,
-                 ttsplits: Iterator[TTSplit] = None,
-                 validation=None,
+                 validation: ItemListCollection = None,
                  random_state=42,
                  split_folds: int = 1,
                  split_strategie: str = 'user_based',
@@ -70,10 +68,8 @@ def __init__(self,
                  minimize_error_metric_val: bool = True,
                  ) -> None:
         self.logger = logging.getLogger('lenskit-auto')
-        self.data = data
         self.train = train
         self.filer = filer
-        self.ttsplits = ttsplits
         self.validation = validation
         self.random_state = random_state
         self.split_folds = split_folds
@@ -84,14 +80,14 @@ def __init__(self,
         self.run_id = 0
         self.ensemble_size = ensemble_size
         self.top_n_runs = pd.DataFrame(columns=['run_id', 'model', 'error'])
-        if self.ttsplits is None:
-            self.train_test_splits = validation_split(data=self.data,
+        if self.validation is None:
+            self.train_test_splits = validation_split(data=self.train,
                                                       strategy=self.split_strategie,
                                                       num_folds=self.split_folds,
                                                       frac=self.split_frac,
                                                       random_state=self.random_state)
         else:
-            self.train_test_splits = self.ttsplits
+            self.train_test_splits = iter([TTSplit(train, validation)])
 
     def evaluate(self, config_space: ConfigurationSpace) -> float:
         """ evaluates model defined in config_space

lkauto/lkauto.py

@@ -19,12 +19,13 @@
 from lenskit.metrics.predict import RMSE
 from lenskit.metrics import NDCG
 from lenskit.pipeline import Component
+from lenskit.data import Dataset, ItemListCollection
 
 from typing import Tuple
 
 
-def get_best_prediction_model(train: pd.DataFrame,
-                              validation: pd.DataFrame = None,
+def get_best_prediction_model(train: Dataset,
+                              validation: ItemListCollection = None,
                               cs: ConfigurationSpace = None,
                               optimization_metric=RMSE,
                               optimization_strategie: str = 'bayesian',
@@ -166,7 +167,7 @@ def get_best_prediction_model(train: pd.DataFrame,
                     drop_na_values=drop_na_values,
                     drop_duplicates=drop_duplicates)
 
-    # decide which optimization strategie to use
+    # decide which optimization strategy to use
     if optimization_strategie == 'bayesian':
         incumbent, top_n_runs = bayesian_optimization(train=train,
                                                       cs=cs,

lkauto/optimization_strategies/bayesian_optimization.py

@@ -9,6 +9,8 @@
 from smac.intensifier import Intensifier
 from smac.scenario import Scenario
 
+from lenskit.data import Dataset, ItemListCollection
+
 from lkauto.explicit.explicit_evaler import ExplicitEvaler
 from lkauto.implicit.implicit_evaler import ImplicitEvaler
 from lkauto.utils.filer import Filer
@@ -19,9 +21,9 @@
 import logging
 
 
-def bayesian_optimization(train: pd.DataFrame,
+def bayesian_optimization(train: Dataset,
                           user_feedback: str,
-                          validation: pd.DataFrame = None,
+                          validation: ItemListCollection = None,
                           cs: ConfigurationSpace = None,
                           optimization_metric=None,
                           time_limit_in_sec: int = 2700,
@@ -118,7 +120,7 @@ def bayesian_optimization(train: pd.DataFrame,
     if cs is None:
         logger.debug('initializing default ConfigurationSpace')
         cs = get_default_configuration_space(data=train,
-                                             val_fold_indices=evaler.val_fold_indices,
+                                             val_fold_indices=evaler.train_test_splits,
                                              validation=validation,
                                              feedback='explicit',
                                              random_state=random_state)

lkauto/optimization_strategies/random_search.py

@@ -4,6 +4,8 @@
 
 from ConfigSpace import ConfigurationSpace, Configuration
 
+from lenskit.data import Dataset, ItemListCollection
+
 from lkauto.explicit.explicit_evaler import ExplicitEvaler
 from lkauto.implicit.implicit_evaler import ImplicitEvaler
 from lkauto.utils.get_default_configurations import get_default_configurations
@@ -15,11 +17,11 @@
 
 
 def random_search(cs: ConfigurationSpace,
-                  train: pd.DataFrame,
+                  train: Dataset,
                   user_feedback: str,
                   optimization_metric,
                   filer: Filer,
-                  validation: pd.DataFrame = None,
+                  validation: ItemListCollection = None,
                   time_limit_in_sec: int = 3600,
                   num_evaluations: int = None,
                   split_folds: int = 1,
@@ -117,7 +119,7 @@ def random_search(cs: ConfigurationSpace,
     if cs is None:
         logger.debug('initializing default ConfigurationSpace')
         cs = get_default_configuration_space(data=train,
-                                             val_fold_indices=evaler.val_fold_indices,
+                                             val_fold_indices=evaler.train_test_splits,
                                              validation=validation,
                                              feedback='explicit',
                                              random_state=random_state)

lkauto/utils/get_default_configuration_space.py

@@ -45,25 +45,6 @@ def get_default_configuration_space(data: Union[Dataset, Iterator[TTSplit]],
         raise ValueError("Unknown feedback type: {}".format(feedback))
 
     # get minimum number of items and users for the given train split
-
-    """
-    num_items = 0
-    num_users = 0
-    if validation is None:
-        val_fold_indices = val_fold_indices
-        for fold in range(len(val_fold_indices)):
-            tmp = data.loc[val_fold_indices[fold]["train"], :]
-            if tmp['item'].nunique() < num_items or num_items == 0:
-                num_items = tmp['item'].nunique()
-            if tmp['user'].nunique() < num_users or num_users == 0:
-                num_users = tmp['user'].nunique()
-    else:
-        if data['item'].nunique() < num_items or num_items == 0:
-            num_items = data['item'].nunique()
-        if data['user'].nunique() < num_users or num_users == 0:
-            num_users = data['user'].nunique()
-            """
-
     num_items = 0
     num_users = 0
 

lkauto/utils/validation_split.py

@@ -137,12 +137,6 @@ def __row_based_k_fold_validation_split(data: Dataset, num_folds: int, random_st
         Lenskit Dataset with the data to be split.
     """
 
-    # generate the indices of the train and validation split for the given data
-    for i, splits in enumerate(crossfold_records(data, partitions=num_folds, rng_spec=random_state)):
-        fold_indices[i]['train'] = np.append(fold_indices[i]["train"], splits[0].index)
-        fold_indices[i]['validation'] = np.append(fold_indices[i]["validation"], splits[1].index)
-    return fold_indices
-
     splits = crossfold_records(data=data, partitions=num_folds, rng=random_state)
     return splits