def train_PSO_PSO_ANN(inputs, res_ex, boundary, draw_graph=False): dim = 9 + N_H_LAYER * 2 opso = PSO(dim, lambda param: fitness_mean(inputs, res_ex, 50, 25, *scale_args(param, boundary)), max_iter=20, n_particle=10, n_neighbor=4, inertia_start=0.5, inertia_end=0.5, comparator=minimise, min_bound=MIN_BOUND, max_bound=MAX_BOUND) print("\nRunning...\n") if draw_graph: opso.set_graph_config(inputs=inputs, res_ex=res_ex, opso=True) opso.run() return opso
def train_PSO(function, comparator, n_iter, n_particle, n_neighbor, min_bound, max_bound, cognitive_trust, social_trust, inertia_start, inertia_end, velocity_max): pso = PSO(function.dimension, function.evaluate, max_iter=n_iter, n_particle=n_particle, n_neighbor=n_neighbor, comparator=comparator, min_bound=min_bound, max_bound=max_bound, cognitive_trust=cognitive_trust, social_trust=social_trust, inertia_start=inertia_start, inertia_end=inertia_end, velocity_max=velocity_max, version=2011, endl='\r') pso.run() return pso
def run_experiment(function_name, topology, param_pair, pso_variant, num_particles=NUM_POPULATION, num_inter=NUM_ITERATIONS): print("------------START EXPERIMENT-------------") print_experiment_settings(function_name, pso_variant, topology, param_pair) function = getattr(cost_functions, f"{function_name}_fn") err_best_all = sys.maxsize pos_best_all = None for i in range(10): err_best, pos_best = PSO.run(function, (-5.12, 5.12), pso_variant, num_particles, num_inter, topology, param_pair) if err_best < err_best_all: err_best_all = err_best pos_best_all = pos_best err_best_all = format(err_best_all, '.10f') pos_best_all = [format(x, '.10f') for x in pos_best_all] print(f'Best Position: {pos_best_all}') print(f'Best error: {err_best_all}') print("-------------END EXPERIMENT--------------\n\n") return err_best_all, pos_best_all
def train_ANN_PSO(inputs, res_ex, max_iter, n_particle, n_neighbor, nb_h_layers, nb_neurons_layer, min_bound, max_bound, cognitive_trust, social_trust, inertia_start, inertia_end, velocity_max, activations, draw_graph=False): nb_neurons = set_nb_neurons(len(inputs[0]), nb_neurons_layer, nb_h_layers) # print(nb_neurons, n_neighbor, activations) ann = ANN(nb_neurons=nb_neurons, nb_layers=len(nb_neurons), activations=activations) dim = sum(nb_neurons[i] * nb_neurons[i + 1] for i in range(len(nb_neurons) - 1)) + len(nb_neurons) - 1 pso = PSO(dim, lambda params: fitness_for_ann(params, ann, inputs, res_ex), max_iter=max_iter, n_particle=n_particle, n_neighbor=n_neighbor, comparator=minimise, min_bound=min_bound, max_bound=max_bound, cognitive_trust=cognitive_trust, social_trust=social_trust, inertia_start=inertia_start, inertia_end=inertia_end, velocity_max=velocity_max, endl='', version=2007) if draw_graph: pso.set_graph_config(inputs=inputs, res_ex=res_ex) pso.run() return pso, ann
def train_PSO_PSO_ANN(inputs, res_ex, boundary, opso_arg, pso_arg, draw_graph=False): dim = 11 opso = PSO(dim, lambda param: fitness_mean(inputs, res_ex, *pso_arg.values(), *scale_args(param, boundary)), **opso_arg, comparator=minimise, min_bound=train_help.MIN_BOUND, max_bound=train_help.MAX_BOUND, endl="11") print("\nRunning...\n") if draw_graph: opso.set_graph_config(inputs=inputs, res_ex=res_ex, opso=True) opso.run() return opso
def train_PSO_PSO(function): dim = 5 opso = PSO(dim, lambda param: train_mean_PSO(function, minimise, 20, 2000, -5, 10, *active_PSO(*param)), 40, 30, inertia_start=0.5, inertia_end=0.5, comparator=minimise, min_bound=MIN_BOUND, max_bound=MAX_BOUND, endl='\n\n') print('oui') opso.run() params = active_PSO(*opso.best_position) print(params) pso = train_PSO(function, minimise, 20, 500, -5, 10, *params) print("---", pso.best_score, "---", pso.best_position) graph_opso(pso, opso)
def main(): iterations = 100 simulation_runs = 5 num_particles = 36 num_archived = 10 num_dimensions = 5 inertia_weight = 1.5 constriction_factor = 0.5 pso = PSO(max_iter=iterations, simulation_runs=simulation_runs, num_particles=num_particles, num_output_features=num_archived, num_dimensions=num_dimensions, inertia_weight=inertia_weight, constriction_factor=constriction_factor) topology_list = ['full-graph', 'ring', '4-neighbours'] pso_variant_list = ['main', 'inertia-weight', 'constriction-factor'] influence_model_list = [(1.03, 2.07), (2.10, 2.20), (1.0, 2.0)] objective_function_list = [(rastrigin, 0, [(-5.12, 5.12), (-5.12, 5.12), (-5.12, 5.12), (-5.12, 5.12), (-5.12, 5.12)], [(0, 0), (0, 0), (0, 0), (0, 0), (0, 0)]), (griewank, 0, [(-100, 100), (-100, 100), (-100, 100), (-100, 100), (-100, 100)], [(0, 0), (0, 0), (0, 0), (0, 0), (0, 0)])] table_data = [] for objective_function in objective_function_list: for topology in topology_list: for pso_variant in pso_variant_list: for influence_model in influence_model_list: solution, objective_function_value, error_value = pso.run( topology, pso_variant, influence_model, objective_function) table_data += [[ objective_function[0].__name__, pso_variant, topology, str(influence_model), str(solution), objective_function_value, error_value ]] print_table_data(table_data)
def runTest(): global iter_max global num_group if ui_obj.lineEdit.text() and ui_obj.lineEdit_2.text(): iter_max = int(ui_obj.lineEdit.text()) num_group = int(ui_obj.lineEdit_2.text()) else: iter_max = 100 num_group = 150 # 绘制图一 drawCitiesPoint() # 运行主程序进行仿真测试 pso = PSO(num_city = data.shape[0],data = data.copy(),num_group = num_group,iter_max = iter_max,ui_obj = ui_obj) Best_path, Best_length = pso.run() Best_path = list(map(lambda x: x+1,Best_path)) frontText = ui_obj.textEdit.toPlainText() backText = '迭代结束后的最短距离是:' + str(Best_length) + '\n' + '迭代结束后的最佳路径是:' + '\n' + str(Best_path) ui_obj.textEdit.setText(frontText + backText) plt.show()
def main(argv): path_creation("results/pso") path_creation("results/ga") for gaTest in experiments.gaTests: name = gaTest["name"] conf = gaTest["conf"] if DEBUG: print name for n in xrange(n_range[0], n_range[1]): times = [] bestSArr = [] nGens = [] output = {} solutionsFound = 0 for i in range(0, REPS): conf["n"] = n if DEBUG: print gaTest g = GA(**conf) res, time = timer(lambda: g.run()) bestS = res["bestS"] bestInd = res["bestInd"] backupBest = res["backupBest"] nGen = res["nGens"] fitness = bestInd.fitness.values bestSArr.append(bestS) times.append(time) nGens.append(nGen) if fitness[0] == 0.0 and bestS == fraud[n]: solutionsFound += 1 if DEBUG: sys.stdout.write('\t') print bestS, bestInd, backupBest, nGens, fitness, solutionsFound meanTimes = np.mean(times) stdTimes = np.std(times) meanGens = np.mean(nGens) stdGens = np.std(nGens) meanS = np.mean(bestSArr) stdS = np.std(bestSArr) output["meanTimes"] = meanTimes output["stdTimes"] = stdTimes output["meanGens"] = meanGens output["stdGens"] = stdGens output["meanS"] = meanS output["stdS"] = stdS output["solutionPercentage"] = float(solutionsFound) / REPS output["n"] = n with open( 'results/ga/ga' + "_" + str(name) + "_n=" + str(n) + "_reps=" + str(REPS) + ".data", 'w+') as the_file: the_file.write(str(output)) for psoTest in experiments.psoTests: name = psoTest["name"] conf = psoTest["conf"] if DEBUG: print name for n in xrange(n_range[0], n_range[1]): times = [] bestSArr = [] nGens = [] output = {} solutionsFound = 0 for i in range(0, REPS): conf["n"] = n if DEBUG: print psoTest print conf pso = PSO(**conf) res, time = timer(lambda: pso.run()) bestS = res["bestS"] bestInd = res["bestInd"] nGen = res["nGens"] fitness = res["bestFitness"] bestSArr.append(bestS) times.append(time) nGens.append(nGen) if fitness[0] == 0.0 and bestS == fraud[n]: solutionsFound += 1 if DEBUG: sys.stdout.write('\t') print bestS, bestInd, fitness[0], nGens, solutionsFound meanTimes = np.mean(times) stdTimes = np.std(times) meanGens = np.mean(nGens) stdGens = np.std(nGens) meanS = np.mean(bestSArr) stdS = np.std(bestSArr) output["meanTimes"] = meanTimes output["stdTimes"] = stdTimes output["meanGens"] = meanGens output["stdGens"] = stdGens output["meanS"] = meanS output["stdS"] = stdS output["solutionPercentage"] = float(solutionsFound) / REPS output["n"] = n with open( 'results/pso/pso' + "_" + str(name) + "_n=" + str(n) + ".data", 'w+') as the_file: the_file.write(str(output))
# importar o otimizador from pso import PSO # criar instancia da função de teste quadrática def quad_func(x): return x[0]**2 + x[1]**2 # Executar o algoritmo pso_unimodal = PSO(quad_func, [-10, -10], [10, 10], max_feval=1000, swarm_size=10, acceleration=[1.5, 1.5], constrition=0.5, topology='lbest') pso_unimodal.run()
class Nightmare(): def __init__(self,model,cost_function,start_parameters,savename,): self.model = model self.cost_function = cost_function self.start_parameters = start_parameters self.set_PSO() self.savename = savename def set_PSO(self,): self.pso = PSO() self.pso.set_cost_function(self.cost_function) self.pso.update_w = True self.pso.set_start_position(self.start_parameters) self.pso.set_bounds(1.0) self.pso.set_speed(-0.25,0.25) def run_pso(self,nchains,nparticles,niterations): self.nchains = nchains self.pso_results = [] for _ in range(nchains): self.pso.run(nparticles,niterations) self.pso_results.append({'params':np.asarray(self.pso.best)}) self.pso.set_start_position(self.start_parameters) self.pso.best = None def run_DREAM(self,nsamples=100000): model = pymc.Model() with model: params = pymc.Normal('params', mu=self.start_parameters, sd=np.array([1.0 ]*len(self.start_parameters)), shape=(len(self.start_parameters))) #params = pymc.Flat('params',shape=(len(self.start_parameters))) global cost_function cost_function = self.cost_function error = pymc.Potential('error', DREAM_cost(params)) nseedchains = 10*len(self.model.parameters_rules()) step = pymc.Dream(variables=[params], nseedchains=nseedchains, blocked=True, start_random=False, save_history=True, parallel=True, adapt_crossover=False, verbose=False,) trace = pymc.sample(nsamples, step, start=self.pso_results, njobs=self.nchains, use_mpi=False, progressbar=False,) cont_flag = True while cont_flag: cont_flag = False conv_stats = gelman_rubin(trace) for i in conv_stats['params']: if i>1.2: print "Parameters have not converged, will continue run." print "Value so far is %s"%i cont_flag = True break trace = pymc.sample(int(nsamples*.1), step, #start=self.pso_results, njobs=self.nchains, use_mpi=False, trace = trace, progressbar=False,) conv_stats = gelman_rubin(trace) for i in conv_stats['params']: print i,i<1.2 #pymc.traceplot(trace,vars=[params,error]) #plt.show() return trace
import pandas as pd import matplotlib.pyplot as plt from pso import PSO if __name__ == "__main__": data = pd.read_csv('D:/Tsukuba/My Research/Program/dataset/1_normal_data/normal_data.csv') x = data.values pso = PSO(n_cluster=4, n_particle=10, data=x, hybrid=True)#max_iter, print_debug pso.run() pso.show_cluter()