from typing import List, Optional, Tuple
import numpy as np
from smac.configspace import ConfigurationSpace
from smac.epm.base_epm import BaseEPM
__author__ = "Katharina Eggensperger"
__copyright__ = "Copyright 2015, ML4AAD"
__license__ = "3-clause BSD"
__maintainer__ = "Katharina Eggensperger"
__email__ = "eggenspk@cs.uni-freiburg.de"
__version__ = "0.0.1"
[docs]class RandomEPM(BaseEPM):
"""EPM which returns random values on a call to ``fit``.
Parameters
----------
configspace : ConfigurationSpace
Configuration space to tune for.
types : List[int]
Specifies the number of categorical values of an input dimension where
the i-th entry corresponds to the i-th input dimension. Let's say we
have 2 dimension where the first dimension consists of 3 different
categorical choices and the second dimension is continuous than we
have to pass [3, 0]. Note that we count starting from 0.
bounds : List[Tuple[float, float]]
bounds of input dimensions: (lower, uppper) for continuous dims; (n_cat, np.nan) for categorical dims
seed : int
The seed that is passed to the model library.
instance_features : np.ndarray (I, K), optional
Contains the K dimensional instance features
of the I different instances
pca_components : float
Number of components to keep when using PCA to reduce
dimensionality of instance features. Requires to
set n_feats (> pca_dims).
"""
def __init__(
self,
configspace: ConfigurationSpace,
types: List[int],
bounds: List[Tuple[float, float]],
seed: int,
instance_features: Optional[np.ndarray] = None,
pca_components: Optional[int] = None,
) -> None:
super().__init__(
configspace=configspace,
types=types,
bounds=bounds,
seed=seed,
instance_features=instance_features,
pca_components=pca_components,
)
self.rng = np.random.RandomState(self.seed)
def _train(self, X: np.ndarray, Y: np.ndarray) -> "RandomEPM":
"""Pseudo training on X and Y.
Parameters
----------
X : np.ndarray (N, D)
Input data points. The dimensionality of X is (N, D),
with N as the number of points and D is the number of features.
Y : np.ndarray (N, 1)
The corresponding target values.
"""
if not isinstance(X, np.ndarray):
raise NotImplementedError("X has to be of type np.ndarray")
if not isinstance(Y, np.ndarray):
raise NotImplementedError("Y has to be of type np.ndarray")
self.logger.debug("(Pseudo) Fit model to data")
return self
def _predict(self, X: np.ndarray, cov_return_type: Optional[str] = "diagonal_cov") -> Tuple[np.ndarray, np.ndarray]:
"""Predict means and variances for given X.
Parameters
----------
X : np.ndarray of shape = [n_samples, n_features (config + instance features)]
cov_return_type: Optional[str]
Specifies what to return along with the mean. Refer ``predict()`` for more information.
Returns
-------
means : np.ndarray of shape = [n_samples, n_objectives]
Predictive mean
vars : np.ndarray of shape = [n_samples, n_objectives]
Predictive variance
"""
if cov_return_type != "diagonal_cov":
raise ValueError("'cov_return_type' can only take 'diagonal_cov' for this model")
if not isinstance(X, np.ndarray):
raise NotImplementedError("X has to be of type np.ndarray")
return self.rng.rand(len(X), 1), self.rng.rand(len(X), 1)