Ejemplo n.º 1
0
def minimize_ackley_continuous_noisy():
    """
    SSRacos example of minimizing ackley function under Gaussian noise

    :return: no return value
    """
    ackley_noise_func = ackley_noise_creator(0, 0.1)
    dim_size = 100  # dimensions
    dim_regs = [[-1, 1]] * dim_size  # dimension range
    dim_tys = [True] * dim_size  # dimension type : real
    dim = Dimension(dim_size, dim_regs,
                    dim_tys)  # form up the dimension object
    objective = Objective(ackley_noise_func,
                          dim)  # form up the objective function
    budget = 200000  # 20*dim_size  # number of calls to the objective function
    # suppression=True means optimize with value suppression, which is a noise handling method
    # resampling=True means optimize with re-sampling, which is another common used noise handling method
    # non_update_allowed=500 and resample_times=100 means if the best solution doesn't change for 500 budgets,
    # the best solution will be evaluated repeatedly for 100 times
    # balance_rate is a parameter for exponential weight average of several evaluations of one sample.
    parameter = Parameter(budget=budget,
                          noise_handling=True,
                          suppression=True,
                          non_update_allowed=500,
                          resample_times=100,
                          balance_rate=0.5)

    # parameter = Parameter(budget=budget, noise_handling=True, resampling=True, resample_times=10)
    parameter.set_positive_size(5)

    ExpOpt.min(objective,
               parameter,
               repeat=2,
               plot=True,
               plot_file="img/ackley_continuous_noisy_figure.png")
Ejemplo n.º 2
0
def minimize_sphere_continuous():
    """
    Example of minimizing the sphere function

    :return: no return value
    """
    dim_size = 100
    # form up the objective function
    objective = Objective(sphere, Dimension(dim_size, [[-1, 1]] * dim_size, [True] * dim_size))

    budget = 100 * dim_size
    # if intermediate_result is True, ZOOpt will output intermediate best solution every intermediate_freq budget
    parameter = Parameter(budget=budget, intermediate_result=True,
                          intermediate_freq=1000)
    ExpOpt.min(objective, parameter, repeat=1, plot=True, plot_file="img/sphere_continuous_figure.png")
Ejemplo n.º 3
0
def minimize_sphere_sre():
    """
    Example of minimizing high-dimensional sphere function with sequential random embedding.

    :return: no return value
    """

    dim_size = 10000  # dimensions
    dim_regs = [[-1, 1]] * dim_size  # dimension range
    dim_tys = [True] * dim_size  # dimension type : real
    dim = Dimension(dim_size, dim_regs,
                    dim_tys)  # form up the dimension object
    objective = Objective(sphere_sre, dim)  # form up the objective function

    # setup algorithm parameters
    budget = 2000  # number of calls to the objective function
    parameter = Parameter(budget=budget,
                          high_dim_handling=True,
                          reducedim=True,
                          num_sre=5,
                          low_dimension=Dimension(10, [[-1, 1]] * 10,
                                                  [True] * 10))
    solution_list = ExpOpt.min(objective,
                               parameter,
                               repeat=1,
                               plot=True,
                               plot_file="img/minimize_sphere_sre.png")
Ejemplo n.º 4
0
def minimize_sphere_mixed():
    """
    Mixed optimization example of minimizing sphere function, which has mixed search search space.

    :return: no return value
    """

    # setup optimization problem
    dim_size = 100
    dim_regs = []
    dim_tys = []
    # In this example, the search space is discrete if this dimension index is odd, Otherwise, the search space
    # is continuous.
    for i in range(dim_size):
        if i % 2 == 0:
            dim_regs.append([0, 1])
            dim_tys.append(True)
        else:
            dim_regs.append([0, 100])
            dim_tys.append(False)
    dim = Dimension(dim_size, dim_regs, dim_tys)
    objective = Objective(sphere_mixed, dim)  # form up the objective function
    budget = 100 * dim_size  # number of calls to the objective function
    parameter = Parameter(budget=budget)

    solution_list = ExpOpt.min(objective,
                               parameter,
                               repeat=1,
                               plot=True,
                               plot_file="img/sphere_mixed_figure.png")
Ejemplo n.º 5
0
 def test_racos_performance(self):
     dim = 100  # dimension
     objective = Objective(ackley,
                           Dimension(dim, [[-1, 1]] * dim,
                                     [True] * dim))  # setup objective
     parameter = Parameter(budget=100 * dim, sequential=False)
     solution = ExpOpt.min(objective, parameter)[0]
     assert solution.get_value() < 0.2
Ejemplo n.º 6
0
 def test_asracos_performance(self):
     # continuous
     dim = 100  # dimension
     objective = Objective(ackley,
                           Dimension(dim, [[-1, 1]] * dim,
                                     [True] * dim))  # setup objective
     parameter = Parameter(budget=100 * dim,
                           parallel=True,
                           server_num=2,
                           seed=2)
     # parameter = Parameter(budget=100 * dim, init_samples=[Solution([0] * 100)])  # init with init_samples
     solution_list = ExpOpt.min(objective, parameter, repeat=1)
     for solution in solution_list:
         value = solution.get_value()
         assert value < 0.2
     # discrete
     # setcover
     problem = SetCover()
     dim = problem.dim  # the dim is prepared by the class
     objective = Objective(problem.fx,
                           dim)  # form up the objective function
     budget = 100 * dim.get_size(
     )  # number of calls to the objective function
     parameter = Parameter(budget=budget,
                           parallel=True,
                           server_num=2,
                           seed=777)
     sol = ExpOpt.min(objective, parameter, repeat=1)[0]
     assert sol.get_value() < 2
     # sphere
     dim_size = 100  # dimensions
     dim_regs = [[-10, 10]] * dim_size  # dimension range
     dim_tys = [False] * dim_size  # dimension type : integer
     dim_order = [True] * dim_size
     dim = Dimension(dim_size, dim_regs, dim_tys,
                     order=dim_order)  # form up the dimension object
     objective = Objective(sphere_discrete_order,
                           dim)  # form up the objective function
     parameter = Parameter(budget=10000,
                           parallel=True,
                           server_num=2,
                           uncertain_bits=1,
                           seed=1)
     sol = ExpOpt.min(objective, parameter)[0]
     assert sol.get_value() < 10
Ejemplo n.º 7
0
def minimize_sphere_discrete_order():
    """
    Discrete optimization example of minimizing the sphere function, which has ordered search space.

    :return: no return value
    """
    dim_size = 100  # dimensions
    dim_regs = [[-10, 10]] * dim_size  # dimension range
    dim_tys = [False] * dim_size  # dimension type : integer
    dim_order = [True] * dim_size
    dim = Dimension(dim_size, dim_regs, dim_tys, order=dim_order)  # form up the dimension object
    objective = Objective(sphere_discrete_order, dim)  # form up the objective function

    # setup algorithm parameters
    budget = 10000  # number of calls to the objective function
    parameter = Parameter(budget=budget, uncertain_bits=1)

    ExpOpt.min(objective, parameter, repeat=1, plot=True, plot_file="img/sphere_discrete_order_figure.png")
Ejemplo n.º 8
0
def minimize_setcover_discrete():
    """
    Discrete optimization example of minimizing setcover problem.

    :return: no return value
    """
    problem = SetCover()
    dim = problem.dim  # the dim is prepared by the class
    objective = Objective(problem.fx, dim)  # form up the objective function
    budget = 100 * dim.get_size()  # number of calls to the objective function
    # if autoset is False, you should define train_size, positive_size, negative_size on your own
    parameter = Parameter(budget=budget, autoset=False)
    parameter.set_train_size(6)
    parameter.set_positive_size(1)
    parameter.set_negative_size(5)

    ExpOpt.min(objective,
               parameter,
               repeat=10,
               best_n=5,
               plot=True,
               plot_file="img/setcover_discrete_figure.png")
Ejemplo n.º 9
0
def minimize_ackley_continuous():
    """
    Continuous optimization example of minimizing the ackley function.

    :return: no return value
    """
    dim_size = 100  # dimensions
    dim_regs = [[-1, 1]] * dim_size  # dimension range
    dim_tys = [True] * dim_size  # dimension type : real
    dim = Dimension(dim_size, dim_regs, dim_tys)  # form up the dimension object

    objective = Objective(ackley, dim)  # form up the objective function

    budget = 100 * dim_size  # number of calls to the objective function
    parameter = Parameter(budget=budget)

    solution_list = ExpOpt.min(objective, parameter, repeat=1, plot=True, plot_file="img/ackley_continuous_figure.png")
Ejemplo n.º 10
0
    def fit(self,
            real_data,
            budget=10000,
            server_num=3,
            repeat=1,
            seed=1,
            plot=False,
            plot_file="optimize.png",
            intermediate_freq=100,
            init_samples=None,
            loss_ord=0):
        problem = problem_maker(self, real_data, self.training_date_end,
                                loss_ord)
        dim, dim_range, dim_type = self.get_dim()  # dimension
        dim_range = [[a[0], a[1]] for a in dim_range]
        print(dim_range)
        objective = Objective(problem, Dimension(dim, dim_range,
                                                 dim_type))  # set up objective
        parameter = Parameter(algorithm='racos',
                              budget=budget,
                              intermediate_result=True,
                              intermediate_freq=intermediate_freq,
                              seed=seed,
                              parallel=True,
                              server_num=server_num,
                              init_samples=init_samples)
        parameter.set_probability(0.6)
        solution_list = ExpOpt.min(objective,
                                   parameter,
                                   repeat=repeat,
                                   plot=plot,
                                   plot_file=plot_file)

        f_min = np.inf
        x_min = None
        for s in solution_list:
            if s.get_value() < f_min:
                f_min = s.get_value()
                x_min = s.get_x()

        self.set_param(x_min)

        return x_min, f_min
Ejemplo n.º 11
0
 def test_racos_performance2(self):
     # continuous
     dim = 100  # dimension
     one_dim = (ValueType.CONTINUOUS, [-1, 1], 1e-6)
     dim_list = [(one_dim)] * dim
     objective = Objective(ackley, Dimension2(dim_list))  # setup objective
     parameter = Parameter(budget=100 * dim, sequential=False, seed=1)
     solution = ExpOpt.min(objective, parameter)[0]
     assert solution.get_value() < 0.2
     dim = 500
     dim_list = [(one_dim)] * dim
     objective = Objective(ackley, Dimension2(dim_list))  # setup objective
     parameter = Parameter(budget=10000, sequential=False, seed=1)
     sol = Opt.min(objective, parameter)
     sol.print_solution()
     assert solution.get_value() < 2
     # discrete
     # setcover
     problem = SetCover()
     dim_size = 20
     one_dim = (ValueType.DISCRETE, [0, 1], False)
     dim_list = [(one_dim)] * dim_size
     dim = Dimension2(dim_list)  # the dim is prepared by the class
     objective = Objective(problem.fx,
                           dim)  # form up the objective function
     budget = 100 * dim.get_size(
     )  # number of calls to the objective function
     parameter = Parameter(budget=budget, sequential=False, seed=777)
     sol = Opt.min(objective, parameter)
     sol.print_solution()
     assert sol.get_value() < 2
     # sphere
     dim_size = 100  # dimensions
     one_dim = (ValueType.DISCRETE, [-10, 10], True)
     dim_list = [(one_dim)] * dim_size
     dim = Dimension2(dim_list)  # form up the dimension object
     objective = Objective(sphere_discrete_order,
                           dim)  # form up the objective function
     parameter = Parameter(budget=10000, sequential=False, seed=77)
     sol = Opt.min(objective, parameter)
     sol.print_solution()
     assert sol.get_value() < 200
Ejemplo n.º 12
0
 def test_racos_performance(self):
     # continuous
     dim = 100  # dimension
     objective = Objective(ackley,
                           Dimension(dim, [[-1, 1]] * dim,
                                     [True] * dim))  # setup objective
     parameter = Parameter(budget=100 * dim, sequential=False, seed=1)
     solution = ExpOpt.min(objective, parameter)[0]
     assert solution.get_value() < 0.2
     dim = 500
     objective = Objective(ackley,
                           Dimension(dim, [[-1, 1]] * dim,
                                     [True] * dim))  # setup objective
     parameter = Parameter(budget=10000, sequential=False, seed=1)
     sol = Opt.min(objective, parameter)
     sol.print_solution()
     assert solution.get_value() < 2
     # discrete
     # setcover
     problem = SetCover()
     dim = problem.dim  # the dim is prepared by the class
     objective = Objective(problem.fx,
                           dim)  # form up the objective function
     budget = 100 * dim.get_size(
     )  # number of calls to the objective function
     parameter = Parameter(budget=budget, sequential=False, seed=777)
     sol = Opt.min(objective, parameter)
     sol.print_solution()
     assert sol.get_value() < 2
     # sphere
     dim_size = 100  # dimensions
     dim_regs = [[-10, 10]] * dim_size  # dimension range
     dim_tys = [False] * dim_size  # dimension type : integer
     dim_order = [True] * dim_size
     dim = Dimension(dim_size, dim_regs, dim_tys,
                     order=dim_order)  # form up the dimension object
     objective = Objective(sphere_discrete_order,
                           dim)  # form up the objective function
     parameter = Parameter(budget=10000, sequential=False, seed=77)
     sol = Opt.min(objective, parameter)
     sol.print_solution()
     assert sol.get_value() < 200
Ejemplo n.º 13
0
def run_test_handlingnoise(task_name, layers, in_budget, max_step, repeat,
                           terminal_value):
    """
    example of running direct policy search for gym task with noise handling.

    :param task_name: gym task name
    :param layers:
        layer information of the neural network
        e.g., [2, 5, 1] means input layer has 2 neurons, hidden layer(only one) has 5 and output layer has 1
    :param in_budget:  number of calls to the objective function
    :param max_step: max step in gym
    :param repeat:  number of repeatitions for noise handling
    :param terminal_value: early stop, algorithm should stop when such value is reached
    :return: no return value
    """
    gym_task = GymTask(task_name)  # choose a task by name
    gym_task.new_nnmodel(layers)  # construct a neural network
    gym_task.set_max_step(max_step)  # set max step in gym

    budget = in_budget  # number of calls to the objective function
    rand_probability = 0.95  # the probability of sample in model

    # set dimension
    dim_size = gym_task.get_w_size()
    dim_regs = [[-10, 10]] * dim_size
    dim_tys = [True] * dim_size
    dim = Dimension(dim_size, dim_regs, dim_tys)
    # form up the objective function
    objective = Objective(gym_task.sum_reward, dim)
    # by default, the algorithm is sequential RACOS
    parameter = Parameter(budget=budget,
                          autoset=True,
                          suppression=True,
                          terminal_value=terminal_value)
    parameter.set_resample_times(70)
    parameter.set_probability(rand_probability)

    solution_list = ExpOpt.min(objective, parameter, repeat=repeat)
Ejemplo n.º 14
0
    def training_error(self, best):
        """
        Training error.
        """
        wrong = 0.0
        for i in range(len(self.__data)):
            fx = self.calc_product(best, i)
            if fx * self.trans_label(i) <= 0:
                wrong += 1
        rate = wrong / len(self.__data)
        return rate

    def dim(self):
        """
        Construct dimension of this problem.
        """
        return Dimension(self.__dim_size, [[-10, 10]] * self.__dim_size,
                         [True] * self.__dim_size)


if __name__ == '__main__':
    # read data
    loss = RampLoss('ionosphere.arff')
    objective = Objective(loss.eval, loss.dim())
    budget = 100 * loss.get_dim_size()
    parameter = Parameter(budget=budget)
    solution_list = ExpOpt.min(objective,
                               parameter,
                               repeat=1,
                               plot=True,
                               plot_file="img/ramploss.png")
Ejemplo n.º 15
0
"""
An example of using POSS to optimize a subset selection problem.
"""

from sparse_mse import SparseMSE
from zoopt import Objective, Parameter, ExpOpt
from math import exp

if __name__ == '__main__':
    # load data file
    mse = SparseMSE('sonar.arff')
    mse.set_sparsity(8)

    # setup objective
    # print(mse.get_dim().get_size())
    objective = Objective(func=mse.loss,
                          dim=mse.get_dim(),
                          constraint=mse.constraint)
    parameter = Parameter(algorithm='poss',
                          budget=2 * exp(1) * (mse.get_sparsity()**2) *
                          mse.get_dim().get_size(),
                          seed=1)

    # perform sparse regression with constraint |w|_0 <= k
    solution_list = ExpOpt.min(objective, parameter, repeat=2, plot=False)
Ejemplo n.º 16
0
                idx_ssz.append(i)
    ssz = np.asarray(np.sort(ssz))
        
    # table2 = np.concatenate((table2[:122,:],table2[121,:].reshape((1,256)),table2[122:,:]))
    # table3 = np.concatenate((table3[:122,:],table3[121,:].reshape((1,256)),table3[122:,:]))
             
    # best_approx = np.asarray([table1,table2,table3,table4,table5])
    
    best_approx = [np.asarray(Table1['MUX'][idx_ssz])*2*np.pi,np.asarray(Table1['MUY'][idx_ssz])*2*np.pi]

    env = env_mod.OptEnv(ssz[ss], ssz, focusing_list, solver, n_iter, best_approx)
    
    if solver == 'BOBYQA':
        solution = pybobyqa.solve(env.step, ssz[ss], bounds=(env.lower, env.upper), seek_global_minimum=True)
    elif solver == 'ZOOpt':  
        solution = ExpOpt.min(env.step, env.parameter, plot=True)
    elif solver == 'Bayesian':
        env.optimizer.probe(params = ssz[ss], lazy = True)
        env.optimizer.maximize(n_iter = int(env._n_iter*0.7), init_points = int(env._n_iter*0.3) )
        solution = env.optimizer.max
        
    else:
        solution = minimize(env.step, ssz[ss], method=solver, bounds=env.bounds, options={'maxiter': n_iter,
                                                                                    'xtol': 2,
                                                                                    'adaptive': True
                                                                                        })

    
    timer[solver] = env.timer
    values[solver] = env.values
    positions[solver] = env.x_best
Ejemplo n.º 17
0
"""
This file contains an example of how to optimize continuous ackley function.

Author:
    Yu-Ren Liu, Xiong-Hui Chen
"""

from zoopt import Dimension, Objective, Parameter, ExpOpt
from simple_function import ackley

if __name__ == '__main__':
    dim = 100  # dimension
    objective = Objective(ackley, Dimension(dim, [[-1, 1]] * dim,
                                            [True] * dim))  # setup objective
    parameter = Parameter(budget=100 * dim, sequential=False)
    solution_list = ExpOpt.min(objective,
                               parameter,
                               repeat=5,
                               plot=False,
                               plot_file="img/quick_start.png")
Ejemplo n.º 18
0
"""
An example of using POSS to optimize a subset selection problem.
"""

from sparse_mse import SparseMSE
from zoopt import Objective, Parameter, ExpOpt
from math import exp

if __name__ == '__main__':
    # load data file
    mse = SparseMSE('sonar.arff')
    mse.set_sparsity(8)

    # setup objective
    # print(mse.get_dim().get_size())
    objective = Objective(func=mse.loss,
                          dim=mse.get_dim(),
                          constraint=mse.constraint)
    parameter = Parameter(algorithm='poss',
                          budget=2 * exp(1) * (mse.get_sparsity()**2) *
                          mse.get_dim().get_size())

    # perform sparse regression with constraint |w|_0 <= k
    solution_list = ExpOpt.min(objective, parameter, repeat=1, plot=True)
Ejemplo n.º 19
0
# dim = 100  # dimension
# objective = Objective(ackley, Dimension(dim, [[-1, 1]] * dim, [True] * dim))  # setup objective
# parameter = Parameter(budget=100 * dim, parallel=True, server_num=2)
# # parameter = Parameter(budget=100 * dim, init_samples=[Solution([0] * 100)])  # init with init_samples
# solution_list = ExpOpt.min(objective, parameter, repeat=1)
# for solution in solution_list:
#     value = solution.get_value()
#     assert value < 0.2
# discrete
# setcover
problem = SetCover()
dim = problem.dim  # the dim is prepared by the class
objective = Objective(problem.fx, dim)  # form up the objective function
budget = 100 * dim.get_size()  # number of calls to the objective function
parameter = Parameter(budget=budget, parallel=True, server_num=2, seed=1)
solution_list = ExpOpt.min(objective, parameter, repeat=10)
for solution in solution_list:
    value = solution.get_value()
    assert value < 2
# # sphere
# dim_size = 100  # dimensions
# dim_regs = [[-10, 10]] * dim_size  # dimension range
# dim_tys = [False] * dim_size  # dimension type : integer
# dim_order = [True] * dim_size
# dim = Dimension(dim_size, dim_regs, dim_tys, order=dim_order)  # form up the dimension object
# objective = Objective(sphere_discrete_order, dim)  # form up the objective function
# parameter = Parameter(budget=1000, parallel=True, server_num=1)
# solution_list = ExpOpt.min(objective, parameter, repeat=2, plot=True)
# for solution in solution_list:
#     value = solution.get_value()