text: from typing import Tuple, Optional, List
  
  import numpy as np
  
  from smac.configspace import ConfigurationSpace
  from smac.epm.base_epm import AbstractEPM
  
  __author__ = "Katharina Eggensperger"
  __copyright__ = "Copyright 2015, ML4AAD"
  __license__ = "3-clause BSD"
  __maintainer__ = "Katharina Eggensperger"
  __email__ = "eggenspk@cs.uni-freiburg.de"
  __version__ = "0.0.1"
  
  
  class RandomEPM(AbstractEPM):
      """EPM which returns random values on a call to ``fit``."""
  
      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:
          """Constructor
  
          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).
          """
  
          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) -> 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)]
  
          Returns
          -------
          means : np.ndarray of shape = [n_samples, n_objectives]
              Predictive mean
          vars : np.ndarray  of shape = [n_samples, n_objectives]
              Predictive variance
          """
          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)
  