def test_set_get_transformer(): # can you pass a Space instance to the Space constructor? space = Space([(0.0, 1.0), (-5, 5), ("a", "b", "c"), (1.0, 5.0, "log-uniform"), ("e", "f")]) transformer = space.get_transformer() assert_array_equal(["identity", "identity", "onehot", "identity", "onehot"], transformer) space.set_transformer("normalize") transformer = space.get_transformer() assert_array_equal(["normalize"] * 5, transformer) space.set_transformer(transformer) assert_array_equal(transformer, space.get_transformer()) space.set_transformer_by_type("label", Categorical) assert space.dimensions[2].transform(["a"]) == [0]
def generate(self, dimensions, n_samples, random_state=None): """Creates latin hypercube samples with maxpro criterion. Parameters ---------- dimensions : list, shape (n_dims,) List of search space dimensions. Each search dimension can be defined either as - a `(lower_bound, upper_bound)` tuple (for `Real` or `Integer` dimensions), - a `(lower_bound, upper_bound, "prior")` tuple (for `Real` dimensions), - as a list of categories (for `Categorical` dimensions), or - an instance of a `Dimension` object (`Real`, `Integer` or `Categorical`). n_samples : int The order of the LHS sequence. Defines the number of samples. random_state : int, RandomState instance, or None (default) Set random state to something other than None for reproducible results. Returns ------- np.array, shape=(n_dim, n_samples) LHS set """ rng = check_random_state(random_state) space = Space(dimensions) transformer = space.get_transformer() n_dim = space.n_dims space.set_transformer("normalize") h = self._lhs_normalized(n_dim, n_samples, rng) self.num_pts = n_samples self.dim = n_dim if self.use_gradient: print('Using gradient descent') bounds = [(0, 1)] * len(dimensions) * self.num_pts h_opt = minimize(self.maxpro_criter, h, jac=self.maxpro_grad, bounds=bounds) h_opt = h_opt['x'].reshape(n_samples, n_dim) else: print('Using naive method') best = 1e+6 for i in range(self.iterations): h = self._lhs_normalized(n_dim, n_samples, i * rng) criter = self.maxpro_criter(h) if best > criter: best = criter h_opt = h.copy() h_opt = space.inverse_transform(h_opt) space.set_transformer(transformer) return h_opt