def _gen_swarm(self, lo, up, size=0): for _ in range(size): self.particles.append( Particle( random_vector(lo, up), random_vector(-abs(up - lo), abs(up - lo)) ) )
def _gen_swarm(self, lo, up, size=0): for _ in range(size): x = random_vector(lo, up) self.particles.append( Particle(x, random_vector(-abs(up - lo), abs(up - lo)))) if calculate_yang(x) < calculate_yang( self.best_swarm_x) or self.best_swarm_x == -1: self.best_swarm_x = calculate_yang(x)
def _gen_swarm(self, lo, up, e, size=0): for _ in range(size): x = random_vector(lo, up) self.particles.append( Particle(x, random_vector(-abs(up - lo), abs(up - lo)))) x_val = calculate_yang(x, e) if x_val < self.best_swarm_val or self.best_swarm_x == -1: self.best_swarm_x = x self.best_swarm_val = x_val
def update_velocity(self, omega, fip, fig, g): r = random_vector(0, 1, 2) r2 = random_vector(0, 1, 2) self.velocity = [ omega * self.velocity[i] + fip * r[0]*r2[1] * (self.best_x[i] - self.x[i]) + fig * r[1]*r2[0] * (g[i] - self.x[i]) for i in range(len(self.velocity)-2) ]+[omega * self.velocity[i] + fip * r[0]*r2[0] * (self.best_x[i] - self.x[i]) + fig * r[1]*r2[1] * (g[i] - self.x[i]) for i in range(len(self.velocity)-2,len(self.velocity))]
def _gen_swarm(self, lo, up, e, size=0): for i in range(size): if i == 0: x = random_vector(lo, up) else: x = random_vector( -abs(max(self.particles[0].x) - min(self.particles[0].x)), abs(max(self.particles[0].x) - min(self.particles[0].x))) self.particles.append( Particle(x, random_vector(-abs(up - lo), abs(up - lo)))) x_val = calculate_yang(x, e) if x_val < self.best_swarm_val or self.best_swarm_x == -1: self.best_swarm_x = x self.best_swarm_val = x_val
def update_velocity(self, omega, fip, fig, g): new_velocity = [] r = random_vector(0, 1, 2) for i in range(len(self.velocity)): new_velocity.append(omega * self.velocity[i] + fip * r[0] * (self.best_x[i] - self.x[i]) + fig * r[1] * (g[i] - self.x[i]))
def RFD(pruning_rate_per_layer, is_first, is_last): ran_feat_1, ran_feat_2 = utils.random_vector(L1, L2) mask_1 = utils.mask_vec(ran_feat_1, pruning_rate_per_layer) mask_2 = utils.mask_vec(ran_feat_2, pruning_rate_per_layer) L1_rd_prev = tf.cond(is_first, lambda: L1_prev * mask_1, lambda: L1_prev) L1_rd = tf.nn.relu(L1_rd_prev + B1) L2_rd = tf.cond(is_last, lambda: tf.nn.relu(tf.matmul(L1_rd, W2) * mask_2 + B2), lambda: tf.nn.relu(tf.matmul(L1_rd, W2) + B2)) model_rd = tf.matmul(L2_rd, W3) + B3 return model_rd
def create_balls(): magic_ball = Ball(BALL_POS, 50) magic_ball.speed = BALL_SPEED * random_vector() result = [magic_ball] for x in (-1, 0, 1): for y in (-1, 0, 1): if x == 0 and y == 0: continue result.append(Ball(BALL_POS + Vec2d(150 * x, 150 * y), random.randint(10, 40))) return result
def main(argv): #get arguments args = parser.parse_args() if args.problem != None: problem = args.problem else: problem = "OneMax" if args.size != None: size = int(args.size) else: size = 100 if args.algorithm != None: algorithm = eval(args.algorithm) else: algorithm = ["OPOEA"] if args.it != None: it = int(args.it) else: it = 1 if args.steps != None: steps = int(args.steps) else: steps = int(size) if args.save != None: save = bool(args.save) else: save = False if args.test != None: test = bool(args.test) else: test = False if args.extra_name != None: extra_name = str(args.extra_name) else: extra_name = "" if args.random_seed != None: random_seed = int(args.random_seed) if it > 1: print("Error: it must be equal to 1 when random_seed is specified") return 1 else: random_seed = None crossover_choice = args.crossover_choice max_evaluation = int(args.max_evaluation) #global ioh_output ioh_output = args.ioh_output #DEBUG #print("args.ioh_output: " + str(args.ioh_output)) #print("ioh_output: " + str(ioh_output)) if 'LL_static' in algorithm: LL_static_lambda1 = int(args.LL_static_lambda1) LL_static_lambda2 = int(args.LL_static_lambda2) LL_static_lda = int(args.LL_static_lda) LL_static_crossOverBias = float(args.LL_static_crossOverBias) if 'LL_static_02' in algorithm: LL_static_02_lda = int(args.LL_static_02_lda) LL_static_02_alpha = int(args.LL_static_02_alpha) LL_static_02_beta = int(args.LL_static_02_beta) if 'LL_dynamic_01' in algorithm: LL_dynamic_01_a = float(args.LL_dynamic_01_a) LL_dynamic_01_b = float(args.LL_dynamic_01_b) if 'LL_dynamic_02' in algorithm: LL_dynamic_02_alpha = float(args.LL_dynamic_02_alpha) LL_dynamic_02_beta = float(args.LL_dynamic_02_beta) LL_dynamic_02_gamma = float(args.LL_dynamic_02_gamma) LL_dynamic_02_a = float(args.LL_dynamic_02_a) LL_dynamic_02_b = float(args.LL_dynamic_02_b) results = {} for alg in algorithm: results[alg] = record.Record() #import algorithms #mytest() #DEBUG if ioh_output is not None: if os.path.isfile(ioh_output): os.remove(ioh_output) with open(ioh_output, 'wt') as f: f.write('') for i in range(it): #for i in tqdm(range(it)): print('Run number ' + str(i)) #set the instance for given problem instance = eval('evaluate.setup_' + problem + '(size, problem)') if random_seed is not None: np.random.seed(random_seed) #initial solution initial_solution = Solution(utils.random_vector(size), None, None, 0) initial_solution.value = getattr(evaluate, problem)(initial_solution, instance, True) #Solve the problem for alg in algorithm: algFunc = getattr(algorithms, alg) if alg == 'LL_static': experiment = algFunc(initial_solution, instance, LL_static_lambda1, LL_static_lambda2, LL_static_lda, LL_static_crossOverBias, crossover_choice, max_evaluation, ioh_output) elif alg == 'LL_static_02': experiment = algFunc(initial_solution, instance, LL_static_02_lda, LL_static_02_alpha, LL_static_02_beta, crossover_choice, max_evaluation, ioh_output) elif alg == 'LL_dynamic_01': experiment = algFunc(initial_solution, instance, LL_dynamic_01_a, LL_dynamic_01_b, crossover_choice, max_evaluation, ioh_output) elif alg == 'LL_dynamic_02': experiment = algFunc(initial_solution, instance, LL_dynamic_02_alpha, LL_dynamic_02_beta, LL_dynamic_02_gamma, LL_dynamic_02_a, LL_dynamic_02_b, crossover_choice, max_evaluation, ioh_output) else: experiment = getattr(algorithms, alg)(initial_solution, instance) #print(alg) print(experiment[0]) results[alg].insert_expriment(experiment) list_of_records = [results[alg] for alg in algorithm] if save: for (l, alg) in zip(list_of_records, algorithm): l.print_to_file(problem, size, alg, steps, extra_name) if test: for (l, alg) in zip(list_of_records, algorithm): l.plot_average(steps) utils.compare(list_of_records, steps, algorithm) if it > 1: print("\n------------------- Summarised results ------------------") for alg in algorithm: lsVals = [e[0] for e in results[alg].list_of_results] print(alg + ', mean: ' + str(results[alg].mean_opt_time)) print(alg + ', min: ' + str(np.min(lsVals))) print(alg + ', max: ' + str(np.max(lsVals))) return 0
def main(): t = 1 x, e = random_vector(0, 5), random_vector(0, 1) swarm(t, x, e)
def main(): t = 10 x, e = random_vector(0, 5), random_vector(0, 1)
def update_velocity(self, omega, fip, fig): new_velocity = [] r = random_vector(0, 1, 2) for i in range(len(self.velocity)): new_velocity.append(omega * self.velocity[i] + fip * r[0] * ())
def update_velocity(self, omega, fip, fig): new_velocity = [] r = random_vector(0, 1, 2) for v in self.velocity: new_velocity.append(omega*v + )
def main(): t = 6 x, e = random_vector(-5, 5), random_vector(0, 1) print(x, e) swarm(t, x, e)
def _gen_swarm(self, size=0, lo, up): for _ in range(size): self.particles.append(Particle(random_vector(lo, up)))