def __init__(self, lower_bound, upper_bound, swarm_size_main_population, swarm_size_auxiliary_population, fitness_function, swarm_confidence=2.0): self._random = np.random.RandomState() self._number_of_dimensions = number_of_dimensions self._lower_bound = lower_bound self._upper_bound = upper_bound self._number_of_generation_swarm = number_of_generation_swarm self._swarm_size_main_population = swarm_size_main_population self._swarm_size_auxiliary_population = swarm_size_auxiliary_population #Swarm hyper-parameters self._swarm_confidence = swarm_confidence self._fitness_function = fitness_function # Create the main swarm responsible to explore the function self._swarm = Swarm(number_of_creatures_main_population=self. _swarm_size_main_population, number_of_creatures_auxiliary_population=self. _swarm_size_auxiliary_population, lower_bound=self._lower_bound, upper_bound=self._upper_bound, random=self._random) self._list_real_evaluation_position = [] self._list_real_evaluation_fitness = []
def __init__(self, lower_bound, upper_bound, number_of_dimensions, number_of_real_evaluation, swarm_size, number_of_generation_swarm, fitness_function, inertia_factor=0.5, self_confidence=1.5, swarm_confidence=1.5, sense_of_adventure=1.5): self._number_of_real_evaluation = number_of_real_evaluation self._random = np.random.RandomState() self._number_of_dimensions = number_of_dimensions self._lower_bound = lower_bound self._upper_bound = upper_bound self._number_of_generation_swarm = number_of_generation_swarm self._fitness_before_real_evalutation = [] #Swarm hyper-parameters self._inertia_factor = inertia_factor self._self_confidence = self_confidence self._swarm_confidence = swarm_confidence self._sense_of_adventure = sense_of_adventure # We remove two for the swarm size. # Because the first step of the algorithm is to add two creatures which cover the space # in the most efficient manner. self._swarm_size = swarm_size-2 self._fitness_function = fitness_function self._regressor = FunctionEstimator(get_EI=True) # Create the main swarm responsible to explore the function self._swarm = Swarm(swarm_size=self._swarm_size, number_of_dimensions=self._number_of_dimensions, lower_bound=self._lower_bound, upper_bound=self._upper_bound, random=self._random) self._list_real_evaluation_position = [] self._list_real_evaluation_fitness = [] self._bound_distance = self.create_bound_distance()
def get(self): if not self.current_user: self.redirect("/login/") else: swarm=Swarm() swarm_uid=swarm.get_user_id_by_email(self.get_email()) arrays=swarm.get_reserved_array_by_user_id(swarm_uid) self.render("swarm_arrays.html",arrays=arrays)
def __init__(self, problemFile, paramFile, toBe=False): self._problem = Problem(problemFile) self._dimParticle = len(self._problem.getVertices()) self._noPopulation, self._sizeOfNeighborhood, self._w, self._c1, self._c2 = 0, 0, 0, 0, 0 self.loadParameters(paramFile) self._population = Swarm(self._noPopulation, self._dimParticle, self._problem) self._neighborhoods = self.selectNeighbors() self._toBeDrawn = toBe
def __init__(self, problem): self.problem = problem self.swarm = Swarm(int(self.problem.params["swarmSize"]), int(self.problem.params["nrDims"]), int(self.problem.params["vmin"]), int(self.problem.params["vmax"])) self.totalIterations = int(self.problem.params["totalIterations"]) self.w = float(self.problem.params["w"]) self.c1 = float(self.problem.params["c1"]) self.c2 = float(self.problem.params["c2"]) self.run() self.showStatistics() self.showEvalDiagram()
def logPSOOutput(): if not inputDir == None: samples = readSamples(inp=inputDir) else: samples = [(inputSample, 1)] with open('Malware_Samples_PSO_Results.csv', 'w') as f: f.write( 'Sample,Sample_Length,Number_of_Initial_Mappings,BaselineCofidence,BaselineFitness,Prediction_Before_PSO, Confidence_After_PSO,Fitness_After_PSO,Prediction_After_PSO,Iteration,Number_of_Required_Changes,Number_Of_Queries\n' ) i = 0 for samplePath, _ in samples: sample = readSample(samplePath) print(samplePath) length = (len(sample)) try: swarm = Swarm(numOfParticles, randomMutations, maxQueries, sample, C1, C2, earlyTermination) except: print("\n############################################\n") print("Radare2 failed to analyze sample %s. Skipping...\n" % (samplePath)) print("\n############################################\n") continue try: numberOfPotentialMappings = len(swarm.replacements) baselineConfidence = swarm.calculateBaselineConfidence() if baselineConfidence < 0.5: continue print("Searching Optimum Advresarial Example... %s\n" % (i)) swarm.initializeSwarmAndParticles() print('Number of Potential Changes %s\n' % (numberOfPotentialMappings)) print('Model Prediction Before PSO= %s\n' % (0 if baselineConfidence < 0.5 else 1)) print('Baseline Confidence= %s\n' % (str(baselineConfidence))) _, _, iterations, numberOfQueries = swarm.searchOptimum() modelConfidence = baselineConfidence - swarm.bestFitness print('Model Confindence After PSO %s' % (modelConfidence)) print('Best Fitness Score= %s' % (swarm.bestFitness)) finalPosition = swarm.patchTempFile(swarm.bestPosition) predAfter = get_probs(swarm.targetModel, finalPosition) predAfter = 0 if predAfter < 0.5 else 1 numberOfChanges = swarm.numberOfChanges() print('Model Prediction After PSO= %s' % (str(predAfter))) print('Required number of changes (L1)= %s' % (numberOfChanges)) with open('Malware_Samples_PSO_Results.csv', 'a') as f: f.write( '%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s\n' % (samplePath, str(length), str(numberOfPotentialMappings), str(baselineConfidence), str(1 - baselineConfidence), str(0 if baselineConfidence < 0.5 else 1), str(modelConfidence), str( swarm.bestFitness), str(predAfter), str(iterations), str(numberOfChanges), str(numberOfQueries))) i = i + 1 os.system("mv " + str(samplePath) + " dataset/tested") except: os.system("mv " + str(samplePath) + " dataset/failed")
class Iteration: def __init__(self): self._swarm = Swarm(10) self._w = 0.15 self._c1 = 0.15 self._c2 = 0.15 def run(self): bestParticle = self._swarm.getBestParticle() for p in self._swarm.getSwarm(): p.setBestGlobal(bestParticle) for p in self._swarm.getSwarm(): p.update(bestParticle, self._w, self._c1, self._c2) p.evaluate() def getSwarm(self): return self._swarm.getSwarm()
def create_swarm(self, socket, args): """Initialize a new swarm in this node""" swarm_id = args.swarmid if swarm_id in self._swarms: logging.warn( "Trying to add same swarm twice! Swarm: {}".format(swarm_id)) return None self._swarms[swarm_id] = Swarm(socket, args) return self._swarms[swarm_id]
def setup(): fullScreen() size(200, 200) global pop_size, interfaceHeight, interfaceWidth, inertia, c1, c2, lowerB, xlim, ylim pop_size = 5 inertia = 0.9 c1 = 0.2 c2 = 0.1 interfaceHeight = height interfaceWidth = width * 0.22 xlim, lowerB, ylim = width, interfaceWidth, height global img global img1 img = loadImage("grass.jpg") img1 = loadImage("grass1.jpg") global swarm swarm = Swarm(pop_size, lowerB, xlim, ylim, inertia, c1, c2) swarm.init_population()
def run(target_error, n_particles, c1, c2, w, n_iterations): fit = [] search_space = Swarm(1, target_error, n_particles, c1, c2, w) particles_vector = [Particle() for _ in range(search_space.n_particles)] search_space.particles = particles_vector #search_space.print_particles() iteration = 0 while (iteration < n_iterations): search_space.set_pbest() search_space.set_gbest() if (abs(search_space.gbest_value - search_space.target) <= search_space.target_error): break search_space.move_particles() fit.append(search_space.gbest_value) iteration += 1 return (search_space.gbest_position, iteration, fit)
class World(object): ''' lower_bound and upper_bound refer to the min and max of the function to optimize respectively. number_of_genes correspond to the number of dimensions of the function to optimize. population_size Number of creature in a population number_of_generation correspond to the number of the main loop the algorithm will do ''' def __init__(self, lower_bound, upper_bound, swarm_size_main_population, swarm_size_auxiliary_population, fitness_function, swarm_confidence=2.0): self._random = np.random.RandomState() self._number_of_dimensions = number_of_dimensions self._lower_bound = lower_bound self._upper_bound = upper_bound self._number_of_generation_swarm = number_of_generation_swarm self._swarm_size_main_population = swarm_size_main_population self._swarm_size_auxiliary_population = swarm_size_auxiliary_population #Swarm hyper-parameters self._swarm_confidence = swarm_confidence self._fitness_function = fitness_function # Create the main swarm responsible to explore the function self._swarm = Swarm(number_of_creatures_main_population=self. _swarm_size_main_population, number_of_creatures_auxiliary_population=self. _swarm_size_auxiliary_population, lower_bound=self._lower_bound, upper_bound=self._upper_bound, random=self._random) self._list_real_evaluation_position = [] self._list_real_evaluation_fitness = [] def run_world(self, max_evals): nmbr_evals, best_creature_fitness, best_creature_position = self._swarm.run_swarm( max_iter=self._number_of_generation_swarm, fitness_function=self._fitness_function, max_evals=max_evals) print "FINISHED" print "BEST POSITION FOUND" print best_creature_fitness print best_creature_position return nmbr_evals, best_creature_fitness, best_creature_position
def train2(table=train_18, max_x=15, pop=300, gen=500): swarm_app_strat_1 = Swarm(min_x=0, max_x=max_x, n=2, population=pop, generations=gen, table=table, flag_test=1, plt_name='strat_3') swarm_app_strat_2 = Swarm(min_x=0, max_x=max_x, n=2, population=pop, generations=gen, table=table, flag_test=2, plt_name='strat_4') swarm_app_strat_1.start() swarm_app_strat_2.start()
def Optimize(inFilePtr, outFilePtr, convFact, constraint, points, zeroInd, lossFunctionChoice=0): dist = 1.0 / (constraint[:, 2]**convFact) constraint = np.insert(constraint, 3, dist, axis=1) swarm = Swarm(constraint, len(points), randVal=randRange, swarmSize=swarmSize, zeroInd=zeroInd, lossFunc=lossFunctionChoice) ittFin = One_Move(ittCount, swarm, constraint, len(points), threshold, outFilePtr, convFact) return (stats.pearsonr(swarm.gBest[2], constraint[:, 3])[0], stats.spearmanr(swarm.gBest[2], constraint[:, 3])[0], lossFunction(constraint[:, 3], swarm.gBest[2]), ittFin, swarm.id, swarm)
def draw(): delay(100) global r, g, b, pop_size, swarm, interfaceHeight, interfaceWidth, c1, c2, inertia, lowerB, xlim, ylim backgroundObj = Background(r, b, g, height, width + 100, pop_size, inertia, c1, c2, img, img1) backgroundObj.generateShade() backgroundObj.generateBubbles() interface = backgroundObj.generateInterface(interfaceWidth, interfaceHeight) fill(255, 127, 0) ellipse(swarm.foodSource.x, swarm.foodSource.y, 30, 30) #Code starts after u press 32. to hault the simulation press the mouse. to redraw press a key. to continue release the mouse for i in range(len(interface)): if interface[i] == True: if i == 0: pop_size += 1 interface[i] = False if i == 1: if pop_size > 3: pop_size -= 1 interface[i] = False if i == 2: print('helloo') x = inertia + 0.1 if x < 1: inertia += 0.1 interface[i] = False if i == 3: print('kekek') x = inertia - 0.1 if x >= 0.1: inertia -= 0.1 interface[i] = False if i == 4: x = c1 + 0.1 if x < 1: c1 += 0.1 interface[i] = False if i == 5: x = c1 - 0.1 if x >= 0.1: #swarm.inertia+=1 c1 -= 0.1 interface[i] = False if i == 6: x = c2 + 0.1 if x < 1: #swarm.inertia+=1 c2 += 0.1 interface[i] = False if i == 7: x = c2 - 0.1 if x >= 0.1: #swarm.inertia+=1 c2 -= 0.1 interface[i] = False if i == 8: swarm = Swarm(pop_size, lowerB, xlim, ylim, inertia, c1, c2) swarm.init_population() interface[i] = False if i == 9: interface[i] = False print('l') noLoop() if keyCode == 32: swarm.PSO(100) if keyCode == ENTER: noLoop()
def main(): swarm = Swarm(config.ALPHA, config.ABSORPTION) update_brightness(swarm.fireflies) swarm.update_attractiveness() utils.description(swarm.fireflies) swarm.__str__() t = 0 while t < config.MAX_GENERATION: for i, firefly in enumerate(swarm.fireflies): other_firefly = swarm.most_attractive[i] if other_firefly is not firefly and other_firefly.attractiveness > firefly.attractiveness: swarm.move(firefly, other_firefly) elif other_firefly.attractiveness == firefly.attractiveness: swarm.move_randomly(other_firefly) update_brightness(swarm.fireflies) swarm.update_attractiveness() t += 1 print() swarm.__str__()
#for percent_mask in [0.2, 0.4, 0.6, 0.8]: #for percent_mask in [0.5]: for movecity in [0.2, 0.4, 0.6, 0.8]: #tu zmieniamy params = { 'num_of_cities': 15, 'size_cities': size_cities, 'perc_lockdown': 0.4, #Kuba 'perc_mask': 0.7,#percent_mask,#percent_mask, #Ola 0.7 'perc_out': 0.5,#percent_out, ##prawdopodobienstwo wyjscia z zamknietego miasta #Ola 0.5 'random_move': 0.7, #Kuba 'move_city':movecity#movecity#0.3 #Ola } automat = Swarm(m, iteration, aa, bb, pop, show_visualisation=False, **params) #True numbers = automat.simulation() print(numbers) Ill_list.append(numbers.iloc[:, 0]) Rest_list.append(numbers.iloc[:, 1]) Dead_list.append(numbers.iloc[:, 2]) Healthy_list.append(numbers.iloc[:, 3]) #labele_list.append(str(params['perc_out'])) #labele_list.append(str(params['perc_mask'])) labele_list.append(str(params['move_city'])) visualize_simulation(numbers, iteration, 'iter_' + str(iteration) + '_size_cities_' + str(size_cities)) #Ill for i in range(len(Ill_list)):
import math from Swarm import Swarm def ackley(inpt): return -20 * math.exp(-0.2 * math.sqrt(0.5 * ( (inpt[0]**2) + (inpt[1]**2)))) - (math.exp( 0.5 * (math.cos(2 * math.pi * inpt[0]) + math.cos(2 * math.pi * inpt[1])))) + math.exp(1) + 20 def booth(inpt): x = inpt[0] y = inpt[1] return ((x + 2 * y - 7)**2) + (2 * x + y - 5)**2 opt = Swarm(100, [1, 1], 3, booth, 2) for i in range(100): opt.iterate([0.9, 0.9], [0.4, 0.4], [0.2, 0.2]) opt.visualise() print(opt.swarmsBestPos) print(ackley(opt.swarmsBestPos))
from Swarm import Swarm import Helper import time # objectives 2D - shape # obj = Polygon([(0, 0), (0, 0.5), (0.5, 0.5), (0.5, 0)]) # obj = Polygon([(0.5, 0), (0.5, 0.5), (1, 0.5), (1, 0)]) obj = Polygon([(0.25, 0), (0.25, 0.5), (0.75, 0.5), (0.75, 0)]) # obj = Polygon([(0, 0.5), (0.5, 1), (1, 0.5), (0.5, 0)]) # obj = Point(0.5, 0.5).buffer(0.5) if __name__ == '__main__': start_time = time.time() print 'Start PSO Algorithm...' swarm = Swarm(obj) result = swarm.solve() print '... Done PSO Algorithm' print 'Maximum similarity:', result.get_objective_function() best_process = list(set(result.get_position())) best_process = filter(lambda a: a != 24, best_process) print 'Best process: Start', '->', for i in range(len(best_process)): if best_process[i] < Helper.MAX_ACTION: print 'Fold crease', best_process[i] + 1, '->', print 'End' Helper.draw_output(best_process,obj)
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.connect((HOST, PORT)) s.sendall(b'Worker') while True: resp = (s.recv(1024)).decode('utf-8') #print(resp) if resp == '1': print('Beginning Optimizaiton') start = (s.recv(1024)).decode('utf-8') start = start.split(' ') for i in range(len(start)): start[i] = int(start[i]) print("beginning search at: ") print(start) opt = Swarm(1000, start, (max(start) * 0.2), function, len(start)) for i in range(1000): opt.iterate([0.9, 0.9], [0.4, 0.4], [0.2, 0.2]) #time.sleep(5) # make sure that the server is ready to recieve info again toSend = '' for num in opt.swarmsBestPos: toSend += str(num).strip() + ' ' toSend += str(opt.swarmsBestVal) s.sendall(toSend.encode('utf-8')) print('Sent: ' + toSend) print("Found minimum at: ") print(opt.swarmsBestPos) if not resp: break
from Swarm import Swarm import matplotlib.pyplot as plt c1 = 2.05 c2 = 2.05 popSize = 64 swarm1 = Swarm(popSize, c1, c2) swarm2 = Swarm(popSize, c1, c2) swarm3 = Swarm(popSize, c1, c2) swarm1.runInerWeight() swarm2.runInerWeight() swarm3.runInerWeight() print(swarm1.bestSolValue, swarm1.bestSol) print(swarm2.bestSolValue, swarm2.bestSol) print(swarm3.bestSolValue, swarm3.bestSol) gens = [i for i in range(1, swarm1.iter + 1)] fig, (a1, a2) = plt.subplots(2) a1.plot(gens, swarm1.bestPerGen, 'r-', gens, swarm2.bestPerGen, 'g-', gens, swarm3.bestPerGen, 'b-') a2.plot(gens, swarm1.averagePerGen, 'r-', gens, swarm2.averagePerGen, 'g-', gens, swarm3.averagePerGen, 'b-') #plt.plot(gens, swarm1.bestPerGen, 'r-', gens, swarm2.bestPerGen, 'g-', gens, swarm3.bestPerGen, 'b-') #a1.ylabel("Fitness of best particle in generation") #a2.ylabel("Average fitness of population") plt.xlabel("Generation #")
def __init__(self): self._swarm = Swarm(10) self._w = 0.15 self._c1 = 0.15 self._c2 = 0.15
class SwarmProcess(object): ''' lower_bound and upper_bound refer to the min and max of the function to optimize respectively. number_of_genes correspond to the number of dimensions of the function to optimize. population_size Number of creature in a population number_of_generation correspond to the number of the main loop the algorithm will do ''' def __init__(self, lower_bound, upper_bound, number_of_dimensions, number_of_real_evaluation, swarm_size, number_of_generation_swarm, fitness_function, inertia_factor=0.5, self_confidence=1.5, swarm_confidence=1.5, sense_of_adventure=1.5): self._number_of_real_evaluation = number_of_real_evaluation self._random = np.random.RandomState() self._number_of_dimensions = number_of_dimensions self._lower_bound = lower_bound self._upper_bound = upper_bound self._number_of_generation_swarm = number_of_generation_swarm self._fitness_before_real_evalutation = [] #Swarm hyper-parameters self._inertia_factor = inertia_factor self._self_confidence = self_confidence self._swarm_confidence = swarm_confidence self._sense_of_adventure = sense_of_adventure # We remove two for the swarm size. # Because the first step of the algorithm is to add two creatures which cover the space # in the most efficient manner. self._swarm_size = swarm_size-2 self._fitness_function = fitness_function self._regressor = FunctionEstimator(get_EI=True) # Create the main swarm responsible to explore the function self._swarm = Swarm(swarm_size=self._swarm_size, number_of_dimensions=self._number_of_dimensions, lower_bound=self._lower_bound, upper_bound=self._upper_bound, random=self._random) self._list_real_evaluation_position = [] self._list_real_evaluation_fitness = [] self._bound_distance = self.create_bound_distance() def create_bound_distance(self): bound_distance = [] for i in range(len(self._lower_bound)): bound_distance.append(self._upper_bound[i] - self._lower_bound[i]) bound_distance = np.array(bound_distance) return bound_distance def run_swarm_process(self): # First we find the combination of creature that cover the space the more thoroughly. # To achieve that, we use KMEANS with k=2 on the list of creature position. kmeans = KMeans(n_clusters=2) swarm_positions = self._swarm.get_list_position() # Get the list of point in the space for KMeans # Normalize the dimension of each point so the point chosen is irrelevant of the possible different unities # of each dimensions normalized_swarm_position = np.array(swarm_positions) / np.array(self._bound_distance) kmeans.fit(normalized_swarm_position) # Train KMeans centers = kmeans.cluster_centers_ # Get the centers centers *= self._bound_distance # Go back to the original dimension print "Centers: ", centers # Add two new creatures with their position corresponding to the centers of kmeans. creature0_position = centers[0] creature0_fitness = FitnessFunction.calculate_fitness(self._fitness_function, creature0_position, self._number_of_dimensions) self._number_of_real_evaluation -= 1 # Did a real evaluation creature1_position = centers[1] creature1_fitness = FitnessFunction.calculate_fitness(self._fitness_function, creature1_position, self._number_of_dimensions) self._number_of_real_evaluation -= 1 # Did a real evaluation self._swarm.add_creature_to_swarm(position=creature0_position) self._swarm.add_creature_to_swarm(position=creature1_position) # Add the creatures position and fitness to the list of position and fitness evaluated self._list_real_evaluation_position.append(creature0_position) self._list_real_evaluation_fitness.append(creature0_fitness) self._list_real_evaluation_position.append(creature1_position) self._list_real_evaluation_fitness.append(creature1_fitness) # Train the regressor self._regressor.train_regressor(self._list_real_evaluation_position, self._list_real_evaluation_fitness) # From here, we alternate between exploration and exploitation randomly based on an heuristic except for the # Very first pass where we for the algorithm to be in exploration mode for one more evaluation # (3 evaluations total) self.exploration() self._number_of_real_evaluation -= 1 # Did a real evaluation # Now that we have three points evaluated, we are ready to start the algorithm for the requested amount of real # evaluations. Or until the user stop the program for generation in range(self._number_of_real_evaluation): print self._list_real_evaluation_position print self._list_real_evaluation_fitness print self._fitness_before_real_evalutation # Decide if we explore or exploite. exploitation_threshold = max(0.2, 1/math.sqrt((generation+2)/2)) exploitation_threshold = 0.0 if self._random.rand() < exploitation_threshold: best_creature_ever = self.exploration() # TODO once the exploitation algorithm is finish. Remove the if/else and move this block after # We are almost done with this generation, get the real value of the point of interest found new_point_to_add_fitness = FitnessFunction.calculate_fitness(self._fitness_function, best_creature_ever.get_position(), self._number_of_dimensions) # Finish the generation by adding the new creature to the list and updating the regressor self._list_real_evaluation_position.append(best_creature_ever.get_position()) self._list_real_evaluation_fitness.append(new_point_to_add_fitness) self._fitness_before_real_evalutation.append(self._regressor.get_estimation_fitness_value(best_creature_ever.get_position())[0]) choose_kernel = False if len(self._list_real_evaluation_fitness) % 10 == 0: choose_kernel = True self._regressor.train_regressor(self._list_real_evaluation_position, self._list_real_evaluation_fitness, choose_kernel=choose_kernel) print "Smallest point found: ", new_point_to_add_fitness, "Fitness found by the PSO:", \ best_creature_ever.get_fitness(), " At position: ", best_creature_ever.get_position() # Reset swarm fitness self._swarm.reset_swarm() else: best_creature_ever = self.exploitation() index = self._list_real_evaluation_fitness.index(min(self._list_real_evaluation_fitness)) print "Smallest point found: ", self._list_real_evaluation_fitness[index], " At position: ", \ self._list_real_evaluation_position[index] def exploration(self): print "EXPLORATION" # We want to get EI self._regressor.set_EI_bool(True) # We want to get the curiosity self._swarm.set_curiosity(True) # Make sure that every creature has been evaluated best_fitness = min(self._list_real_evaluation_fitness) print "BEST CURRENT FITNESS", best_fitness self._swarm.evaluate_fitness_swarm(fitness_function=self._regressor, best_real_function_value=best_fitness) # run swarm optimization with number of iterations. best_creature_ever = self._swarm.run_swarm_optimization(max_iterations=self._number_of_generation_swarm, function_to_optimize=self._regressor, inertia_factor=self._inertia_factor, self_confidence=self._self_confidence, swarm_confidence=self._swarm_confidence, sense_of_adventure=self._sense_of_adventure, best_real_function_value=best_fitness, list_position_with_real_fitness= self._list_real_evaluation_position) return best_creature_ever def exploitation(self): print "EXPLOITATION" # Finish exploration by updating the regressor # We don't want to get EI self._regressor.set_EI_bool(False) seed_position = [] fitness_seed_position = [] # Determine the number of parallel optimization to perform on already evaluated position if len(self._list_real_evaluation_position) <= 10: # Number of parallel optimization = number of real evaluation. seed_position.extend(self._list_real_evaluation_position) fitness_seed_position.extend(self._list_real_evaluation_fitness) else: # Create 10 parallel optimization with seed on the 10 best points found. # Get the 3 best positions and chose randomly 7 other points # Start by partially sorting the array to get the best 3 points index_partially_sorted = np.argpartition(a=self._list_real_evaluation_fitness, kth=3)[0:3] seed_position = self._list_real_evaluation_position[index_partially_sorted] fitness_seed_position = self._list_real_evaluation_fitness[index_partially_sorted] # Add randomly 7 positions different from the 3 positions already selected index_range = range(len(self._list_real_evaluation_fitness)) # remove the already selected values for i in index_partially_sorted: index_range.remove(i) choices = np.random.choice(index_range, 7, replace=False) seed_position.extend(self._list_real_evaluation_position[choices]) fitness_seed_position.extend(self._list_real_evaluation_position[choices]) # Reduce the number of creatures per swarms so that the sum of all the creatures in all of the swarms # Are equivalent to when we are in exploration mode. size_of_swarm = int(self._swarm_size / len(seed_position)) swarms = [] limit = math.pi/10.0 normalized_list_real_evaluation = np.array(self._list_real_evaluation_position)/np.array(self._bound_distance) fitness_list = np.array(self._list_real_evaluation_fitness) # Calculate the std of the fitness fitness_std = np.std(fitness_list) # If the std is very small (close to machine error), then the fitness information is basically uniform. # This mean it's useless to try to exploite this area. Launch and exploration phase instead. if fitness_std < np.finfo(float).eps*10: return self.exploration() # Get the sorted list from biggest value to smallest of the position fitness. sorted_fitness_list = np.flipud(np.sort(fitness_list)) for position, fitness_position in zip(seed_position, fitness_seed_position): # We need to set the upper and lower bound in function of the seed point for this swarm and the variance # of the gaussian process. normalized_position = np.array(np.array(position)/self._bound_distance) ''' # old way difference_between_position_and_points_to_avoid = normalized_list_real_evaluation - normalized_position distance_normalized_position_other_points = np.apply_along_axis( np.linalg.norm, axis=1, arr=difference_between_position_and_points_to_avoid) closest_point = np.argmin(distance_normalized_position_other_points) closesness_factor = 0.5 difference_vector = closest_point-position if fitness_position == sorted_fitness_list[0]: mean = abs(sorted_fitness_list[0]-sorted_fitness_list[1]) else: mean = 1.0 ''' # Bounding box is defined as when the std of the gaussian process is equal or smaller to pi/10.0*fitness_std # around the current position considered. However, since we cannot know analytically the std of the GP, # we have to use another way to actually define the measurement of the bounding box. # To do so, we check the closest known position with a real fitness to the creature we're working on right # now (i.e. identified by the name position). We then trace a segment between those two points and check # in the middle of this segment if the std of the GP is above or below our threshold. # If it's below: take half the original segment and call it L. We add L to the current segment and verify # the GP std. We keep increasing the segment by L until the GP std become bigger than our threshold. This is # our new boundary # If it's above: We divide by sqrt(2) the length of the segment and we check again. We keep repeating that # process until we get a value that is below the researched threshold. This is our new bounding box. # First, find the closest point by calculating the distance between the current position and all the others # with known fitness and get the min index = 0 min_distance = float('Inf') min_distance_index = 0 print normalized_list_real_evaluation print normalized_position for point in normalized_list_real_evaluation: if np.array_equal(normalized_position, point) == False: distance = np.linalg.norm(normalized_position-point) if distance < min_distance: min_distance = distance min_distance_index = index index += 1 closest_point = normalized_list_real_evaluation[min_distance_index] print normalized_list_real_evaluation # Now that we have the closest point, calculate the middle point between the closest point and the # considered position middle_point = (normalized_position+closest_point)/2. # Get the variance in the GP of this point prediction, gp_std = self._regressor.get_estimation_fitness_value(middle_point) max_std = (2.0*math.pi)/10. if gp_std > max_std: # get a smaller and smaller segment until we find a point that is within our boundary new_segment = np.array(middle_point-normalized_position) shrinking_factor = 1.0 while gp_std > max_std: point_to_evaluate = np.array(normalized_position) + (shrinking_factor*new_segment) prediction, gp_std = self._regressor.get_estimation_fitness_value(point_to_evaluate * np.array(self._bound_distance)) shrinking_factor /= math.sqrt(2) else: # get a bigger and bigger segment that grow with the length of the middle point each time # calculate the segment to add each time segment_to_add = (np.array(middle_point)-np.array(normalized_position))/2.0 new_segment = np.array(middle_point) while gp_std < max_std: new_segment += np.array(segment_to_add) prediction, gp_std = self._regressor.get_estimation_fitness_value(new_segment * np.array(self._bound_distance)) # Now that the new segment is calculated. We simply get the distance between the position we're interested # in and this point we just found (new_segment) distance_bound = np.linalg.norm(new_segment-normalized_position) # Take care of the curse of dimensionality distance_bound /= math.pow(math.sqrt(2), self._number_of_dimensions-1) # Unormalize distance_bound *= self._bound_distance # We create an array with the same dimension as the function dimension. We have to provide an upper bound # and a lower bound which will both have a distance of the norm we just calculated (distance_bound) upper_bound_exploitation = position + (distance_bound * np.ones(self._number_of_dimensions)) lower_bound_exploitation = position - (distance_bound * np.ones(self._number_of_dimensions)) swarm_to_add = Swarm(swarm_size=size_of_swarm, number_of_dimensions=self._number_of_dimensions, lower_bound=lower_bound_exploitation, upper_bound=upper_bound_exploitation, random=self._random) swarms.append(swarm_to_add) self._regressor.train_regressor(self._list_real_evaluation_position, self._list_real_evaluation_fitness) return 0.0
class Controller: def __init__(self, problem): self.problem = problem self.params = {} self.load_parameters() self.swarm = Swarm(self.params["swarmSize"], len(self.problem.data.set)) def load_parameters(self): try: f = open("params.in", "r") for x in filter(None, f.read().split('\n')): (param, value) = x.split(' =') value = int(value) self.params[param] = value except Exception as e: print("Exception Controller::loadParameters(fileName): " + str(e)) def iteration(self): for i in range(self.params["swarmSize"]): current = self.swarm.v[i] p = self.swarm.get_best_neighbour() current.update(p, i) current.evaluate(self.problem) def run(self): for i in range(self.params["iterations"]): print(i) self.iteration() return self.swarm.get_best_particles(1)[0] def print_run(self): best = self.run() first, second = [], [] for i in range(len(best.position)): if best.position[i] == 0: first.append(i + 1) else: second.append(i + 1) print("first: {}\nsecond: {}".format(first, second)) def run_with_plot(self): best_particles = [] num_iterations = 0 while num_iterations < self.params["iterations"]: best_particles.append( self.swarm.get_best_particles(1)[0].best_fitness) self.iteration() num_iterations += 1 return best_particles def print_plot(self): results = self.run_with_plot() matplotlib.pyplot.plot(range(1, len(results) + 1), results) matplotlib.pyplot.show() best = self.swarm.get_best_particles(1)[0] first, second = [], [] for i in range(len(best.position)): if best.position[i] == 0: first.append(i + 1) else: second.append(i + 1) print("first: {}\nsecond: {}".format(first, second)) def run_statistics(self): best_runs = [] for run in range(self.params["runs"]): print("Running %d" % (run + 1)) best_runs.append(self.run().best_fitness) with open("statistics.data", "a") as g: g.write("Average fitness: {}\n".format(statistics.mean(best_runs))) g.write("Standard deviation of fitness: {}\n\n".format( statistics.stdev(best_runs)))
def init_swarms(number_swarms: int, function: Callable[[np.ndarray], float]): return [Swarm(Const.N_PARTICLES, function) for _ in range(number_swarms)]
def __init__(self, problem): self.problem = problem self.params = {} self.load_parameters() self.swarm = Swarm(self.params["swarmSize"], len(self.problem.data.set))
class Controller: def __init__(self, problemFile, paramFile, toBe=False): self._problem = Problem(problemFile) self._dimParticle = len(self._problem.getVertices()) self._noPopulation, self._sizeOfNeighborhood, self._w, self._c1, self._c2 = 0, 0, 0, 0, 0 self.loadParameters(paramFile) self._population = Swarm(self._noPopulation, self._dimParticle, self._problem) self._neighborhoods = self.selectNeighbors() self._toBeDrawn = toBe def getPopulation(self): return self._population def setPopulation(self): return self._population def selectNeighbors(self): pop = self._population nSize = self._sizeOfNeighborhood if (nSize > len(pop)): nSize = len(pop) # Attention if nSize==len(pop) this selection is not a propper one # use a different approach (like surfle to form a permutation) neighbors = [] for i in range(len(pop)): localNeighbor = [] for j in range(nSize): x = randint(0, len(pop) - 1) while (x in localNeighbor): x = randint(0, len(pop) - 1) localNeighbor.append(x) neighbors.append(localNeighbor.copy()) return neighbors def sigmoidFunction(self, x): return 1 / (1 + exp(-x)) def iteration(self): pop, neighbors, w, c1, c2 = self._population.getListOfParticles( ), self._neighborhoods, self._w, self._c1, self._c2 bestNeighbors = [] # determine the best neighbor for each particle for i in range(len(pop)): bestNeighbors.append(neighbors[i][0]) for j in range(1, len(neighbors[i])): if (pop[bestNeighbors[i]].fitness > pop[neighbors[i][j]].fitness): bestNeighbors[i] = neighbors[i][j] # update the velocity for each particle for i in range(len(pop)): for j in range(len(pop[0].velocity)): newVelocity = w * pop[i].velocity[j] newVelocity = newVelocity + c1 * random() * ( pop[bestNeighbors[i]].position[j] - pop[i].position[j]) newVelocity = newVelocity + c2 * random() * ( pop[i].bestPosition[j] - pop[i].position[j]) pop[i].velocity[j] = newVelocity # update the position for each particle for i in range(len(pop)): newposition = [] for j in range(len(pop[i].velocity)): if (random() >= self.sigmoidFunction(pop[i].velocity[j])): newposition.append(1) else: newposition.append(2) pop[i].position = newposition self._population.setListOfParticles(pop) return self._population def runAlgorithm(self): for i in range(self._noPopulation): self._population = self.iteration() best = 0 fitnesses = [] P = self._population.getListOfParticles() for i in range(0, len(self._population)): fitnesses.append(P[i].fitness) if (P[i].fitness < P[best].fitness): best = i if self._toBeDrawn: pyp.plot(fitnesses) pyp.show() print('The best particle has: \n' + str(P[best]) + 'Fitness = ' + str(P[best].fitness) + '\n') def loadParameters(self, paramFile): f = open(paramFile) line = f.readline().split() self._noPopulation, self._sizeOfNeighborhood, self._w, self._c1, self._c2 = \ int(line[0]), int(line[1]), float(line[2]), float(line[3]), float(line[4]) f.close()
def exploitation(self): print "EXPLOITATION" # Finish exploration by updating the regressor # We don't want to get EI self._regressor.set_EI_bool(False) seed_position = [] fitness_seed_position = [] # Determine the number of parallel optimization to perform on already evaluated position if len(self._list_real_evaluation_position) <= 10: # Number of parallel optimization = number of real evaluation. seed_position.extend(self._list_real_evaluation_position) fitness_seed_position.extend(self._list_real_evaluation_fitness) else: # Create 10 parallel optimization with seed on the 10 best points found. # Get the 3 best positions and chose randomly 7 other points # Start by partially sorting the array to get the best 3 points index_partially_sorted = np.argpartition(a=self._list_real_evaluation_fitness, kth=3)[0:3] seed_position = self._list_real_evaluation_position[index_partially_sorted] fitness_seed_position = self._list_real_evaluation_fitness[index_partially_sorted] # Add randomly 7 positions different from the 3 positions already selected index_range = range(len(self._list_real_evaluation_fitness)) # remove the already selected values for i in index_partially_sorted: index_range.remove(i) choices = np.random.choice(index_range, 7, replace=False) seed_position.extend(self._list_real_evaluation_position[choices]) fitness_seed_position.extend(self._list_real_evaluation_position[choices]) # Reduce the number of creatures per swarms so that the sum of all the creatures in all of the swarms # Are equivalent to when we are in exploration mode. size_of_swarm = int(self._swarm_size / len(seed_position)) swarms = [] limit = math.pi/10.0 normalized_list_real_evaluation = np.array(self._list_real_evaluation_position)/np.array(self._bound_distance) fitness_list = np.array(self._list_real_evaluation_fitness) # Calculate the std of the fitness fitness_std = np.std(fitness_list) # If the std is very small (close to machine error), then the fitness information is basically uniform. # This mean it's useless to try to exploite this area. Launch and exploration phase instead. if fitness_std < np.finfo(float).eps*10: return self.exploration() # Get the sorted list from biggest value to smallest of the position fitness. sorted_fitness_list = np.flipud(np.sort(fitness_list)) for position, fitness_position in zip(seed_position, fitness_seed_position): # We need to set the upper and lower bound in function of the seed point for this swarm and the variance # of the gaussian process. normalized_position = np.array(np.array(position)/self._bound_distance) ''' # old way difference_between_position_and_points_to_avoid = normalized_list_real_evaluation - normalized_position distance_normalized_position_other_points = np.apply_along_axis( np.linalg.norm, axis=1, arr=difference_between_position_and_points_to_avoid) closest_point = np.argmin(distance_normalized_position_other_points) closesness_factor = 0.5 difference_vector = closest_point-position if fitness_position == sorted_fitness_list[0]: mean = abs(sorted_fitness_list[0]-sorted_fitness_list[1]) else: mean = 1.0 ''' # Bounding box is defined as when the std of the gaussian process is equal or smaller to pi/10.0*fitness_std # around the current position considered. However, since we cannot know analytically the std of the GP, # we have to use another way to actually define the measurement of the bounding box. # To do so, we check the closest known position with a real fitness to the creature we're working on right # now (i.e. identified by the name position). We then trace a segment between those two points and check # in the middle of this segment if the std of the GP is above or below our threshold. # If it's below: take half the original segment and call it L. We add L to the current segment and verify # the GP std. We keep increasing the segment by L until the GP std become bigger than our threshold. This is # our new boundary # If it's above: We divide by sqrt(2) the length of the segment and we check again. We keep repeating that # process until we get a value that is below the researched threshold. This is our new bounding box. # First, find the closest point by calculating the distance between the current position and all the others # with known fitness and get the min index = 0 min_distance = float('Inf') min_distance_index = 0 print normalized_list_real_evaluation print normalized_position for point in normalized_list_real_evaluation: if np.array_equal(normalized_position, point) == False: distance = np.linalg.norm(normalized_position-point) if distance < min_distance: min_distance = distance min_distance_index = index index += 1 closest_point = normalized_list_real_evaluation[min_distance_index] print normalized_list_real_evaluation # Now that we have the closest point, calculate the middle point between the closest point and the # considered position middle_point = (normalized_position+closest_point)/2. # Get the variance in the GP of this point prediction, gp_std = self._regressor.get_estimation_fitness_value(middle_point) max_std = (2.0*math.pi)/10. if gp_std > max_std: # get a smaller and smaller segment until we find a point that is within our boundary new_segment = np.array(middle_point-normalized_position) shrinking_factor = 1.0 while gp_std > max_std: point_to_evaluate = np.array(normalized_position) + (shrinking_factor*new_segment) prediction, gp_std = self._regressor.get_estimation_fitness_value(point_to_evaluate * np.array(self._bound_distance)) shrinking_factor /= math.sqrt(2) else: # get a bigger and bigger segment that grow with the length of the middle point each time # calculate the segment to add each time segment_to_add = (np.array(middle_point)-np.array(normalized_position))/2.0 new_segment = np.array(middle_point) while gp_std < max_std: new_segment += np.array(segment_to_add) prediction, gp_std = self._regressor.get_estimation_fitness_value(new_segment * np.array(self._bound_distance)) # Now that the new segment is calculated. We simply get the distance between the position we're interested # in and this point we just found (new_segment) distance_bound = np.linalg.norm(new_segment-normalized_position) # Take care of the curse of dimensionality distance_bound /= math.pow(math.sqrt(2), self._number_of_dimensions-1) # Unormalize distance_bound *= self._bound_distance # We create an array with the same dimension as the function dimension. We have to provide an upper bound # and a lower bound which will both have a distance of the norm we just calculated (distance_bound) upper_bound_exploitation = position + (distance_bound * np.ones(self._number_of_dimensions)) lower_bound_exploitation = position - (distance_bound * np.ones(self._number_of_dimensions)) swarm_to_add = Swarm(swarm_size=size_of_swarm, number_of_dimensions=self._number_of_dimensions, lower_bound=lower_bound_exploitation, upper_bound=upper_bound_exploitation, random=self._random) swarms.append(swarm_to_add) self._regressor.train_regressor(self._list_real_evaluation_position, self._list_real_evaluation_fitness) return 0.0
if __name__ == "__main__": name = "Power2" numberOfSwarm = 50 firstObjective = Objective("X2", [0], X2) secondObjective = Objective("X2_reverse", [1], X2_reverse) objectiveFunction = [firstObjective, secondObjective] numOfFeature = 2 featureRange = ( (-100, 100), (-100, 100), ) numberOfIter = 150 q = 2 swarm = Swarm(name=name, numberOfSwarm=numberOfSwarm, objectiveFunction=objectiveFunction, numOfFeature=numOfFeature, featureRange=featureRange, numberOfIter=numberOfIter, q=q) swarm.initialize() swarm.optimize() swarm.chartHistories() print(swarm.archive[0])
#!/usr/bin/python from Demo import Demo from Swarm import Swarm from Taxi import Taxi swarm= Swarm(count=24) demo= Demo(swarm) while demo.is_open: demo.draw(Taxi(swarm)) if not demo.paused: swarm.move(demo.step)
from Swarm import Swarm import time import logging # Configure a logging level logging.basicConfig(format='%(levelname)s:%(message)s', level=logging.DEBUG) swarm = Swarm() init_time = time.time() swarm.start_mission([0, 1]) # Test of sending commands # You can comment this block for i in range(500): swarm.simultaneous_control_egalitarian_actions([0, 1], "speed?") swarm.simultaneous_control_egalitarian_actions([0, 1], "battery?") swarm.simultaneous_control_egalitarian_actions([0, 1], "time?") swarm.simultaneous_control_egalitarian_actions([0, 1], "height?") swarm.simultaneous_control_egalitarian_actions([0, 1], "temp?") swarm.simultaneous_control_egalitarian_actions([0, 1], "attitude?") swarm.simultaneous_control_egalitarian_actions([0, 1], "baro?") swarm.simultaneous_control_egalitarian_actions([0, 1], "acceleration?") swarm.simultaneous_control_egalitarian_actions([0, 1], "tof?") swarm.simultaneous_control_egalitarian_actions([0, 1], "wifi?") swarm.simultaneous_control_egalitarian_actions([0, 1], "sdk?") swarm.simultaneous_control_egalitarian_actions([0, 1], "sn?") # Example swarm.simultaneous_control_egalitarian_actions([0, 1], "speed 50")
def train_60_func(table=train_60, max_x=15, pop=300, gen=500): swarm_app_start_md = Swarm(min_x=0, max_x=max_x, n=2, population=pop, generations=gen, table=table, flag_choice=1, plt_name='strat_60_md') swarm_app_start_md.start() swarm_app_start_mmre = Swarm(min_x=0, max_x=max_x, n=2, population=pop, generations=gen, table=table, flag_choice=2, plt_name='strat_60_mmre') swarm_app_start_mmre.start() swarm_app_start_rms = Swarm(min_x=0, max_x=max_x, n=2, population=pop, generations=gen, table=table, flag_choice=3, plt_name='strat_60_rms') swarm_app_start_rms.start() swarm_app_start_ed = Swarm(min_x=0, max_x=max_x, n=2, population=pop, generations=gen, table=table, flag_choice=4, plt_name='strat_60_ed') swarm_app_start_ed.start()
from Swarm import Swarm import matplotlib.pyplot as plt c1 = 1.4944 c2 = 1.4944 popSize = 64 swarm1 = Swarm(popSize, c1, c2) swarm2 = Swarm(popSize, c1, c2) swarm3 = Swarm(popSize, c1, c2) swarm1.runBasic() swarm2.runBasic() swarm3.runBasic() print(swarm1.bestSolValue, swarm1.bestSol) print(swarm2.bestSolValue, swarm2.bestSol) print(swarm3.bestSolValue, swarm3.bestSol) gens = [i for i in range(1, swarm1.iter+1)] fig, (a1, a2) = plt.subplots(2) a1.plot(gens, swarm1.bestPerGen, 'r-', gens, swarm2.bestPerGen, 'g-', gens, swarm3.bestPerGen, 'b-') a2.plot(gens, swarm1.averagePerGen, 'r-', gens, swarm2.averagePerGen, 'g-', gens, swarm3.averagePerGen, 'b-') #plt.plot(gens, swarm1.bestPerGen, 'r-', gens, swarm2.bestPerGen, 'g-', gens, swarm3.bestPerGen, 'b-') #a1.ylabel("Fitness of best particle in generation") #a2.ylabel("Average fitness of population") plt.xlabel("Generation #") #plt.title("Best solution per generation vs. Generation #") plt.show()