class Controller: def __init__(self, problem): self.load_params() self._swarm = Swarm(self._num_particles, problem) def iteration(self, problem): best_particle = self._swarm.get_best_particle(problem) for particle in self._swarm: # best_particle = self._swarm.get_best_neighbour(particle, problem) particle.update(best_particle, self._w, self._c1, self._c2) particle.evaluate(problem) def run(self, problem): for i in range(self._num_iterations): self.iteration(problem) def best_particle(self, problem): return self._swarm.get_best_particle(problem) def load_params(self): f = open("params.in") self._num_particles = int(f.readline()) self._num_iterations = int(f.readline()) self._w = float(f.readline()) self._c1 = float(f.readline()) self._c2 = float(f.readline())
def __init__(self): super(MainWindow, self).__init__() self.swarm = Swarm() self.ui = Ui_MainWindow() self.ui.setupUi(self) self.ui.agregar_final_pushButton.clicked.connect(self.click_agregar) self.ui.agregar_inicio_pushButton.clicked.connect( self.click_agregar_inicio) self.ui.mostrar_pushButton.clicked.connect(self.click_mostrar) self.ui.actionAbrir.triggered.connect(self.action_abrir_archivo) self.ui.actionGuardar.triggered.connect(self.action_guardar_archivo) self.ui.ver_grafos_action.triggered.connect(self.grafos) self.ui.actionBusqueda.triggered.connect(self.busqueda_grafos) self.ui.actionId.triggered.connect(self.action_ordenar_id) self.ui.actionDistancia.triggered.connect( self.action_ordenar_distancia) self.ui.actionVelocidad.triggered.connect( self.action_ordenar_velocidad) self.ui.mostrar_tabla_pushButton.clicked.connect(self.mostrar_tabla) self.ui.buscar_pushButton.clicked.connect(self.buscar_iid) self.ui.dibujar_pushButton.clicked.connect(self.dibujar) self.ui.limpiar_pushButton.clicked.connect(self.limpiar) self.scene = QGraphicsScene() self.ui.graphicsView.setScene(self.scene)
def fitness(particle_position): """ Use particle position as parameters for PSO settings, return similarity of resultant model to Rohde et al. experimental data. Expects 6-dimensional search space. """ global fit_count # Constants: dimensions = 3 group_size = 2 no_groups = 100 iterations, particle_settings = get_parameters(particle_position) particle_settings['respect_boundaries'] = True scores = [] # run psos with these params for i, experiment in enumerate(ROHDE_EXPERIMENTS): # TODO: parallelize print ' ', fit_count, i, '\b' * 100, swarm = Swarm(dimensions, group_size, no_groups, **particle_settings) for groups in swarm.step_until(experiment.game, max_iterations=iterations, return_groups=True): pass scores.append(experiment.difference(get_coordination_results(groups))) fit_count += 1 return -1 * sum(scores) / float(len(scores))
def load_data(self, filename): # do a read from file self.c1 = 1 self.c2 = 2 self.population_size = 40 self.max_iterations = 40 self.population = Swarm(self.population_size, self.intersection)
def add_peer_to_swarm(self, peer, resource_id, swarm=None): """ TODO: implement this method Based on the resource_id provided, iterate over the swarms list, and when resource_id matchs, add the new peer to the swarm. :param peer: (peer_ip, peer_port) :param resource_id: :return: VOID """ print(f"Adding peer to {resource_id} swarm") swarm = swarm or self._get_swarm_object(resource_id) if not swarm: swarm = Swarm(resource_id) self.add_swarm(swarm) # avoid dups if not self.peer_in_swarm(peer, swarm): if swarm.size() < self.MAX_PEERS: swarm.add_peer(peer) else: # too many peers, print(f"Too many peers in {swarm.resource_id}") return None # self.make_persistent() return True
def test_get_closest_particle(): positions = ([ [-6,0,0], [-4,0,0], [-2,0,0], [3,0,0], ]) velocities = ([ [3,0,0], [2,0,0], [1,0,0], [-1,0,0], ]) accelerations = ([ [0,0,0], [0,0,0], [0,0,0], [0,0,0], ]) s = Swarm(positions, velocities, accelerations) s.run(10) assert s.getRemainingParticleCount() == 1
def swarm(t, x, e, swarm_size=1000, omega=0.5): swarm = Swarm(e, swarm_size) omega, fip, fig = 0.5, 0.5, 0.5 start = time.time() while check_time(start, t): swarm.update_particles_velocity(e, omega, fip, fig)
def swarm(t, x, e, swarm_size=500, omega=0.5, fip=0.9, fig=0.9): swarm = Swarm(e, swarm_size) start = time.time() while check_time(start,t): swarm.update_particles_velocity(e, omega, fip, fig) print(swarm.best_swarm_x, swarm.best_swarm_val)
def run(self, flip, max_chance, bees_number, maxIterations, locIterations): total_time = 0 for itr in range(1, self.nb_exec + 1): print("Execution {0}".format(str(itr))) self.fsd = FsProblem(self.typeOfAlgo, self.df, self.ql) swarm = Swarm(self.fsd, flip, max_chance, bees_number, maxIterations, locIterations) t1 = time.time() best = swarm.bso(self.typeOfAlgo, flip) t2 = time.time() total_time += t2 - t1 print("Time elapsed for execution {0} : {1:.2f} s\n".format( itr, t2 - t1)) self.worksheet.write(itr, 0, itr) self.worksheet.write(itr, 1, "{0:.2f}".format(best[0])) self.worksheet.write(itr, 2, best[1]) self.worksheet.write(itr, 3, "{0:.3f}".format(t2 - t1)) self.worksheet.write( itr, 4, "{0}".format( str([j[0] for j in [i for i in swarm.best_features()]]))) self.worksheet.write(itr, 5, len(Solution.solutions)) print( "Total execution time of {0} executions \nfor dataset \"{1}\" is {2:.2f} s" .format(self.nb_exec, self.dataset_name, total_time)) self.workbook.close()
def metafitness(position, size=20, dims=10, iters=5, epochs=100, task_names=None): # unpack position vector ( w, C, S, swapping, velocities, decrease_velocity, #add_particle, replace_particle, ) = position task_names = task_names if task_names is not None else [ "rastrigin", "ackley", "sphere" ] task_errors = [] for itask, task_name in enumerate(task_names): task = fit.string_to_func[task_name] task_bounds = fit.bounds[task_name] task_best_loc = fit.actual_minimum(task_name, dims) task_best_val = task(task_best_loc) iterations_errors = [] for iter_ in range(iters): s = Swarm(size, dims, fitness=task_name, bounds=task_bounds, w=w, C=C, S=S, swapping=swapping, velocities=velocities, decrease_velocity=decrease_velocity, add_particle=0.0, replace_particle=replace_particle) result = s.Run(epochs=epochs) swarm_best_key = sorted(list(result["global_bests"].keys()))[-1] swarm_best_loc = result["global_bests"][swarm_best_key] swarm_best_val = task(swarm_best_loc) error = (task_best_val - swarm_best_val)**2 iterations_errors.append(error) avg_iterations_error = sum(iterations_errors) / len(iterations_errors) task_errors.append(avg_iterations_error) # now we have a list (per-task) of average errors. # combine *those* with an average (TODO: maybe some consistent scaling?) # this is our final "meta"-fitness we are trying to optimize. avg_task_error = sum(task_errors) / len(task_errors) return avg_task_error
def swarm(t, x, e, swarm_size=100, omega=0.8, fip=1.4, fig=1.3): swarm = Swarm(e, swarm_size) start = time.time() while check_time(start, t): swarm.update_particles_velocity(e, omega, fip, fig) print(swarm.best_swarm_x, swarm.best_swarm_val) sys.stdout.write(str(swarm.best_swarm_val) + " " + str(swarm.best_swarm_x))
def reset(self): """ resets the map and the robots for iterative testing/benchmarking """ self.grid = GridGraph(self.grid_size) self.swarm = Swarm(self.num_robots) self.swarm.startup_sequence(self.grid.list_of_vertices[0])
def __init__(self, intersection): self.c1 = 1 self.c2 = 2 self.intersection = "" self.max_iterations = 0 self.population_size = 0 self.load_data("mock file name") self.population = Swarm(self.c1, self.c2, self.population_size, intersection)
def runAlg(self): count = 0 s = Swarm(40, 5, 5) while s.bestGlobal > 0.000000001: count += 1 for particle in s.particles: particle.calFitness() s.getBestParticle() for particle in s.particles: particle.evaluate(s.bestGlobalX, s.bestGlobalY, s.c1, s.c2) print("Fount in " + str(count) + " moves")
def test_GUI(): swarm = [[0, 10, 6, 5, 11, 4], [0, 3, 9, 1, 8, 7], [0, 0, 0, 0, 2, 0], [0, 0, 0, 0, 0, 0]] swarm = np.array(swarm) shape = [[0, 0, 1, 1, 1], [0, 0, 1, 0, 0], [0, 0, 1, 1, 1], [0, 0, 1, 0, 0], [0, 0, 1, 1, 1]] shape = np.array(shape) S = Swarm(11, swarm) S.main_sequence(shape, 100, 100, 50) print(S.moves_sequence) return instructions_to_GUI(6, S, S.moves_sequence)
class MainGame: def __init__(self): config = pyglet.gl.Config(major_version=2, minor_version=1) self.window = pyglet.window.Window(config=config, width=WIDTH, height=HEIGHT, resizable=False, vsync=True) #print(self.window.context.get_info().get_renderer()) #print(self.window.context.get_info().get_vendor()) #print('OpenGL Version {}'.format(self.window.context.get_info().get_version())) # start the background music #music = pyglet.resource.media('music.mp3') #music.play() # manage keys self.keys = key.KeyStateHandler() self.window.push_handlers(self.keys) # init objects self.camera = Camera(WIDTH, HEIGHT) self.player = Player() self.player.Translate(WIDTH/2 - (BLOCK_SIZE * 10)/2, HEIGHT - (BLOCK_SIZE * 10), 0.0) #self.enemy = Enemy() #self.enemy.Translate(WIDTH/2 - (BLOCK_SIZE * 10)/2, HEIGHT/2 - (BLOCK_SIZE * 10), 0.0) self.swarm = Swarm() # setup function calls self.window.on_draw = self.on_draw self.window.on_mouse_press = self.on_mouse_press self.window.on_mouse_motion = self.on_mouse_motion pyglet.clock.schedule_interval(self.update, 1/60.0) # update at 60Hz def on_draw(self): glViewport(0, 0, WIDTH, HEIGHT) glClearColor(0.114, 0.114, 0.114, 1.0) #1d1d1d glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) self.player.render() self.swarm.render() def update(self, dt): self.player.update(dt) self.swarm.update(dt) def on_mouse_press(self, x, y, button, modifiers): if button == mouse.LEFT: self.player.fire() def on_mouse_motion(self, x, y, dx, dy): # their x and y is from bottom left # my x and y is from top left increment_x = x - self.player.position.x self.player.translate(increment_x, 0.0, 0.0)
def swarm_find_tracker(self, finfo): peer = self.peer.closest_to_peer(finfo) range_from_me = self.peer.get_range(finfo) range_from_peer = Utils.get_range(peer, finfo) if range_from_me < range_from_peer: s = Swarm(self.peer.id) s.create_tracker(s.files[finfo].fstruct) else: packet = { "datatype": "swarm", "action": "find_tracker", "finfo": finfo } self.peer.client.SendToPeer(peer, packet)
def swarm_find_tracker_red(self, finfo, source): peer = self.peer.closest_to_peer(finfo) range_from_me = self.peer.get_range(finfo) range_from_peer = Utils.get_range(peer, finfo) if range_from_me < range_from_peer: packet = {"datatype": "swarm", "action": "found_tracker"} self.peer.client.SendToPeer(source, packet) s = Swarm(self.peer.id) s.create_tracker(None) else: packet = { "datatype": "swarm", "action": "find_tracker_red", "source": source }
def __init__(self): config = pyglet.gl.Config(major_version=2, minor_version=1) self.window = pyglet.window.Window(config=config, width=WIDTH, height=HEIGHT, resizable=False, vsync=True) #print(self.window.context.get_info().get_renderer()) #print(self.window.context.get_info().get_vendor()) #print('OpenGL Version {}'.format(self.window.context.get_info().get_version())) # start the background music #music = pyglet.resource.media('music.mp3') #music.play() # manage keys self.keys = key.KeyStateHandler() self.window.push_handlers(self.keys) # init objects self.camera = Camera(WIDTH, HEIGHT) self.player = Player() self.player.Translate(WIDTH/2 - (BLOCK_SIZE * 10)/2, HEIGHT - (BLOCK_SIZE * 10), 0.0) #self.enemy = Enemy() #self.enemy.Translate(WIDTH/2 - (BLOCK_SIZE * 10)/2, HEIGHT/2 - (BLOCK_SIZE * 10), 0.0) self.swarm = Swarm() # setup function calls self.window.on_draw = self.on_draw self.window.on_mouse_press = self.on_mouse_press self.window.on_mouse_motion = self.on_mouse_motion pyglet.clock.schedule_interval(self.update, 1/60.0) # update at 60Hz
class Controller: def __init__(self, intersection): self.c1 = 1 self.c2 = 2 self.intersection = "" self.max_iterations = 0 self.population_size = 0 self.load_data("mock file name") self.population = Swarm(self.c1, self.c2, self.population_size, intersection) def load_data(self, filename): # do a read from file self.c1 = 1 self.c2 = 2 self.population_size = 40 self.max_iterations = 40 self.population = Swarm(self.population_size, self.intersection) def iteration(self): for particle in self.population.particles: particle.update(self.population.get_best_particle()) particle.evaluate() def run_alg(self): for i in range(0, self.max_iterations): self.iteration()
def swarm(t, x, e, swarm_size=1000): swarm = Swarm(e, swarm_size) start = time.time() while check_time(start,t): for particle in swarm:
def handle_state_announce(self): assert self.conn_id if self.conn_id_expires < time.time(): print timestamp(), self, "Connection ID expired" self.goto_state_conn_id() return if not self.current_swarm in [ x for x in Swarm.list() if not x.closed ]: self.goto_state_swarm() return if time.time() < self.announce_next_attempt: return retry_text = '' if self.announce_retry > 0: retry_text = ', retry %d' % self.announce_retry print timestamp(), self, "Sending announce for %s%s" % (self.current_swarm, retry_text) buf = '' buf += struct.pack('!QLL', self.conn_id, 1, self.transaction_id) buf += self.current_swarm.sha.decode('hex') buf += hashlib.sha1(Peer.my_peerid).digest() buf += struct.pack('!QQQLLLlH', 0, 0, 0, 1, 0, self.key, -1, self.listen_port) self.send(buf) self.announce_next_attempt = time.time() + config.tracker_retry_time * 2**min(self.announce_retry, 4) self.announce_retry += 1
def main(): swarm = Swarm(81, n, 5, -5, 'mesh') pso = PSO(swarm, P.Function) pso.Optmize() x = swarm.particle.bestPosition
def from_swarm_dicts(cls, swarm_dicts, inference_model, scoring_functions=None, x_min=-1., x_max=1., inertia_weight=0.9, phi1=2., phi2=2., phi3=2., **kwargs): """ Classmethod to create a PSO instance from a list of dictionaries each defining an individual swarm. :param swarm_dicts: A list of dictionaries each defining an individual swarm. See Swarm.from_dict for more info. :param inference_model: A inference model instance that is used for encoding an decoding SMILES to and from the CDDD space. :param scoring_functions: List of functions that are used to evaluate a generated molecule. Either take a RDKit mol object as input or a point in the cddd space. :param kwargs: additional parameters for the PSO class :return: A PSOptimizer instance. """ swarms = [ Swarm.from_dict(dictionary=swarm_dict, x_min=x_min, x_max=x_max, inertia_weight=inertia_weight, phi1=phi1, phi2=phi2, phi3=phi3) for swarm_dict in swarm_dicts ] return cls(swarms, inference_model, scoring_functions, **kwargs)
def run_task(t: Task): try: strategy, iterations, num_good_clients, num_free_riders, peer_size, max_up, max_down = t swarm = Swarm() all_agents = chain( (Client( strat=strategy, up=Points(max_up), down=Points(max_down), peer_size=peer_size, swarm=swarm, iterations=iterations ) for _ in range(num_good_clients)), (Client( strat=strategy, up=no_points, down=Points(max_down), peer_size=peer_size, swarm=swarm, iterations=iterations ) for _ in range(num_free_riders)) ) [swarm.join(x) for x in all_agents] OUTPUT_FILE = f"./results/{strategy.__name__}/{iterations}_{num_good_clients}_{num_free_riders}_{peer_size}_{max_up}_{max_down}.json" if not os.path.isdir(os.path.dirname(OUTPUT_FILE)): os.makedirs(os.path.dirname(OUTPUT_FILE)) with open(OUTPUT_FILE, 'w') as f: f.write(dumps( { 'metadata': { 'strategy': strategy.__name__, 'iterations': iterations, 'max_up': max_up, 'max_down': max_down, 'starting_good_clients': num_good_clients, 'starting_bad_clients': num_free_riders, 'peer_size': peer_size }, 'data': tuple( chain.from_iterable( (x.to_json(iteration) for x in y) for iteration, y in enumerate(Model.run(swarm, iterations)))) } )) except Exception as e: print("got exception ", e)
def from_query_list(cls, init_smiles, num_part, num_swarms, inference_model, scoring_functions=None, phi1=2., phi2=2., phi3=2., x_min=-1., x_max=1., v_min=-0.6, v_max=0.6, **kwargs): """ Classmethod to create a PSO instance with (possible) multiple swarms which particles are initialized at the position of the embedded input SMILES. Each swarms is initialized at the position defined by the different SMILES in the input list. :param init_smiles: A List of SMILES which each define the molecule which acts as starting point of each swarm in the optimization. :param num_part: Number of particles in each swarm. :param num_swarms: Number of individual swarm to be optimized. :param inference_model: A inference model instance that is used for encoding an decoding SMILES to and from the CDDD space. :param scoring_functions: List of functions that are used to evaluate a generated molecule. Either take a RDKit mol object as input or a point in the cddd space. :param phi1: PSO hyperparamter. :param phi2: PSO hyperparamter. :param phi3: PSO hyperparamter. :param x_min: min bound of the optimization space (should be set to -1 as its the default CDDD embeddings take values between -1 and 1). :param x_max: max bound of the optimization space (should be set to -1 as its the default CDDD embeddings take values between -1 and 1). :param v_min: minimal velocity component of a particle. Also used as lower bound for the uniform distribution used to sample the initial velocity. :param v_max: maximal velocity component of a particle. Also used as upper bound for the uniform distribution used to sample the initial velocity. :param kwargs: additional parameters for the PSO class :return: A PSOptimizer instance. """ assert isinstance(init_smiles, list) assert len(init_smiles) == num_swarms embedding = inference_model.seq_to_emb(init_smiles) swarms = [] for i, sml in enumerate(init_smiles): swarms.append( Swarm.from_query(init_sml=sml, init_emb=embedding[i], num_part=num_part, v_min=v_min, v_max=v_max, x_min=x_min, x_max=x_max, phi1=phi1, phi2=phi2, phi3=phi3)) return cls(swarms, inference_model, scoring_functions, **kwargs)
def __init__(self, function_to_be_minimized, constants): self.constants = constants self.precision = constants.PRECISION self.inertia = constants.INERTIA_WEIGHT self.cognitive = constants.COGNITIVE_WEIGHT self.social = constants.SOCIAL_WEIGHT self.max_velocity_allowed = constants.MAX_VELOCITY_ALLOWED self.pop_size = constants.POP_SIZE self.generations_no = constants.GENERATIONS_NO self.dimensions_no = constants.DIMENSIONS_OF_THE_FUNCTION self.fitness = function_to_be_minimized self.a = constants.INTERVALS_OF_DEFINITION[self.fitness.__name__][0] self.b = constants.INTERVALS_OF_DEFINITION[self.fitness.__name__][1] self.population = [] self.swarm = Swarm(self.fitness, self.precision)
def on_heartbeat(self): # Kludge for now. Just have every tracker announce every swarm for x in Swarm.list(): self.add_swarm(x) # Cleanup old swarms for x in [x for x in self.swarms.keys() if x.closed or x not in Swarm.list()]: print timestamp(), self, "Swarm seems to have gone away, removing:", x del self.swarms[x] if self.state == STATE_SOCK: self.handle_state_sock() elif self.state == STATE_SWARM: self.handle_state_swarm() elif self.state == STATE_CONN_ID: self.handle_state_conn_id() elif self.state == STATE_ANNOUNCE: self.handle_state_announce() elif self.state == STATE_MUTE: self.handle_state_mute() else: raise Exception("State machine broken?")
def main(): options, files = getopt.getopt(sys.argv[1:], 'ivt:', ['info', 'verbose', 'threads:']) for flag, value in options: if flag == '-v' or flag == '--verbose': configuration['verbose'] = True elif flag == '-t' or flag == '--threads': try: configuration['threads'] = int(value) except: usage() elif flag == '-i' or flag == '--info': configuration['info'] = True else: usage() if len(files) != 1: usage() try: torrent = Torrent(files[0]) except: print 'Impossible to read torrent file/magnet link:', files[0] exit(1) if configuration['info'] == True: torrent.show() exit(0) torrent.start() generate_clientid() tracker = Tracker(torrent.data['announce']) tracker.update(torrent) swarm = Swarm() swarm.update_peers(tracker) threads = configuration['threads']
def test_get_closest_particle(): positions = ([ [3, 0, 0], [4, 0, 0], ]) velocities = ([ [2, 0, 0], [0, 0, 0], ]) accelerations = ([ [-1, 0, 0], [-2, 0, 0], ]) s = Swarm(positions, velocities, accelerations) s.run(10) assert s.getClosestParticleIndex() == 0
def main(): positions = [] velocities = [] accelerations = [] line = f.readline() while line: m = re.search('p=<(.*)>, v=<(.*)>, a=<(.*)>', line.rstrip('\n')) pStrings = m.group(1).split(',') vStrings = m.group(2).split(',') aStrings = m.group(3).split(',') positions.append([int(pStrings[0]), int(pStrings[1]), int(pStrings[2])]) velocities.append([int(vStrings[0]), int(vStrings[1]), int(vStrings[2])]) accelerations.append([int(aStrings[0]), int(aStrings[1]), int(aStrings[2])]) line = f.readline() s = Swarm(positions, velocities, accelerations) s.run(1000) print(s.getRemainingParticleCount())
def pso(self, w=0.45, c1=1.70, c2=2.49): time_to_end = time.time() + self.t # C₁ importance of personal best value # C₂ importance of social best value. # w meaning of velocity vector swarm = Swarm(self.SWARM_SIZE, self.VECTOR_SIZE, self.params, w, c1, c2) while time.time() < time_to_end: swarm.update_swarm() swarm.set_best_particle() #print(swarm.best_particle) #print("#BEST", swarm.best_particle) return swarm.best_particle
def main(): metaswarm = Swarm(size=25, dims=len(meta_params), fitness="sphere", bounds=(0.0, 1.0)) metaswarm.fitnessFunc = metafitness metaswarm._fitnessString = "metafitness" metaswarm.CheckConvergence = _dummy_false results = metaswarm.Run(100) results.save_json("metaswarm_output.json") best_settings_key = sorted(list(results["global_bests"].keys()))[-1] best_settings = results["global_bests"][best_settings_key] for setting, value in zip(meta_params, best_settings): print(f"{setting}\t{value}")
class Main(object): """ the Main running class, mainly used for running the algorithm for accuracy and for benchmarking its efficiency. visualization.py was used for actual visualization """ def __init__(self, grid_size, num_robots): self.grid_size, self.num_robots = grid_size, num_robots self.grid = GridGraph(self.grid_size) self.swarm = Swarm(self.num_robots) self.swarm.startup_sequence(self.grid.list_of_vertices[0]) def reset(self): """ resets the map and the robots for iterative testing/benchmarking """ self.grid = GridGraph(self.grid_size) self.swarm = Swarm(self.num_robots) self.swarm.startup_sequence(self.grid.list_of_vertices[0]) def run(self): """ runs the algorithms until complete, and keeps track of the number of times it calls update, which is considered our benchmark """ profile = 0 while not (all([ True if robot.state == "standby" else False for robot in self.swarm.swarm ]) and (not [ area for area in self.swarm.unknown_territory if area.state == "red" ])): self.swarm.update() profile += 1 # makes sure that the map we made is correct to the environment's map actual_graph = { vertex.name: {neighbor.name for neighbor in vertex.neighbors} for vertex in self.grid.list_of_vertices } if actual_graph == self.swarm.map: return profile else: raise ValueError("You done g00fed")
def startSwarm(self, size = None): ''' Runs permutations on model parameters to find the optimal model characteristics for the given data. * size - A value from grokpy.SwarmSize. Initially, small, medium, or large. the default is medium. Small is only good for testing, whereas large can take a very long time. ''' if self.swarm and self.swarm.getState() in ['Starting', 'Running']: raise GrokError('This model is already swarming.') url = self.swarmsUrl requestDef = {} if size: requestDef.update({'options': {"size": size}}) result = self.c.request('POST', url, requestDef) # Save the swarm object self.swarm = Swarm(self, result['swarm']) return result
def __init__(self): #Start Pygame pygame.init() pygame.display.set_caption('Graph Exploration') #Create Pygame variables self.clock = pygame.time.Clock() self.sizex = 700 self.sizey = 700 self.imgCounter = 0 self.font = pygame.font.SysFont('Roboto', 25) self.background_color = (227, 232, 239) self.robot_color = (83, 87, 94) self.edge_color = (83, 87, 94) self.state_to_color_mapping = { 'red': pygame.Color('red'), 'yellow': pygame.Color('yellow'), 'green': pygame.Color('green') } self.screen = pygame.display.set_mode((self.sizex, self.sizey)) self.background = pygame.Surface((self.sizex, self.sizey)) #Create Grid for robots to walk on self.grid = TripleGraph() #Create swarm of robots self.swarm = Swarm(2) self.swarm.startup_sequence(self.grid.list_of_vertices[0]) self.old_vertices = None swarm = Swarm(3) swarm.startup_sequence(self.grid.list_of_vertices[0]) #Set Main loop to running self._running = True #Draw graph into window self.background.fill(self.background_color) self.space_out_vertices(self.grid) self.draw_grid() pygame.draw.circle(self.background, self.robot_color, self.swarm.hive.coords, 15, 3) self.screen.blit(self.background, (0, 0)) pygame.display.update() sleep(1)
def run(swarm: Swarm, iterations: int) -> Iterator[Iterator[Result]]: all_agents = list(swarm.all_clients()) [x.init_peers() for x in all_agents] for c in range(iterations): print("Iteration", c) do_assertions(all_agents) remaining_agents = set(all_agents) while remaining_agents: # filter out the ones that don't want content remaining_agents -= {x for x in all_agents if not x.wants_content()} # Iterate in random order for agent in random_iteration(remaining_agents): # Iterate all peers of that agent in random order for peer in random_iteration(agent.peers): if peer.ask_for_content(agent): # If they gave us content agent.give_content(peer) break else: # None of the peers gave them something remaining_agents.remove(agent) yield (x.get_state() for x in all_agents) [x.reset_values() for x in all_agents] do_assertions(all_agents) # Find new peers print("--before--") [x.before_reset() for x in random_iteration(all_agents)] print("--reset--") [x.reset(c) for x in random_iteration(all_agents)] print("--after--") [x.after_reset(c) for x in random_iteration(all_agents)] do_assertions(all_agents)
"respect_boundaries" ] = True # Actually seems to track more closely without this, just at much lower (1/10th) rates # particle_settings['initial_inertia'] = 0.00019464380975982382 # Brennan & Clark 1996 graph = False if graph: from matplotlib import pyplot as pl from matplotlib import animation from mpl_toolkits.mplot3d import Axes3D for i, experiment in enumerate(parameter_estimation.ROHDE_EXPERIMENTS): fig = pl.figure() ax = fig.add_subplot(111, projection="3d") # pl.axis([-0.05, 1.05,] * dimensions) swarm = Swarm(dimensions, group_size, no_groups, **particle_settings) # plot = pl.scatter(*zip(*[particle.position for particle in swarm.step(experiment.game)]), alpha=0.2) plot = pl.scatter(*zip(*[particle.position for particle in swarm.step(experiment.game)])) anim = animation.FuncAnimation( fig, update_plot, frames=xrange(iterations), fargs=(swarm, plot, experiment.game) ) pl.show() else: # new_experiments = [ # Experiment( # free ambiguous form # Experiment.Settings( # reference_costs=(-60., -120., -280.), # ambiguous_reference_cost=-0.,
if __name__ == '__main__': output_location = r'I:\Users\Chase Stevens\Dropbox\Dissertation\swarm_state.json' iterations = 10000 dimensions = 6 group_size = 100 no_groups = 1 save = True graph = False if os.path.exists(output_location): with open(output_location, 'r') as f: swarm = Swarm.from_dict(json.load(f)) print "Loaded swarm - resuming from iteration", swarm.particles[0]._time print "(Loaded", len(swarm.particles), "particles into", len(swarm.particle_groups), "groups)" else: swarm = Swarm( dimensions, group_size, no_groups, particle_distribution=parameter_estimation.mitchell_sampling_factory(dimensions), ) fitness_func = parameter_estimation.fitness if graph: from matplotlib import pyplot as pl from matplotlib import animation
class Model(object): ''' Object representing a Grok Model. * parent - **Either** a `Client` or `Project`. * modelDef - A dict, usually returned from a model creation or get action. Usually includes: * id * name * streamId * swarmsUrl * url ''' def __init__(self, parent, modelDef): # Give streams access to the parent client/project and its connection self.parent = parent self.c = self.parent.c # Take everything we're passed and make it an instance property. self.__dict__.update(modelDef) # Prepare to have a swarm associated with the model self.swarm = None def _runCommand(self, command, **params): url = self.commandsUrl commandObject = {'command': command} if params: commandObject['params'] = params result = self.c.request('POST', url, commandObject) return result def delete(self): ''' Permanently deletes the model .. warning:: There is currently no way to recover from this opperation. ''' self.c.request('DELETE', self.url) def clone(self, params = None): ''' Clones this model ''' if params: result = self.c.request('POST', self.cloneUrl, {'model': params}) else: result = self.c.request('POST', self.cloneUrl) return Model(self.parent, result['model']) ############################################################################# # Model Configuration def setName(self, newName): ''' Renames the model. * newName - String ''' # Get the current model state modelDef = self.getState() # Update the definition modelDef['name'] = newName # Update remote state self.c.request('POST', self.url, {'model': modelDef}) # Update local state self.name = newName def setNote(self, newNote): ''' Adds or updates a note for this model. * newNote - A String describing this model. ''' # Get the current model state modelDef = self.getState() # Update the definition modelDef['note'] = newNote # Update remote state self.c.request('POST', self.url, {'model': modelDef}) # Update local state self.note = newNote ############################################################################# # Model states def getState(self): ''' Returns the full state of the model from the API server TODO: Remove popping of Nones once API is updated ''' modelDef = self.c.request('GET', self.url)['model'] # API doesn't except None values. Remove them. for key, value in modelDef.items(): if value is None: del modelDef[key] return modelDef def promote(self, **params): ''' Puts the model into a production ready mode. .. note: This may take several seconds. ''' # Check how many records are in the swarm model output cache headers, data, meta = self.getModelOutput() swarmOutputCacheLen = len(data) # Promotion command self._runCommand('promote', **params) ##### WARNING: Ugly hack that will go away ##### # Check if the state of the model changes timeoutCounter = 0 while True: modelDef = self.c.request('GET', self.url)['model'] status = modelDef['status'] if timeoutCounter >= 20: raise GrokError('The production model did not start in a reasonable ' 'amount of time. Please try again or contact support.') elif status == 'running': # The production model has turned on break else: print 'Waiting for the production model to become ready ...' time.sleep(.5) timeoutCounter += 1 # Check that the production model has at least caught up to where we were # at the end of swarm. timeoutCounter = 0 while True: # Production Model Output Cache Length try: headers, data, meta = self.getModelOutput() pmocLen = len(data) except requests.exceptions.HTTPError: print 'Whoops 500' time.sleep(.5) timeoutCounter += 1 continue if timeoutCounter >= 80: raise GrokError("The production model did not catch up to the swarm " "in a reasonable amount of time. Please try again or " "contact support.") elif pmocLen >= swarmOutputCacheLen: break else: print 'Waiting for the production model to catch up with the data ...' time.sleep(1) timeoutCounter += 1 ##### END UGLY HACK def start(self, **params): ''' Starts up a model, readying it to receive new data from a stream ''' return self._runCommand('start', **params) def disableLearning(self, **params): ''' Puts the model into a predictions only state where it will not learn from new data. .. note:: This method is intended for use with RUNNING models that have been promoted. The API server will return an error in other cases. ''' return self._runCommand('disableLearning', **params) def enableLearning(self, **params): ''' New records will be integrated into the models future predictions. .. note:: This method is intended for use with RUNNING models that have been promoted. The API server will return an error in other cases. ''' return self._runCommand('enableLearning', **params) def setAnomalyAutoDetectThreshold(self, autoDetectThreshold): ''' Sets the autoDetectThreshold of the model. Model must be TemporalAnomaly for this to succeed. * autoDetectThreshold - value to set the auto detect threshold .. note:: This method is intended for use with RUNNING models that have been promoted. The API server will return an error in other cases. ''' return self._runCommand('setAutoDetectThreshold', \ autoDetectThreshold=autoDetectThreshold) def getAnomalyAutoDetectWaitRecords(self): ''' Gets the autoDetectWaitRecords of the model. Model must be TemporalAnomaly for this to succeed. Response on success:: { 'autoDetectWaitRecords': integer } .. note:: This method is intended for use with RUNNING models that have been promoted. The API server will return an error in other cases. ''' return self._runCommand('getAutoDetectWaitRecords') def setAnomalyAutoDetectWaitRecords(self, autoDetectWaitRecords): ''' Sets the autoDetectWaitRecords of the model. Model must be TemporalAnomaly for this to succeed. * autoDetectWaitRecords - value to set the auto detect wait records .. note:: This method is intended for use with RUNNING models that have been promoted. The API server will return an error in other cases. ''' return self._runCommand('setAutoDetectWaitRecords', \ autoDetectWaitRecords=autoDetectWaitRecords) def getAnomalyAutoDetectThreshold(self): ''' Gets the autoDetectThreshold of the model. Model must be TemporalAnomaly for this to succeed. Response on success:: { 'autoDetectThreshold': float } .. note:: This method is intended for use with RUNNING models that have been promoted. The API server will return an error in other cases. ''' return self._runCommand('getAutoDetectThreshold') def getLabels(self, startRecordID=None, endRecordID=None): ''' Returns a list of labels for a given range of records. Each record has a list of labels assocciated. A label may have no labels. * startRecordID - ROWID of the first prediction of these label results * endRecordID - ROWID of the last prediction record of these label results. (Not inclusive.) Response on success:: { 'isProcessing': boolean, 'recordLabels': [ { 'ROWID': integer, 'labels': [str, ...] },... ] } .. note:: This method is intended for use with RUNNING models that have been promoted. The API server will return an error in other cases. ''' return self._runCommand('getLabels', startRecordID=startRecordID, endRecordID=endRecordID) def addLabel(self, startRecordID, endRecordID, labelName): ''' Adds a label to a given range of records from startRecordID to endRecordID, not inclusive of endRecordID. * startRecordID - ROWID of the first prediction to add this label * endRecordID - ROWID of the last prediction record to add this label. (Not inclusive.) * labelName - string indicating name of the label to add to the given range Response on success:: { 'status': 'success' } .. note:: This method is intended for use with RUNNING models that have been promoted. The API server will return an error in other cases. ''' return self._runCommand('addLabel', startRecordID=startRecordID, \ endRecordID=endRecordID, labelName=labelName) def removeLabels(self, startRecordID=None, endRecordID=None, labelFilter=None): ''' Removes a label or all labels from a given range of records from startRecordID to endRecordID, not inclusive of endRecordID. If labelFilter is set, only labels of type labelFilter will be removed, otherwise all labels will be removed from the given range. * startRecordID - ROWID of the first prediction to remove labels * endRecordID - ROWID of the last prediction record to remove labels. (Not inclusive.) * labelFilter - string. If not None, only labels equal to this will be removed. Otherwise all labels will be removed from given range. Response on success:: { 'status': 'success' } .. note:: This method is intended for use with RUNNING models that have been promoted. The API server will return an error in other cases. ''' return self._runCommand('removeLabels', startRecordID=startRecordID, \ endRecordID=endRecordID, labelFilter=labelFilter) ############################################################################# # Stream def getStream(self): ''' Returns the Stream that this model is associated with. ''' return self.parent.getStream(self.streamId) ############################################################################# # Swarms def listSwarms(self): ''' Returns a list of Swarm objects for this model ''' # Where to make our request url = self.swarmsUrl swarmDefs = self.c.request('GET', url)['swarms'] swarms = [] for swarmDef in swarmDefs: swarms.append(Swarm(self, swarmDef)) return swarms def startSwarm(self, size = None): ''' Runs permutations on model parameters to find the optimal model characteristics for the given data. * size - A value from grokpy.SwarmSize. Initially, small, medium, or large. the default is medium. Small is only good for testing, whereas large can take a very long time. ''' if self.swarm and self.swarm.getState() in ['Starting', 'Running']: raise GrokError('This model is already swarming.') url = self.swarmsUrl requestDef = {} if size: requestDef.update({'options': {"size": size}}) result = self.c.request('POST', url, requestDef) # Save the swarm object self.swarm = Swarm(self, result['swarm']) return result def stop(self): ''' Stops (and checkpoints) a running model. If a swarm is in progress it will gracefully stop the swarm progress and make the model available for promotion (this can take a few seconds). ''' self._runCommand('stop') def getSwarmState(self): ''' Returns the current state of a swarm. ''' if not self.swarm: # See if the API knows about a swarm for this model swarms = self.listSwarms() if not swarms: raise GrokError('There is no swarm associated with this model.') else: # Find the latest swarm # Use the string time to sort with the latest time first # If details hasn't been populated yet, assume this is the latest swarms = sorted(swarms, key = lambda swarm: swarm.details.get('startTime', 0), reverse=True) # Set that as *the* swarm for this model self.swarm = swarms[0] return self.swarm.getState() ############################################################################# # Checkpoints def listCheckpoints(self): ''' Returns a list of checkpoint dicts for this model ''' # Where to make our request url = self.checkpointsUrl checkpoints = self.c.request('GET', url)['checkpoints'] return checkpoints def createCheckpoint(self): ''' Creates a new checkpoint object and returns it as a dict ''' # Where to make our request url = self.checkpointsUrl checkpoint = self.c.request('POST', url)['checkpoint'] return checkpoint ############################################################################# # Model data def getModelOutput(self, limit=None, offset = None, startAt = None, shift = True): ''' Returns the data in the output cache of the best model found during Swarm. * limit - The maximum number of rows to get from the model * offset - The number of rows from the last row from which to begin returning data from. For example:: If you have 1000 records in the model output cache and set offset to 100, you will get records with row ID 900 to 999. If you set offset above the maximum row ID that exists in the model's output cache you will get no records. * startAt - The start row ID to begin returning data from. For example:: If you have 1000 records in the model output cache and set startAt to 100, you will get records with row ID 100 to 1000. If you set startAt above the maximum row ID that exists in the model's output cache you will get no records. * shift - This shifts the records returned so that all predictions are aligned with actual values. Note: Set this value to False if you are working with realtime data. ''' params = {} if limit is not None: params['limit'] = limit if offset is not None: params['offset'] = offset if startAt is not None: params['startAt'] = startAt if shift is not None: params['shift'] = shift result = self.c.request('GET', self.dataUrl, params = params)['output'] headers = result['names'] data = result['data'] try: meta = result['meta'] except KeyError: meta = None return headers, data, meta
scale = numpy.array([5, 10]) plot.set_offsets(zip([particle.position * scale for particle in swarm.step(fitness_func)])) return plot, if __name__ == '__main__': iterations = 600 dimensions = 2 group_size = 50 no_groups = 50 save = True graph = True swarm = Swarm(dimensions, group_size, no_groups, respect_boundaries=False, velocity_dampening=0.2) fitness_func = lambda (x, y): -abs((y * 10) - (x * 5) ** 2) if graph: from matplotlib import pyplot as pl from matplotlib import animation fig = pl.figure() #ax = pl.axis([0, 10,] * dimensions) ax = pl.axis([0, 5, 0, 10]) plot = pl.scatter(*zip(*[particle.position for particle in swarm.step(fitness_func)])) anim = animation.FuncAnimation(fig, update_plot, frames=iterations, fargs=(swarm, plot, fitness_func)) anim.save('squares.mp4', fps=10, extra_args=['-vcodec', 'libx264'])
def main(): # Setup some basic logging logging.basicConfig() formatter = logging.Formatter('%(name)-24s: %(asctime)s : %(levelname)-8s %(message)s') logger = logging.getLogger() logger.handlers[0].setFormatter(formatter) # Callback for showing statistics def log_stats(data): sideband = 'USB' auto_amps = {} for baseline in data.baselines: if baseline.is_valid(): chunk = baseline.left._chk interleaved = array(list(p for p in data[baseline][chunk][sideband] if not isnan(p))) complex_data = interleaved[0::2] + 1j * interleaved[1::2] if baseline.is_auto(): auto_amps[baseline] = abs(complex_data).mean() norm = auto_amps[baseline] else: norm_left = auto_amps[SwarmBaseline(baseline.left, baseline.left)] norm_right = auto_amps[SwarmBaseline(baseline.right, baseline.right)] norm = sqrt(norm_left * norm_right) logger.info( '{baseline!s}[chunk={chunk}].{sideband} : Amp={amp:.4e}, Phase={pha:+.2e}, Corr.={corr:5.2f}%'.format( baseline=baseline, chunk=chunk, sideband=sideband, corr=100.0*abs(complex_data).mean()/norm, pha=angle(complex_data).mean(), amp=abs(complex_data).mean() ) ) # Callback for saving raw data def save_rawdata(rawdata): for fid, datas in enumerate(rawdata): filename = 'fid%d.dat' % fid save_bin(filename, datas) logger.info('Data for FID #%d saved to %r' % (fid, filename)) # Callback for checking ramp def check_ramp(rawdata): ramp = empty(SWARM_VISIBS_ACC_SIZE) for fid, datas in enumerate(rawdata): raw = array(unpack('>%dI'%SWARM_VISIBS_ACC_SIZE, datas)) ramp[0::2] = raw[1::2] ramp[1::2] = raw[0::2] errors_ind = list(i for i, p in enumerate(ramp) if p !=i) logger.info('Ramp errors for FID #%d: %d' % (fid, len(errors_ind))) # Parse the user's command line arguments parser = argparse.ArgumentParser(description='Catch and process visibility data from a set of SWARM ROACH2s') parser.add_argument('-v', dest='verbose', action='store_true', help='display debugging logs') parser.add_argument('-m', '--swarm-mapping', dest='swarm_mapping', metavar='SWARM_MAPPING', type=str, default=SWARM_MAPPING, help='Use file SWARM_MAPPING to determine the SWARM input to IF mapping (default="%s")' % SWARM_MAPPING) parser.add_argument('-i', '--interface', dest='interface', metavar='INTERFACE', type=str, default='eth2', help='listen for UDP data on INTERFACE (default="eth2")') parser.add_argument('-b', '--bitcode', dest='bitcode', metavar='BITCODE', type=str, default=DEFAULT_BITCODE, help='program ROACH2s with BITCODE (default="%s")' % DEFAULT_BITCODE) parser.add_argument('-t', '--integrate-for', dest='itime', metavar='INTEGRATION-TIME', type=float, default=30.0, help='integrate for approximately INTEGRATION-TIME seconds (default=30)') parser.add_argument('--setup-only', dest='setup_only', action='store_true', help='only program and setup the board; do not wait for data') parser.add_argument('--listen-only', dest='listen_only', action='store_true', help='do NOT setup the board; only wait for data') parser.add_argument('--visibs-test', dest='visibs_test', action='store_true', help='enable the DDR3 visibility ramp test') parser.add_argument('--save-raw-data', dest='save_rawdata', action='store_true', help='Save raw data from each FID to file') parser.add_argument('--log-stats', dest='log_stats', action='store_true', help='Print out some baselines statistics (NOTE: very slow!)') args = parser.parse_args() # Set logging level given verbosity if args.verbose: logger.setLevel(logging.DEBUG) else: logger.setLevel(logging.INFO) # Silence katcp INFO messages katcp_logger = logging.getLogger('katcp') katcp_logger.setLevel(logging.WARNING) # Setup the listener class listener = SwarmListener(args.interface) # Create our SWARM instance swarm = Swarm() if not args.listen_only: # Setup using the Swarm class and our parameters swarm.setup(args.bitcode, args.itime, listener) if args.visibs_test: # Enable the visibs test swarm.members_do(lambda fid, member: member.visibs_delay(delay_test=True)) else: # Disable the visibs test swarm.members_do(lambda fid, member: member.visibs_delay(delay_test=False)) if not args.setup_only: # Create the data handler swarm_handler = SwarmDataHandler(swarm, listener) if args.log_stats: # Use a callback to show visibility stats swarm_handler.add_callback(log_stats) if args.save_rawdata: # Give a rawback that saves the raw data swarm_handler.add_rawback(save_rawdata) if args.visibs_test: # Give a rawback that checks for ramp errors swarm_handler.add_rawback(check_ramp) # Start the main loop swarm_handler.loop()