Example #1
0
 def test_mapping_to_cube_and_bound(self):
     """ Test map_to_cube and map_to_bounds. """
     self.report('map_to_cube and map_to_bounds')
     bounds = np.array([[1, 3], [2, 4], [5, 6]])
     x = np.array([1.7, 3.1, 5.5])
     X = np.array([[1.7, 3.1, 5.5], [2.1, 2.9, 5.0]])
     y = np.array([0.35, 0.55, 0.5])
     Y = np.array([[0.35, 0.55, 0.5], [0.55, 0.45, 0]])
     # Map to cube
     y_ = general_utils.map_to_cube(x, bounds)
     Y_ = general_utils.map_to_cube(X, bounds)
     # Map to Bounds
     x_ = general_utils.map_to_bounds(y, bounds)
     X_ = general_utils.map_to_bounds(Y, bounds)
     # Check if correct.
     assert np.linalg.norm(y - y_) < 1e-5
     assert np.linalg.norm(Y - Y_) < 1e-5
     assert np.linalg.norm(x - x_) < 1e-5
     assert np.linalg.norm(X - X_) < 1e-5
def _get_mf_cost_function(fidel_bounds, is_0_1):
  """ Returns the cost function. fidel_bounds are the bounds for the fidelity space
      and is_0_1 should be true if fidel_bounds is [0,1]^p. """
  fidel_dim = len(fidel_bounds)
  if fidel_dim == 1:
    fidel_powers = [2]
  elif fidel_dim == 2:
    fidel_powers = [3, 2]
  elif fidel_dim == 3:
    fidel_powers = [3, 2, 1.5]
  else:
    fidel_powers = [3] + list(np.linspace(2, 1.2, fidel_dim-1))
  # Define the normalised
  def _norm_cost_function(norm_z):
    """ The cost function with normalised coordinates. """
    min_cost = 0.05
    return min_cost + (1-min_cost) * np.power(norm_z, fidel_powers).sum()
  # Now return based on whether or not is_0_1
  ret = (_norm_cost_function if is_0_1 else
           lambda z: _norm_cost_function(map_to_cube(z, fidel_bounds)))
  return ret
Example #3
0
 def get_normalised_coords(self, Z, X):
     """ Maps points in the original space to the cube. """
     ret_Z = None if Z is None else map_to_cube(Z, self.fidel_bounds)
     ret_X = None if X is None else map_to_cube(X, self.domain_bounds)
     return ret_Z, ret_X
Example #4
0
 def _norm_cost_function(z):
     """ Normalised cost function. """
     return 0.1 + 0.9 * (_unnorm_cost_function(
         map_to_cube(np.array(z), fidel_bounds)) / max_unnorm_cost)
Example #5
0
 def get_normalised_domain_coords(self, X):
     """ Maps points in the original domain to the cube. """
     if self.domain_is_normalised:
         return map_to_cube(X, self.raw_domain.bounds)
     else:
         return X
Example #6
0
 def get_normalised_fidel_coords(self, Z):
     """ Maps points in the original fidelity space to the cube. """
     if self.domain_is_normalised:
         return map_to_cube(Z, self.raw_fidel_space.bounds)
     else:
         return Z
Example #7
0
 def get_normalised_coords(self, X):
   """ Maps points in the original space to the unit cube. """
   return map_to_cube(X, self.true_dom_bounds)