def main(): if not os.path.exists("./logfiles"): os.makedirs("logfiles") if os.path.exists("./logfiles/test_matlab_engine.log"): os.remove("./logfiles/test_matlab_engine.log") logging.basicConfig(filename="./logfiles/test_matlab_engine.log", level=logging.INFO) print("\nNumber of threads: 4") print("Maximum number of evaluations: 500") print("Sampling method: CandidateDYCORS") print("Experimental design: Latin Hypercube") print("Surrogate: Cubic RBF") nthreads = 4 maxeval = 500 data = Ackley(dim=10) print(data.info) # Use the serial controller (uses only one thread) controller = ThreadController() controller.strategy = \ SyncStrategyNoConstraints( worker_id=0, data=data, maxeval=maxeval, nsamples=nthreads, exp_design=LatinHypercube(dim=data.dim, npts=2*(data.dim+1)), response_surface=RBFInterpolant(kernel=CubicKernel, tail=LinearTail, maxp=maxeval), sampling_method=CandidateDYCORS(data=data, numcand=100*data.dim)) print("\nNOTE: You may need to specify the matlab_root keyword in " "order \n to start a MATLAB session using the matlab_wrapper " "module\n") # We need to tell MATLAB where the script is mfile_location = os.getcwd() # Launch the threads for _ in range(nthreads): worker = MatlabWorker(controller) try: worker.matlab = matlab_wrapper.MatlabSession(options='-nojvm') except Exception as err: print("\nERROR: Failed to initialize a MATLAB session.\n") exit() worker.matlab.workspace.addpath(mfile_location) controller.launch_worker(worker) # Run the optimization strategy result = controller.run() # Print the final result print('Best value found: {0}'.format(result.value)) print('Best solution found: {0}\n'.format( np.array_str(result.params[0], max_line_width=np.inf, precision=5, suppress_small=True)))
def solve_opf_dycors_serial(problem: AcOPFBlackBox, maxeval=1000, verbose=False, stop_at=False, stop_value=0): """ :param problem: :param maxeval: :param verbose: :param stop_at: :param stop_value: :return: """ print(problem.info) # (2) Experimental design # Use a symmetric Latin hypercube with 2d + 1 samples exp_des = SymmetricLatinHypercube(dim=problem.dim, npts=2 * problem.dim + 1) # (3) Surrogate model # Use a cubic RBF interpolant with a linear tail surrogate = RBFInterpolant(kernel=CubicKernel, tail=LinearTail, maxp=maxeval) # (4) Adaptive sampling # Use DYCORS with 100d candidate points adapt_samp = CandidateDYCORS(data=problem, numcand=100 * problem.dim) # Use the serial controller (uses only one thread) controller = SerialController(problem.objfunction) # (5) Use the sychronous strategy without non-bound constraints strategy = SyncStrategyNoConstraints(worker_id=0, data=problem, maxeval=maxeval, nsamples=1, exp_design=exp_des, response_surface=surrogate, sampling_method=adapt_samp) controller.strategy = strategy # Run the optimization strategy result = controller.run(stop_at=stop_at, stop_value=stop_value) # Print the final result if verbose: print('Best value found: {0}'.format(result.value)) print('Best solution found: {0}'.format( np.array_str(result.params[0], max_line_width=np.inf, precision=5, suppress_small=True))) # the result is x return result.value, result.params[0]
def main(): if not os.path.exists("./logfiles"): os.makedirs("logfiles") if os.path.exists("./logfiles/test_penalty.log"): os.remove("./logfiles/test_penalty.log") logging.basicConfig(filename="./logfiles/test_penalty.log", level=logging.INFO) print("\nNumber of threads: 4") print("Maximum number of evaluations: 500") print("Sampling method: CandidateDYCORS") print("Experimental design: Symmetric Latin Hypercube") print("Surrogate: Cubic RBF") nthreads = 4 maxeval = 500 penalty = 1e6 nsamples = nthreads data = Keane(dim=10) print(data.info) # Create a strategy and a controller controller = ThreadController() controller.strategy = \ SyncStrategyPenalty( worker_id=0, data=data, maxeval=maxeval, nsamples=nsamples, response_surface=RBFInterpolant(kernel=CubicKernel, tail=LinearTail, maxp=maxeval), exp_design=SymmetricLatinHypercube(dim=data.dim, npts=2*(data.dim+1)), sampling_method=CandidateDYCORS(data=data, numcand=100*data.dim), penalty=penalty) # Launch the threads for _ in range(nthreads): worker = BasicWorkerThread(controller, data.objfunction) controller.launch_worker(worker) # Use penalty based merit def feasible_merit(record): xx = np.zeros((1, record.params[0].shape[0])) xx[0, :] = record.params[0] return record.value + controller.strategy.penalty_fun(xx)[0, 0] result = controller.run(merit=feasible_merit) best, xbest = result.value, result.params[0] print('Best value: {0}'.format(best)) print('Best solution: {0}'.format( np.array_str(xbest, max_line_width=np.inf, precision=5, suppress_small=True))) print('Feasible: {0}\n'.format( np.max(data.eval_ineq_constraints(xbest)) <= 0.0))
def main(): if not os.path.exists("./logfiles"): os.makedirs("logfiles") if os.path.exists("./logfiles/test_projection.log"): os.remove("./logfiles/test_projection.log") logging.basicConfig(filename="./logfiles/test_projection.log", level=logging.INFO) print("\nNumber of threads: 4") print("Maximum number of evaluations: 1000") print("Sampling method: CandidateDYCORS") print("Experimental design: Latin Hypercube") print("Surrogate: Cubic RBF") nthreads = 4 maxeval = 1000 nsamples = nthreads data = AckleyUnit(dim=10) print(data.info) def projection(x): return x / np.linalg.norm(x) # Create a strategy and a controller controller = ThreadController() controller.strategy = \ SyncStrategyProjection( worker_id=0, data=data, maxeval=maxeval, nsamples=nsamples, exp_design=LatinHypercube(dim=data.dim, npts=2*(data.dim+1)), response_surface=RBFInterpolant(kernel=CubicKernel, tail=LinearTail, maxp=maxeval), sampling_method=CandidateDYCORS(data=data, numcand=100*data.dim), proj_fun=projection ) # Launch the threads and give them access to the objective function for _ in range(nthreads): worker = BasicWorkerThread(controller, data.objfunction) controller.launch_worker(worker) # Run the optimization strategy result = controller.run() print('Best value found: {0}'.format(result.value)) print('Best solution found: {0}'.format( np.array_str(result.params[0], max_line_width=np.inf, precision=5, suppress_small=True))) print('||x||_2 = {0}\n'.format(np.linalg.norm(result.params[0])))
def main(): if not os.path.exists("./logfiles"): os.makedirs("logfiles") if os.path.exists("./logfiles/test_subprocess_files.log"): os.remove("./logfiles/test_subprocess_files.log") logging.basicConfig(filename="./logfiles/test_subprocess_files.log", level=logging.INFO) print("\nNumber of threads: 4") print("Maximum number of evaluations: 200") print("Sampling method: Candidate DYCORS") print("Experimental design: Symmetric Latin Hypercube") print("Surrogate: Cubic RBF") assert os.path.isfile("./sphere_ext_files"), "You need to build sphere_ext" nthreads = 4 maxeval = 200 nsamples = nthreads data = Sphere(dim=10) print(data.info) # Create a strategy and a controller controller = ThreadController() controller.strategy = \ SyncStrategyNoConstraints( worker_id=0, data=data, maxeval=maxeval, nsamples=nsamples, exp_design=SymmetricLatinHypercube(dim=data.dim, npts=2*(data.dim+1)), sampling_method=CandidateDYCORS(data=data, numcand=100*data.dim), response_surface=RBFInterpolant(kernel=CubicKernel, tail=LinearTail, maxp=maxeval)) # Launch the threads and give them access to the objective function for i in range(nthreads): worker = CppSim(controller) worker.my_filename = str(i) + ".txt" controller.launch_worker(worker) # Run the optimization strategy result = controller.run() print('Best value found: {0}'.format(result.value)) print('Best solution found: {0}\n'.format( np.array_str(result.params[0], max_line_width=np.inf, precision=5, suppress_small=True)))
def main(): if not os.path.exists("./logfiles"): os.makedirs("logfiles") if os.path.exists("./logfiles/test_simple_time.log"): os.remove("./logfiles/test_simple_time.log") logging.basicConfig(filename="./logfiles/test_simple_time.log", level=logging.INFO) print("\nNumber of threads: 4") print("Time budget: 30 seconds") print("Sampling method: CandidateDYCORS") print("Experimental design: Symmetric Latin Hypercube") print("Surrogate: Cubic RBF") nthreads = 4 maxeval = -30 nsamples = nthreads data = Ackley(dim=10) print(data.info) # Create a strategy and a controller controller = ThreadController() controller.strategy = \ SyncStrategyNoConstraints( worker_id=0, data=data, maxeval=maxeval, nsamples=nsamples, exp_design=SymmetricLatinHypercube(dim=data.dim, npts=2*(data.dim+1)), response_surface=RBFInterpolant(kernel=CubicKernel, tail=LinearTail, maxp=1000), sampling_method=CandidateDYCORS(data=data, numcand=100*data.dim)) # Launch the threads and give them access to the objective function for _ in range(nthreads): worker = BasicWorkerThread(controller, data.objfunction) controller.launch_worker(worker) # Run the optimization strategy start_time = time.time() result = controller.run() end_time = time.time() print('Run time: {0} seconds'.format(end_time - start_time)) print('Best value found: {0}'.format(result.value)) print('Best solution found: {0}\n'.format( np.array_str(result.params[0], max_line_width=np.inf, precision=5, suppress_small=True)))
def main(): if not os.path.exists("./logfiles"): os.makedirs("logfiles") if os.path.exists("./logfiles/test_multisampling.log"): os.remove("./logfiles/test_multisampling.log") logging.basicConfig(filename="./logfiles/test_multisampling.log", level=logging.INFO) print("\nNumber of threads: 1") print("Maximum number of evaluations: 500") print( "Sampling method: CandidateDYCORS, Genetic Algorithm, Multi-Start Gradient" ) print("Experimental design: Latin Hypercube") print("Surrogate: Cubic RBF") nthreads = 1 maxeval = 500 nsamples = nthreads data = Ackley(dim=10) print(data.info) # Create a strategy and a controller sampling_method = [ CandidateDYCORS(data=data, numcand=100 * data.dim), GeneticAlgorithm(data=data), MultiStartGradient(data=data) ] controller = SerialController(data.objfunction) controller.strategy = \ SyncStrategyNoConstraints( worker_id=0, data=data, maxeval=maxeval, nsamples=nsamples, response_surface=RBFInterpolant(kernel=CubicKernel, tail=LinearTail, maxp=maxeval), exp_design=SymmetricLatinHypercube(dim=data.dim, npts=2*(data.dim + 1)), sampling_method=MultiSampling(sampling_method, [0, 1, 0, 2])) result = controller.run() best, xbest = result.value, result.params[0] print('Best value: {0}'.format(best)) print('Best solution: {0}\n'.format( np.array_str(xbest, max_line_width=np.inf, precision=5, suppress_small=True)))
def main(): if not os.path.exists("./logfiles"): os.makedirs("logfiles") if os.path.exists("./logfiles/test_gp.log"): os.remove("./logfiles/test_gp.log") logging.basicConfig(filename="./logfiles/test_gp.log", level=logging.INFO) print("\nNumber of threads: 4") print("Maximum number of evaluations: 500") print("Sampling method: CandidateDYCORS") print("Experimental design: Symmetric Latin Hypercube") print("Surrogate: Gaussian process regression") nthreads = 4 maxeval = 500 nsamples = nthreads data = Ackley(dim=10) print(data.info) # Create a strategy and a controller controller = ThreadController() controller.strategy = \ SyncStrategyNoConstraints( worker_id=0, data=data, maxeval=maxeval, nsamples=nsamples, exp_design=SymmetricLatinHypercube(dim=data.dim, npts=2*(data.dim+1)), response_surface=GPRegression(maxp=maxeval), sampling_method=CandidateDYCORS(data=data, numcand=100*data.dim)) # Launch the threads and give them access to the objective function for _ in range(nthreads): worker = BasicWorkerThread(controller, data.objfunction) controller.launch_worker(worker) # Run the optimization strategy result = controller.run() print('Best value found: {0}'.format(result.value)) print('Best solution found: {0}\n'.format( np.array_str(result.params[0], max_line_width=np.inf, precision=5, suppress_small=True)))
def main_master(nworkers): if not os.path.exists("./logfiles"): os.makedirs("logfiles") if os.path.exists("./logfiles/test_subprocess_mpi.log"): os.remove("./logfiles/test_subprocess_mpi.log") logging.basicConfig(filename="./logfiles/test_subprocess_mpi.log", level=logging.INFO) print( "\nTesting the POAP MPI controller with {0} workers".format(nworkers)) print("Maximum number of evaluations: 200") print("Search strategy: Candidate DYCORS") print("Experimental design: Symmetric Latin Hypercube") print("Surrogate: Cubic RBF") assert os.path.isfile("./sphere_ext"), "You need to build sphere_ext" maxeval = 200 data = Sphere(dim=10) print(data.info) # Create a strategy and a controller strategy = \ SyncStrategyNoConstraints( worker_id=0, data=data, maxeval=maxeval, nsamples=nworkers, exp_design=SymmetricLatinHypercube(dim=data.dim, npts=2*(data.dim+1)), sampling_method=CandidateDYCORS(data=data, numcand=100*data.dim), response_surface=RBFInterpolant(kernel=CubicKernel, tail=LinearTail, maxp=maxeval)) controller = MPIController(strategy) # Run the optimization strategy result = controller.run() print('Best value found: {0}'.format(result.value)) print('Best solution found: {0}\n'.format( np.array_str(result.params[0], max_line_width=np.inf, precision=5, suppress_small=True)))
def main(): if not os.path.exists("./logfiles"): os.makedirs("logfiles") if os.path.exists("./logfiles/test_extra_vals.log"): os.remove("./logfiles/test_extra_vals.log") logging.basicConfig(filename="./logfiles/test_extra_vals.log", level=logging.INFO) print("\nNumber of threads: 4") print("Maximum number of evaluations: 500") print("Sampling method: CandidateDYCORS") print("Experimental design: Symmetric Latin Hypercube") print("Surrogate: Cubic RBF") nthreads = 4 maxeval = 500 nsamples = nthreads data = Ackley(dim=10) print(data.info) nextra = 10 extra = np.random.uniform(data.xlow, data.xup, (nextra, data.dim)) extra_vals = np.nan * np.ones((nextra, 1)) for i in range(nextra): # Evaluate every second point if i % 2 == 0: extra_vals[i] = data.objfunction(extra[i, :]) # Create a strategy and a controller controller = ThreadController() controller.strategy = \ SyncStrategyNoConstraints( worker_id=0, data=data, maxeval=maxeval, nsamples=nsamples, exp_design=SymmetricLatinHypercube(dim=data.dim, npts=2*(data.dim+1)), response_surface=RBFInterpolant(kernel=CubicKernel, tail=LinearTail, maxp=maxeval), sampling_method=CandidateDYCORS(data=data, numcand=100*data.dim), extra=extra, extra_vals=extra_vals) # Append the known function values to the POAP database since POAP won't evaluate these points for i in range(len(extra_vals)): if not np.isnan(extra_vals[i]): record = EvalRecord(params=(np.ravel(extra[i, :]), ), status='completed') record.value = extra_vals[i] record.feasible = True controller.fevals.append(record) # Launch the threads and give them access to the objective function for _ in range(nthreads): worker = BasicWorkerThread(controller, data.objfunction) controller.launch_worker(worker) # Run the optimization strategy result = controller.run() print('Best value found: {0}'.format(result.value)) print('Best solution found: {0}\n'.format( np.array_str(result.params[0], max_line_width=np.inf, precision=5, suppress_small=True)))