switched to 3.10

Author: KrissiHub

CHANGELOG.md

@@ -1,3 +1,12 @@
+# Version 1.4.2
+
+## Python 3.10
+- Upgraded python version to 3.10
+- Switched pyrfr with RandomForestRegressor from sklearn
+- Switched pyrfr with Optuna
+- Removed pyrfr all together
+- Optuna is now installed by default
+
 # Version 1.4.1
 
 ## Raytune

Makefile

@@ -55,9 +55,6 @@ install-dev:
 install-examples:
 	$(PIP) install -e ".[examples]"
 
-install-optuna:
-	$(PIP) install -e ".[optuna]"
-
 install-bohb:
 	$(PIP) install -e ".[bohb]"
 

README.md

@@ -25,10 +25,9 @@ conda install -c anaconda swig
 pip install DeepCAVE
 ```
 
-To load runs created with Optuna, the BOHB optimizer or RayTune, you need to install the
+To load runs created with the BOHB optimizer or RayTune, you need to install the
 respective packages by running:
 ```bash
-pip install deepcave[optuna]
 pip install deepcave[bohb]
 pip install deepcave[raytune]
 ```

deepcave/evaluators/ablation.py

@@ -33,8 +33,6 @@
 from collections import OrderedDict
 
 import numpy as np
-
-# from deepcave.evaluators.epm.random_forest_surrogate import RandomForestSurrogate
 from sklearn.ensemble import RandomForestRegressor
 
 from deepcave.runs import AbstractRun

deepcave/evaluators/epm/__init__.py

@@ -18,8 +18,6 @@
 
 ## Modules
 ----------
-fanova_forest
-    The module provides utilities for creating a fANOVA forest.
 random_forest
     This module can be used for training and using a Random Forest Regression model.
 random_forest_surrogate

deepcave/evaluators/epm/random_forest.py

@@ -18,14 +18,11 @@
 
 This module can be used for training and using a Random Forest Regression model.
 
-A pyrfr wrapper is used for simplification.
-
 ## Classes
-    - RandomForest: A random forest wrapper for pyrfr.
+    - RandomForest: For training and using a Random Forest Regression model.
 
 ## Constants
     VERY_SMALL_NUMBER : float
-    PYRFR_MAPPING : Dict[str, str]
 """
 
 from typing import Any, Dict, Optional, Tuple, Union
@@ -36,13 +33,10 @@
 from ConfigSpace import ConfigurationSpace
 from ConfigSpace.hyperparameters import (
     CategoricalHyperparameter,
-    Constant,
     UniformFloatHyperparameter,
     UniformIntegerHyperparameter,
 )
 from sklearn.decomposition import PCA
-
-# import pyrfr.regression as regression
 from sklearn.ensemble import RandomForestRegressor
 from sklearn.exceptions import NotFittedError
 from sklearn.preprocessing import MinMaxScaler
@@ -62,14 +56,7 @@
 
 class RandomForest:
     """
-    A random forest wrapper for pyrfr.
-
-    This is handy because only the configuration space needs to be passed.
-    and have a working version without specifying e.g. types and bounds.
-
-    Note
-    ----
-    This wrapper also supports instances.
+    For training and using a Random Forest Regression model.
 
     Properties
     ----------
@@ -219,8 +206,7 @@ def _impute_inactive(self, X: np.ndarray) -> np.ndarray:
                         impute_values[idx] = len(hp.choices)
                     elif isinstance(hp, (UniformFloatHyperparameter, UniformIntegerHyperparameter)):
                         impute_values[idx] = -1
-                    elif isinstance(hp, Constant):
-                        impute_values[idx] = 1
+
                     else:
                         raise ValueError
 
@@ -432,7 +418,7 @@ def predict_marginalized(self, X: np.ndarray) -> Tuple[np.ndarray, np.ndarray]:
         # Mean per tree across instances
         dat_ = np.array([tree.predict(X) for tree in self._model.estimators_])  # shape: (n_trees,)
 
-        # 3. compute statistics across trees
+        # compute statistics across trees
         mean_ = dat_.mean(axis=1)
         var = dat_.var(axis=1)
 

deepcave/evaluators/epm/random_forest_surrogate.py

@@ -63,8 +63,6 @@ def predict(self, X: np.ndarray) -> Tuple[np.ndarray, np.ndarray]:
         Tuple[np.ndarray, np.ndarray]
             The means and standard deviation.
         """
-        # means, stds = self._model.predict(X)
-        # return means[:, 0], stds[:, 0]
         means, vars_ = self._model.predict(X)
         # Convert variance to standard deviation
         stds = np.sqrt(vars_)

deepcave/evaluators/fanova.py

@@ -39,8 +39,6 @@ class fANOVA:
     """
     Calculate and provide midpoints and sizes.
 
-    They are generated from the forest's split values in order to get the marginals.
-
     Properties
     ----------
     run : AbstractRun
@@ -71,6 +69,7 @@ def calculate(
         budget: Optional[Union[int, float]] = None,
         n_trees: int = 16,
         seed: int = 0,
+        y: Any = None,
     ) -> Any:
         """Create Optuna study from data and fit Fanova evaluator."""
         if objectives is None:
@@ -83,21 +82,16 @@ def calculate(
         df = self.run.get_encoded_data(
             objectives, budget, specific=True, include_combined_cost=True
         )
-
         X = df[self.hp_names].to_numpy()
 
         # Combined cost name includes the cost of all selected objectives
-        Y = df[COMBINED_COST_NAME].to_numpy()
+        if y is not None:
+            Y = y
+        else:
+            Y = df[COMBINED_COST_NAME].to_numpy()
 
-        direction = ""
+        self.study = optuna.create_study()
 
-        if isinstance(objectives, Objective):
-            if objectives.optimize == "upper":
-                direction = "maximize"
-            else:
-                direction = "minimize"
-
-        self.study = optuna.create_study(direction=direction)
         params: dict = {}
         distributions: dict = {}
 
@@ -112,6 +106,7 @@ def calculate(
                 if hp.__class__.__name__ == "CategoricalHyperparameter":
                     # For categorical, val is assumed to be an index
                     idx = int(val)
+
                     params[name] = hp.choices[idx]  # type: ignore
                     distributions[name] = optuna.distributions.CategoricalDistribution(
                         hp.choices  # type: ignore

deepcave/evaluators/lpi.py

@@ -34,8 +34,6 @@
 )
 from ConfigSpace.types import Array, f64
 from ConfigSpace.util import impute_inactive_values
-
-# from deepcave.evaluators.epm.fanova_forest import FanovaForest
 from sklearn.ensemble import RandomForestRegressor
 
 from deepcave.constants import COMBINED_COST_NAME
@@ -130,7 +128,6 @@ def calculate(
         Y = df[COMBINED_COST_NAME].to_numpy()
 
         # Get model and train it
-        # Use same forest as for fanova
         self._model = RandomForestRegressor(n_estimators=n_trees, random_state=seed)
         self._model.fit(X, Y)
 
@@ -180,7 +177,6 @@ def calculate(
                 )
                 new_config = impute_inactive_values(Configuration(self.cs, vector=new_array))
 
-                # x = np.array(new_config.get_array())
                 mean, var = self._predict_mean_var(new_config)
                 performances[hp_name].append(mean)
                 variances[hp_name].append(var)

deepcave/evaluators/mo_fanova.py

@@ -14,17 +14,17 @@
 
 #  noqa: D400
 """
-# fANOVA
+# MOfANOVA
 
 This module provides a tool for assessing the importance of an algorithms Hyperparameters.
 
 Utilities provide calculation of the data wrt the budget and train the forest on the encoded data.
 
 ## Classes
-    - fANOVA: Calculate and provide midpoints and sizes.
+    - MOfANOVA: Calculate and provide midpoints and sizes.
 """
 
-from typing import List, Optional, Union
+from typing import Any, List, Optional, Union
 
 import pandas as pd
 
@@ -38,8 +38,6 @@ class MOfANOVA(fANOVA):
     """
     Multi-Objective fANOVA.
 
-    Calculate and provide midpoints and sizes from the forest's split values in order to get
-    the marginals.
     Override: to train the random forest with an arbitrary weighting of the objectives
     (multi-objective case).
     """
@@ -58,6 +56,7 @@ def calculate(
         budget: Optional[Union[int, float]] = None,
         n_trees: int = 100,
         seed: int = 0,
+        y: Any = None,
     ) -> None:
         """
         Get the data with respect to budget and train the forest on the encoded data.
@@ -103,19 +102,24 @@ def calculate(
                 df[normed] = 1 - df[normed]
             objectives_normed.append(normed)
         df = df.dropna(subset=objectives_normed)
-        # X = df[self.hp_names].to_numpy()
+
         weightings = get_weightings(objectives_normed, df)
+
         df_all = pd.DataFrame([])
 
         # calculate importance for each weighting generated from the pareto efficient points
         for w in weightings:
-            # Y = sum(df[obj] *weighting for obj, weighting in zip(objectives_normed, w)).to_numpy()
+            Y = sum(df[obj] * weighting for obj, weighting in zip(objectives_normed, w)).to_numpy()
+
+            super().calculate(
+                objectives=objectives, budget=budget, seed=seed, n_trees=self.n_trees, y=Y
+            )
+            self.importances = super().get_importances()
 
-            self.importances = super().calculate(objectives, budget, seed)
-            print(self.importances)
             df_res = pd.DataFrame.from_dict(self.importances).loc[0:1].T.reset_index()
             df_res["weight"] = w[0]
             df_all = pd.concat([df_all, df_res])
+
         self.importances_ = df_all.rename(
             columns={0: "importance", 1: "variance", "index": "hp_name"}
         ).reset_index(drop=True)