def cost_history(self, **kwargs): from pyswarms.utils import plotters plotters.plot_cost_history( cost_history=self.samples.log_posterior_list, **kwargs ) self.output.to_figure(structure=None, auto_filename="cost_history") self.close()
def cost_history(self, **kwargs): plotters.plot_cost_history( cost_history=self.samples.log_posterior_list, **kwargs ) self.output.to_figure(structure=None, auto_filename="cost_history") self.mat_plot_1d.figure.close()
def swarm(self): circuit_swarm = GlobalBestPSO(n_particles=self.particles, dimensions=self.dimensions, options=self.options, bounds=self.bounds) cost, pos = circuit_swarm.optimize(self.swarm_cost, iters=self.loops, n_processes=self.processes) plot_cost_history(circuit_swarm.cost_history) plt.show() return cost, pos
def plotCostHistory(optimizer): ''' :param optimizer: optimizer object returned in the application/definition of PSO ''' try: plot_cost_history(cost_history=optimizer.cost_history) plt.show() except: raise
def plotCostHistory(self, optimizer): ''' :param optimizer: optimizer object returned in the application/definition of PSO ''' try: plot_cost_history(cost_history=optimizer.cost_history) plt.show() except: raise CustomError.ErrorCreationModel(config.ERROR_ON_PLOTTING)
def PSO(): # Set-up hyperparameters options = {'c1': 0.5, 'c2': 0.3, 'w': 0.9} # Call instance of PSO optimizer = ps.single.GlobalBestPSO( n_particles=15, dimensions=len(params), options=options, bounds=([params[i][1] for i in range(len(params))], [params[i][2] for i in range(len(params))])) # Perform optimization best_cost, best_pos = optimizer.optimize(obj_func_many, iters=1000) plot_cost_history(optimizer.cost_history) plt.show()
def pso(c1, c2, w, k=2, p=2, n_particles=100, epochs=100, mode="gbest", verbose=0, visualize=0): options = {'c1': c1, 'c2': c2, 'w': w} # bound max_value = 1.0 * np.ones(DIMENSIONS) min_value = -1.0 * np.ones(DIMENSIONS) bounds = (min_value, max_value) # create pso optimizer if mode == "gbest": from pyswarms.single.global_best import GlobalBestPSO optimizer = GlobalBestPSO(n_particles=n_particles, dimensions=DIMENSIONS, options=options, bounds=bounds) elif mode == "lbest": from pyswarms.single.local_best import LocalBestPSO options.update({"k": k, "p": p}) optimizer = LocalBestPSO(n_particles=n_particles, dimensions=DIMENSIONS, options=options, bounds=bounds) else: raise NotImplementedError("Mode %s not support." % mode) # optimize cost, params = optimizer.optimize(f, epochs, verbose=verbose) if verbose: print("Accuracy: ", (predict(X_test, params) == Y_test).mean()) if visualize: import matplotlib.pyplot as plt from pyswarms.utils.plotters import plot_cost_history plot_cost_history(cost_history=optimizer.cost_history) plt.show() # for bayesian optimization return -cost
def runOptimization(self): ''' Run the Optimization and show convergence history ''' if self.parallel: import ray ray.init() cost, pos = self.optimizer.optimize(self._computeCostFunctionValues_Parallel, iters=self.nIterations) ray.shutdown() else: cost, pos = self.optimizer.optimize(self._computeCostFunctionValues_SingleThreaded, iters=self.nIterations) self._createContinuationFile(self.optimizer.swarm.position, pos, cost) if self.showConvergence: print("Showing optimization convergence plot") # Show optimization history from pyswarms.utils.plotters import plot_cost_history plot_cost_history(self.optimizer.cost_history) plt.show() return cost, pos
def particleswarm(objfcn, dimensions, args={}, use_bnds=True, bounds=(None, None), iters=100, n_particles=10, ftol=-np.inf, options={ 'c1': 0.5, 'c2': 0.3, 'w': 0.9 }, verbosity=1, **kwargs): """ Global minimization function using particle swarms (wrapper around pyswarms.single.GlobalBestPSO) Args: :objfcn: | objective function | Should output a vector with cost values for each of the particles. :dimensions: | Number of parameter values for the objective function. :args: | Dict with objfcn input parameters (except the to be optimized x) :use_bnd: | True, optional | False: omits bounds and defaults to regular minimize function. :bounds: | (lower, upper), optional | Tuple of lists or dicts (x0_keys is None) of lower and upper bounds for each of the parameters values. :iters: | 100, optional | Number of swarm iterations :n_particles: | 10, optional | Number of particles in swarm :ftol: | -np.inf, optional | Relative error in objective_func(best_pos) acceptable for | convergence. Default is :code:`-np.inf` options: | {'c1': 0.5, 'c2': 0.3, 'w':0.9}, optional | dict with keys {'c1', 'c2', 'w'} | A dictionary containing the parameters for the specific | optimization technique. | - 'c1' : float, cognitive parameter | - 'c2' : float, social parameter | - 'w' : float, inertia parameter :verbosity: | 1, optional | If > 0: plot the cost history (see pyswarms's plot_cost_history function) :kwargs: | allows input for other type of arguments for GlobalBestPSO Note: For more info on other input arguments, see 'ps.single.GlobalBestPSO?' Returns: :res: | dict with output of minimization: | keys(): | - 'x_final': final solution x | - 'cost': final function value of obj_fcn() | - and some of the input arguments characterizing the | minimization, such as n_particles, bounds, ftol, options, optimizer. Reference: 1. pyswarms documentation: https://pyswarms.readthedocs.io/ """ if (bounds[0] is None) & (bounds[1] is None): use_bnds = False if use_bnds == True: kwargs['bounds'] = bounds optimizer = ps.single.GlobalBestPSO(n_particles=n_particles, dimensions=dimensions, options=options, ftol=ftol, **kwargs) cost, pos = optimizer.optimize(objfcn, iters=iters, **args) if verbosity > 0: # Plot cost history: plot_cost_history(cost_history=optimizer.cost_history) # create output dictionary: res = { 'x_final': pos, 'cost': cost, 'iters': iters, 'n_particles': n_particles, 'bounds': bounds, 'ftol': ftol, 'options': options, 'optimizer': optimizer } return res
def plotCost(self): plot_cost_history(cost_history=self.optimize.cost_history) plt.show()
# #Main # %%time # # Initialize swarm # options = {'c1': 0.5, 'c2': 0.3, 'w':0.9} # in_dimen = env.observation_space.shape[0] # out_dimen = env.action_space.shape[0] # # Call instance of PSO0 # dimensions = (in_dimen * 20) + 20 + (20*20) +20 +(20*20) + 20 + (20 * out_dimen) + out_dimen # optimizer = ps.single.GlobalBestPSO(n_particles=100, dimensions=dimensions, options=options) # # # Perform optimization # cost, pos = optimizer.optimize(f, iters=500) from pyswarms.utils.plotters import plot_cost_history, plot_contour, plot_surface import matplotlib.pyplot as plt plot_cost_history(optimizer.cost_history) plt.show() 0observation = env.reset() totalReward = 0 for step in range(1000): env.render() action = forward_prop(pos,observation) observation, reward, done, info = env.step(action) totalReward += reward print(totalReward) if done: observation = env.reset() break env.close() show_video()
def save(self, title=None, plot_fit=None, target=None, band=None, param=None, weight=None, cost_history=None, cost_history_particle=None, pso_param_history=None): if self.myid != 0: return if plot_fit is True: if title is not None: fout = 'BAND.' + title.strip() + '.pdf' else: fout = 'BAND.pdf' self.plot_fit(title=title.strip(), fout=fout) if target is True: if title is not None: tfileoutnm = 'band_structure_DFT.' + title.strip( ) + '.dat' + ' ' * ( 132 - len('band_structure_DFT.' + title.strip() + '.dat')) else: tfileoutnm = 'band_structure_DFT.dat' + ' ' * ( 132 - len('band_structure_DFT.dat')) pyfit.print_target(self.pinpt, self.pkpts, self.edft, self.pwght, self.pgeom, tfileoutnm) if band is True: if title is not None: suffix = '.' + title.strip() + ' ' * (132 - len(title.strip()) + 1) else: suffix = ' ' * 132 use_overlap = self.ppram.flag_use_overlap pyfit.print_etba(self.pinpt, self.pkpts, self.etba, self.edft, self.pwght, self.pgeom, suffix, use_overlap) if param is True: if title is not None: param_out = 'PARAM_FIT.new.' + title.strip() + '.dat' else: param_out = 'PARAM_FIT.new.dat' self.print_param(param_out=param_out) if weight is True: if title is not None: weight_out = 'WEIGHT.' + title.strip() + '.dat' else: weight_out = 'WEIGHT.dat' self.print_weight(weight_out=weight_out) if cost_history is True: if title is not None: cost_out_dat = 'COST_HISTORY.' + title.strip() + '.dat' cost_out_pdf = 'COST_HISTORY.' + title.strip() + '.pdf' else: cost_out_dat = 'COST_HISTORY.dat' cost_out_pdf = 'COST_HISTORY.pdf' if self.ppram.niter == 0: niter = self.pinpt.miter else: niter = self.ppram.niter plot_cost_history(self.cost_history[:niter], title=title.strip()) plt.savefig(cost_out_pdf, bbox_inches='tight', pad_inches=0) cost_out = open(cost_out_dat, 'w+') for ii in range(niter): cost_out.write(" %d %.9f \n" % (ii, self.cost_history[ii])) cost_out.close() if cost_history_particle is True: if title is not None: cost_out_dat = 'COST_HISTORY_particles.' + title.strip( ) + '.dat' cost_out_pdf = 'COST_HISTORY_particles.' + title.strip( ) + '.pdf' else: cost_out_dat = 'COST_HISTORY_particles.dat' cost_out_pdf = 'COST_HISTORY_particles.pdf' if self.ppram.niter == 0: niter = self.pinpt.miter else: niter = self.ppram.niter bestn = int(self.n_particles * 0.2) if (bestn > 5): bestn = 5 self.plot_pso_cost_history(title=title.strip(), fout=cost_out_pdf, bestn=bestn) cost_out = open(cost_out_dat, 'w+') for jj in range(self.n_particles): cost_out.write("# Particle : %d \n" % (jj)) for ii in range(niter): cost_out.write("%d %.9f \n" % (ii, self.cost_history_particle[ii, jj])) cost_out.write(" \n") cost_out.close() if pso_param_history is True: if title is not None: param_out_dat = 'PARAM_best_particles.' + title.strip( ) + '.dat' param_out_pdf = 'PARAM_best_particles.' + title.strip( ) + '.pdf' else: param_out_dat = 'PARAM_best_particles.dat' param_out_pdf = 'PARAM_best_particles.pdf' if self.ppram.niter == 0: niter = self.pinpt.miter else: niter = self.ppram.niter bestn_ = int(self.n_particles * 0.2) if (bestn_ > 5): bestn = 5 else: bestn = bestn_ self.plot_pso_pbest(title=title.strip(), fout=param_out_pdf, bestn=bestn) best_nparticle_index = self.cost_history_particle[ -1, :].argsort()[:bestn_] param_out = open(param_out_dat, 'w+') for i in range(bestn_): ii = best_nparticle_index[i] cost = self.cost_history_particle[-1, ii] param_out.write( "# Best Particle : rank=%d , ID=%d, COST=%.9f \n" % (i, ii, cost)) param_set = self.ppram.param for ip in range(self.ppram.nparam_free): param_set[self.ppram.iparam_free[ip] - 1] = self.ppram.pso_pbest_history[-1, ii, ip] for j in range(self.ppram.nparam): pj = self.select_param(param_set, j) param_out.write("%5d %20.9f # %5d %20.9f\n" % (j + 1, pj, ii, cost)) param_out.write(" \n") param_out.close()
def test_plot_cost_history_error(bad_values): """Tests if plot_cost_history() raises an error given bad values""" with pytest.raises(TypeError): plot_cost_history(bad_values)
def test_plot_cost_history_return_type(trained_optimizer, history): """Tests if plot_cost_history() returns a SubplotBase instance""" opt_params = vars(trained_optimizer) plot = plot_cost_history(opt_params[history]) assert isinstance(plot, SubplotBase)
SL, TP = [10, 10, 10, 10] , [20, 20, 20, 20] Volumen= [200, 200, 200, 200] decision = fn.f_decisiones(Operacion, SL,TP,Volumen) backtest_train = fn.f_backtest(escenario,decision,capital_inicial) miniback=fn.f_minimizar(backtest_train) lb= [3,3,1,1,8,8,3,3,100000,100000,50000,50000] ub= [10,10,3,3,20,20,6,6,500000,500000,200000,200000] cost, df_decisiones_optimo, graph= fn.f_optimizacion(escenario,np.array(lb),np.array(ub),Operacion) graph = plot_cost_history(cost_history=graph.cost_history) df_backtest_optimo_train = fn.f_backtest(escenario, df_decisiones_optimo,capital_inicial) df_escenarios_test =fn.f_escenarios_test(escenario) df_backtest_test = fn.f_backtest(df_escenarios_test,decision,capital_inicial) df_backtest_optimo_test= fn.f_backtest(df_escenarios_test, df_decisiones_optimo,capital_inicial) vs.f_graph_train(backtest_train,df_backtest_optimo_train) vs.f_graph_test(df_backtest_test,df_backtest_optimo_test)
def plotCost(self): if self.isFit: plot_cost_history(cost_history=self.cost_history) plt.show() else: print('\nModels is not fitted\n')