Exemple #1
0
def run():
    """====================
        test some things
        =================="""
    D = AntDomain([1000, 1000], pitch=1)
    D.set_gaussian(sigma=25)
    P = MapPlot(D.Map.X, D.Map.Y, 'blue')
    A = Ant(start_pos=[500, 500],
            limits=[1000, 1000],
            speed=10,
            angle=360 * np.random.rand())
    i = 0
    for loc in 300 + np.random.rand(100, 2) * 600:
        i += 1
        tic = time.time()
        D.local_add_pheromone(loc=loc, Q=1e3)
        D.update_pheromone()
        # P.draw_contour(D.Map.map)
        if i % 5 == 0 or i == 1:
            P.draw_contour(D.Map.map)
        A.random_step(sigma=10)
        P.draw_scatter(A.pos.x, A.pos.y, color='k')
        print("Iteration {i} in {s:.4f} msec".format(i=i,
                                                     s=(time.time() - tic) *
                                                     1e3))
    P.hold_until_close()
Exemple #2
0
    def epoch(self, pheromoneMatrix):
        population = []
        for i in range(self.__noAnts):
            ant = Ant(self.__problem)
            population.append(ant)

        for i in range(self.__problem.getNumberOfTasks() - 1):
            for ant in population:
                ant.update(pheromoneMatrix, self.__alpha, self.__beta,
                           self.__q0)

        t = [1.0 / population[i].fitness() for i in range(len(population))]

        for i in range(self.__problem.getNumberOfComputers()):
            for j in range(self.__problem.getNumberOfTasks()):
                pheromoneMatrix[i][j] = (1 -
                                         self.__rho) * pheromoneMatrix[i][j]

        for i in range(len(population)):
            for j in range(len(population[i].getPath()) - 1):
                x = population[i].getPath()[j]
                y = population[i].getPath()[j + 1]

                pheromoneMatrix[x][y] = pheromoneMatrix[x][y] + t[i]
        fitness = [[population[i].fitness(), i]
                   for i in range(len(population))]
        fitness = min(fitness)
        return population[fitness[1]]
Exemple #3
0
def spawnMouseAnts():
    global spawnAnts
    global pos
    if(spawnAnts):
        spawnedAnt = Ant()
        spawnedAnt.setPos(pos[0], pos[1], map)
        antList.append(spawnedAnt)
Exemple #4
0
def create_children(breeders, env, number_of_child, ants_energy, food_value):
    # creates children using genes from to selected ants
    nextColony = []
    breeders_indexes = np.arange(len(breeders))
    breeders_indexes_shuffled = np.arange(len(breeders))
    np.random.shuffle(breeders_indexes_shuffled)
    for i in range(len(breeders) / 2):
        # first round of childrean, each pair of randomly selected parents create one of them
        # each parent can be selected only once
        first_parent_id = breeders_indexes_shuffled[i]
        second_parent_id = breeders_indexes_shuffled[
            len(breeders_indexes_shuffled) - i - 1]
        brain = select_genes(breeders[first_parent_id],
                             breeders[second_parent_id])
        nextColony.append(
            Ant(env,
                energy=ants_energy,
                food_value=food_value,
                genetic_inh=brain,
                child=1))
    for j in range(number_of_child - (len(breeders) / 2)):
        # if we need more children, we are going to use again some of the old parents
        random_parent = random.choice(breeders_indexes)
        brain = select_genes(breeders[random_parent],
                             breeders[len(breeders) - random_parent - 1])
        nextColony.append(
            Ant(env,
                energy=ants_energy,
                food_value=food_value,
                genetic_inh=brain,
                child=1))
    return nextColony
Exemple #5
0
 def step(self):
     if not self.ant.settled:
         try:
             self.ant.move()
         except Error as e:
             raise e
     else:
         if self.ant.y > self.maxHeight:
             self.maxHeight = self.ant.y
         if self.checkBridge():
             return False
         self.addJoints(self.ant)
         self.antId = self.antId + 1
         self.numAnts += 1
         if G.DeterministicAnts:
             self.ant = Pyramid(self.antId)
             self.oldy = self.y
             self.y = self.ant.y
             if self.y != self.oldy:
                 Physics.resetPhysics()
                 Physics.checkPhysics()
         else:
             self.ant = Ant(self.antId)
             Physics.resetPhysics()
             Physics.checkPhysics()
         self.updateShaking()
     return True
Exemple #6
0
    def f(ant: Ant, pheromones: dict) -> Ant:
        neighbors = ant.get_neighbors()
        transition_arr = [(ant.solution_path[-1], i) for i in neighbors]

        for index in range(len(transition_arr)):
            i, j = transition_arr[index]
            if i > j:
                transition_arr[index] = (j, i)

        next_neighbor = None
        distances = np.array(list(map(ant.get_distance, transition_arr)))
        heuristic = distances**-beta
        if np.random.uniform() < q0:
            max_pheromone = 0
            next_neighbor = np.argmax(
                np.array([pheromones[coord]
                          for coord in transition_arr]) * heuristic)
        else:
            taos = np.array([pheromones[coord] for coord in transition_arr])
            probabilities = ((taos ** alpha)*heuristic) / \
                ((taos ** alpha)*heuristic).sum()
            next_neighbor = np.random.choice(len(transition_arr),
                                             p=probabilities)

        ant.add_node(transition_arr[next_neighbor])
        return ant
Exemple #7
0
    def __init__(self, size=[1000, 1000], pitch=1, n_ants=5):
        """ ==================
            Do a simulation of an Ant
            ================== """
        self.size = size
        self.pitch = pitch

        self.Dom = AntDomain(size,
                             pitch,
                             food={
                                 'location': [850, 500],
                                 'radius': 50
                             },
                             nest={
                                 'location': [150, 500],
                                 'radius': 50
                             })
        self.Dom.set_gaussian(sigma=10)
        self.Ant = Ant(
            limits=size,
            start_pos=[700, 500],
            speed=5,
        )
        self.Ants = [
            Ant(limits=size,
                start_pos=1000 * np.random.rand(1, 2)[0],
                angle=360 * np.random.rand(),
                speed=2,
                v_max=5,
                ant_id=i) for i in range(n_ants)
        ]
        self.Plot = MapPlot(self.Dom.Map.X, self.Dom.Map.Y)
Exemple #8
0
class Sim(object):
    def __init__(self):
        G.state = np.zeros((G.numBlocksX, G.numBlocksY), dtype=np.int)
        G.weight = np.ones((G.numBlocksX, G.numBlocksY))
        self.antId = 0
        if G.DeterministicAnts:
            self.ant = Pyramid(self.antId)
            self.y = self.ant.y
            self.oldy = self.y
        else:
            self.ant = Ant(self.antId)
        self.numAnts = 1
        self.maxHeight = 0

        G.jointData = np.zeros((G.numBlocksX * G.numBlocksY * 3))
        G.numJoints = 0
        G.jointRef = {}

    def step(self):
        if not self.ant.settled:
            try:
                self.ant.move()
            except Error as e:
                raise e
        else:
            if self.ant.y > self.maxHeight:
                self.maxHeight = self.ant.y
            if self.checkBridge():
                return False
            self.addJoints(self.ant)
            self.antId = self.antId + 1
            self.numAnts += 1
            if G.DeterministicAnts:
                self.ant = Pyramid(self.antId)
                self.oldy = self.y
                self.y = self.ant.y
                if self.y != self.oldy:
                    Physics.resetPhysics()
                    Physics.checkPhysics()
            else:
                self.ant = Ant(self.antId)
                Physics.resetPhysics()
                Physics.checkPhysics()
            self.updateShaking()
        return True

    def addJoints(self, ant):
        for adjacent in getAdjacent(ant.pos):
            if G.state[adjacent]:
                Joint(ant.pos, adjacent, -1)

            # attach anchor joints
        if ant.y == 0:
            Joint(ant.pos, (ant.x, ant.y - 1), -1)
            Joint(ant.pos, (ant.x - 1, ant.y - 1), -1)
            Joint(ant.pos, (ant.x + 1, ant.y - 1), -1)

    def getForces(self, (x, y)):
        return [f.force() for f in G.jointRef[(x, y)]]
Exemple #9
0
def create_generation(ant: Ant, board: np.ndarray):
    print("creating generation")

    coords = ant.get_coords()
    board_value = board[coords[1], coords[0]]
    cell_type = ant.evolve(board_value)

    return {"ant": ant, "new_value": cell_type, "coords": coords}
Exemple #10
0
    def run(self):
        '''
        Function to run the rank based Ant Colony Optimization algorithm
        '''
        best_ant = Ant(0, 0, [])

        for i in range(self._n_iterations):
            colony = []
            for j in range(self._n_ants):
                ant = Ant(0, self._distances.shape[0],
                          copy.deepcopy(self._vehicles))
                for x in range(len(ant.vehicles)):
                    ant.vehicles[x].put_node_path(0, self._occupancies,
                                                  self._distances, self._times)
                ant.build_path(self._distances, self._times, self._occupancies,
                               self._pheromone, self._alpha, self._beta)
                ant.calculate_distance(self._distances)
                ant.objectve_function(self._distance_cost)
                colony.append(ant)

            n_bests_ants = self.find_n_bests_ants(colony)

            if n_bests_ants[0].of_value < best_ant.of_value:
                best_ant = n_bests_ants[0]

            self.update_pheromone(best_ant, n_bests_ants)

            #print("Iteration: %d Best OF: %f" %(i + 1, best_ant.of_value))

        return best_ant
Exemple #11
0
def pheromone_update(self, ant: Ant):
    """ Pheromone update method to be potentially used after each batch of ants

    :param self: Reference to the graph
    :param ant:  The ant during the update
    """
    # Update the pheromone levels for each edge the ant took
    value = self.get_path_value(ant.get_tour())
    for n1, n2 in ant.get_tour():
        self.edges[n1, n2]['pheromone'] = (1 - self.global_evaporation_rate) * self.edges[n1, n2]['pheromone'] + \
                                          self.global_evaporation_rate * value
Exemple #12
0
    def init_tiles_ants(self):
        self.screen_size = self.screen.get_size()[0]
        self.tile_size = self.screen_size // cfg.N_TILES
        if isinstance(self.init_tiles, str) and self.init_tiles == 'random':
            self.tiles = np.random.randint(0, 2, (cfg.N_TILES, cfg.N_TILES))
        elif self.init_tiles is not None:
            self.tiles = self.init_tiles
        else:
            self.tiles = np.zeros((cfg.N_TILES, cfg.N_TILES))

        self.ant = Ant(self.ant_init_pos, self.ant_init_direction)
        self.total_step = 0
Exemple #13
0
 def __init__(self, data, alpha=0.2, label=None, mask=None, option=None):
     self.mask = mask
     self.option = option
     self.al = alpha
     self.nest_counter = 1
     if label is None:
         self.ants = set([Ant(datum) for datum in data.tolist()])
     else:
         self.ants = set([
             Ant(datum, true_label=label[i])
             for i, datum in enumerate(data.tolist())
         ])
Exemple #14
0
def make_ants(G, pos, num_steps, anthill_data):
    ants = []
    for ant_num in range(1, int(anthill_data['ants']) + 1):
        ant = Ant(ant_num)
        ant.set_node_path(anthill_data)
        ant.set_location(pos, anthill_data)
        ant.set_journey(pos, num_steps, anthill_data)
        ant.color = ant_colors[ant_num % 11]
        ants.append(ant)
    return (ants)
Exemple #15
0
class LangtonsAnt:
    def __init__(
        self, initial_state: List[List[bool]], start_position: List[int]
    ) -> None:
        self._grid = Grid(initial_state)
        self._ant = Ant(start_position[0], start_position[1])

    def next(self) -> bool:
        current_ant_position_x, current_ant_position_y = self._ant.position

        if self._grid.get_color(current_ant_position_x, current_ant_position_y):
            self._grid.change_color(current_ant_position_x, current_ant_position_y)
            self._ant.turn(TurnDirection.RIGHT)
            self._ant.move()
        else:
            self._grid.change_color(current_ant_position_x, current_ant_position_y)
            self._ant.turn(TurnDirection.LEFT)
            self._ant.move()

        return self.validate_move()

    @property
    def state(self):
        return self._grid.state

    @property
    def ant_position(self):
        return self._ant.position

    def validate_move(self) -> bool:
        current_ant_position_x, current_ant_position_y = self._ant.position
        return self._grid.validate_point(current_ant_position_x, current_ant_position_y)

    def validate(self) -> bool:
        return self._grid.validate()
Exemple #16
0
    def populate_world(self):
        first_ant = Ant(world=self,
                        n_nodes=self.n_nodes,
                        alpha=self.alpha,
                        beta=self.beta)
        ant = first_ant

        for i in range(self.n_ants - 1):
            ant.next = Ant(world=self,
                           n_nodes=self.n_nodes,
                           alpha=self.alpha,
                           beta=self.beta)
            ant = ant.next
        self.first_ant = first_ant
Exemple #17
0
    def __init__(self, parameters, instance):

        self.instance = instance
        self.ants = [Ant(instance) for i in range(parameters.n_ants)]
        self.best_so_far_ant = Ant(instance)
        self.restart_best_ant = Ant(instance)
        self.prob_of_selection = [0 for i in range(parameters.nn_ants + 1)]
        # Ensure that we do not run over the last element in the random wheel.
        self.prob_of_selection[parameters.nn_ants] = math.inf
        self.pheromone = [[None for i in range(instance.n)]
                          for i in range(instance.n)]
        self.total = [[None for i in range(instance.n)]
                      for i in range(instance.n)]
        self.nn_tour = None
        self.compute_nn_tour()
 def put_ants(self):
     points = range(1,self.points+1) 
     position = 0
     for tower in self.__towers:
     	ant = Ant()
     	ant.position = position
     	ant.set_coverage(copy(points))
     	ant.possible_towers = copy(self.__towers)
     	ant.route = []
     	ant.set_actual_tower(tower)
     	self.__ants.append(ant)
     	position += 1
Exemple #19
0
 def update(self, data):
     map(lambda tile, pheromones: tile.update(**pheromones), self.tiles,
         data['board'])
     for tile in self.tiles:
         rect, color = tile.render()
         pygame.draw.rect(self.screen, color, rect)
     for ant_repr in data['ants']:
         if ant_repr['id'] in self.ants:
             ant = self.ants[ant_repr['id']]
             ant.position = ant_repr['position']
         else:
             ant = Ant(**ant_repr)
             self.ants[ant_repr['id']] = ant
         pos = map(lambda coord: coord * TILE_SIZE + TILE_SIZE / 2,
                   ant.position)
         ant_color = YELLOW if ant.carries_food else GREEN
         pygame.draw.circle(self.screen, ant_color, pos, TILE_SIZE / 5)
     # Place colony
     pygame.draw.rect(self.screen, GREEN, self.colony)
     # Place food
     food_pos = self.food['position']
     pile = [[
         food_pos[0] * TILE_SIZE + TILE_SIZE / 2, food_pos[1] * TILE_SIZE
     ], [food_pos[0] * TILE_SIZE, (food_pos[1] + 1) * TILE_SIZE],
             [(food_pos[0] + 1) * TILE_SIZE, (food_pos[1] + 1) * TILE_SIZE]]
     pygame.draw.polygon(self.screen, YELLOW, pile)
     pygame.display.flip()
Exemple #20
0
 def __init__(self):
     self.area = Area()
     self.ant_num = 20
     self.ant_list = []
     self.add_number = 0
     for i in range(self.ant_num):
         self.ant_list.append(Ant(self.area.area))
Exemple #21
0
    def Start_find_food(self):
        # while True:
        ant_x_list = []
        ant_y_list = []
        dispatch = False
        mydispatch = False
        direction = 0
        if self.add_number > 0:
            self.ant_list.append(Ant(self.area.area))
            self.add_number = self.add_number - 1
            self.ant_num = self.ant_num + 1

        for i in range(self.ant_num):
            dispatch = self.ant_list[i].walking()
            if len(self.ant_list[i].previous_location_list) > 2000:
                self.ant_list[i].previous_location_lis = []
            if dispatch == True:
                mydispatch = True
            ant_x_list.append(self.ant_list[i].location[0])
            ant_y_list.append(self.ant_list[i].location[1])
            #     if self.ant_list[i].direction_x==self.ant_list[i].driection_y and self.ant_list[i].direction_x:
            #         direction=direction+1
            # print(direction)
            pass
        print(len(self.ant_list[19].previous_location_list))
        if mydispatch == True:
            if self.ant_num < 50:
                self.add_number = 5

        return ant_x_list, ant_y_list
Exemple #22
0
    def reconnaissance(self, iterations=1):
        maze = self.maze
        if self.do_reconnaissance < 1:
            return maze

        print 'performing reconnaissance with %d ants for %d steps in %d iterations' % (
            self.ant_count, self.do_reconnaissance, iterations)

        disabled = set()
        start_time = time.time()
        for iteration in range(iterations):
            ants = []
            for i in range(self.ant_count):
                ants.append(Ant(maze, maze.start))

            results = self.pool.map_async(
                ant_loop_apply,
                itertools.izip(ants, [self.do_reconnaissance] *
                               self.ant_count)).get(999999)

            for ant in results:
                for disable in ant.disable_positions:
                    maze.disable_at(disable)
                    disabled.add(disable)

        print 'Reconnaissance done, %d cells disabled in %0.2fs' % (
            len(disabled), time.time() - start_time)
        return maze
Exemple #23
0
def ant_colony_opt(matrix, n_ants=10, max_iterations=23000):
    best_pheromone_matrix = np.ones(shape=(9, 9, 9)) / 9

    ants = [Ant(matrix.copy(), best_pheromone_matrix) for _ in range(n_ants)]
    print(ants[0].fitness())
    best_fitness = float('inf')
    best_ant = None

    history = []

    for _ in tqdm(range(max_iterations)):
        for i, ant in enumerate(ants):

            ant.solve_sudoku(epsilon_greedy=0.05)
            fitness = ant.fitness()

            if fitness < best_fitness:
                best_ant = copy.deepcopy(ant)
                best_fitness = fitness
                tqdm.write(str(best_fitness))

        for i in range(9):
            for j in range(9):
                best_pheromone_matrix[i][j][best_ant.current_solution[i, j] -
                                            1] += 0.0005
                best_pheromone_matrix[i][j] /= np.sum(
                    best_pheromone_matrix[i][j])

        history.append(best_fitness)
        if best_fitness == 0:
            # We found the solution, just stop
            break

    return best_ant.current_solution, history
    def __init__(self,
                 graph,
                 num_ants,
                 alpha=1.0,
                 beta=5.0,
                 iterations=10,
                 evaporation=0.5):
        self.graph = graph
        self.locationsLength = len(graph.locations)
        self.num_ants = num_ants
        self.alpha = alpha  # importância do feromônio
        self.beta = beta  # importância da informação heurística
        self.iterations = iterations  # quantidade de iterações
        self.evaporation = evaporation  # taxa de evaporação
        self.ants = []  # lista de ants

        locations = self.graph.getLocationsList()
        # cria as ants colocando cada uma em uma location diferente
        for _ in range(self.num_ants):
            location_ant = random.choice(locations)
            locations.remove(location_ant)
            self.ants.append(Ant(location=location_ant))
            if not locations:
                locations = [
                    location for location in range(1, self.locationsLength + 1)
                ]

        # reestrutura location como set
        locations = self.graph.locations

        for key_edge in self.graph.edges:
            # pheromone = 1.0 / (self.locationsLength * cost)
            self.graph.setPheromoneEdge(key_edge[0], key_edge[1], 0.1)
Exemple #25
0
 def thread_body(queue):
     pixels = NeoPixel(DATA_PIN, N_PIXELS, brightness=BRIGHTNESS,
                       auto_write=False)
     updates = {'RAINBOW': Rainbow(pixels),
                'ANT':     Ant(pixels),
                'OCD':     Ocd(pixels),
                'FLASH':   Flash(pixels),
                'IMPLODE': Implode(pixels),
                'ERROR':   Error(pixels),
                'QUIT':    Quit(pixels)}
     assert set(updates.keys()) == MODES
     mode = "OCD"
     while True:
         try:
             new_mode = queue.get_nowait()
             assert new_mode in MODES, "unknown mode %s" % mode
             if new_mode != mode:
                 updates[new_mode].setup()
             mode = new_mode
         except:
             pass
         sleep = updates[mode].exec_update()
         if mode == "QUIT":
             break
         time.sleep(sleep)
Exemple #26
0
    def perform_tours(self, instance):
        """
        Initialises ants within colony and makes the ants perform their tours around the tsp instance
        """

        # Create n ants with each one starting on a random node where n is the amount of nodes
        node_range = len(instance.nodes) - 1
        self.ants = [
            Ant(instance, random.randint(0, node_range))
            for _ in range(node_range)
        ]

        # Make each ant perform a tour around the instance
        for ant in self.ants:
            ant.perform_tour(instance)

            # Update pheromones locally
            self.local_update_pheromones(instance, ant.nodes_traversed())

            distance = ant.get_distance(instance)

            # Initialise the minimum distance as infinity if None
            if not (self.min_distance):
                self.min_distance = float('inf')

            # Update the colonys minimum distance and shortest path if the ant has found a shorter distance
            if self.min_distance > distance:

                self.min_distance = distance

                self.shortest_path = ant.path[:]
Exemple #27
0
    def ant_algorithm(self):
        for i in range(self.max_iter):
            ants = list(Ant(self.graph) for j in range(self.ants_num))
            for k in range(self.ants_num):
                while not len(ants[k].att_to_visit) == 0:
                    next_index = self.select_next_attraction(ants[k])
                    if not ants[k].check_condition(next_index):
                        next_index = self.select_next_attraction(ants[k])
                        if not ants[k].check_condition(next_index):
                            next_index = 0
                    ants[k].visit_attraction(next_index)
                ants[k].visit_attraction(0)
            paths_distance = np.array(
                [ant.total_travel_distance for ant in ants])
            best_index = np.argmin(paths_distance)

            if self.best_path is None or paths_distance[
                    best_index] < self.best_path_distance:
                self.best_path = ants[int(best_index)].travel_path
                self.best_path_distance = paths_distance[best_index]
                self.best_vehicle_num = self.best_path.count(0) - 1

            self.graph.update_pheromones(self.best_path,
                                         self.best_path_distance)
            print('Iteration ' + str(i))

        print('Best path distance is ' +
              str(round(self.best_path_distance, 3)) +
              ', number of vehicle is ' + str(self.best_vehicle_num))
Exemple #28
0
 def create_ants(self):
     self.reset()
     ants = []
     for i in range(0, self.num_ants):
         ant = Ant(i, random.randint(0, self.graph.num_nodes - 1), self)
         ants.append(ant)
     return ants
Exemple #29
0
def create_new_ant():
    sensing_area = random.randint(1, 10)
    p_repeat = random.random()
    p_target = random.random()
    p_pheromone = random.random()
    new_ant = Ant(sensing_area, p_repeat, p_target, p_pheromone, get_id = get_ant_id)
    return new_ant
Exemple #30
0
    def setup(self):

        if settings.DRAW_BASE:
            self.create_base()

        for _ in range(settings.NUM_WALLS):
            self.create_wall()

        for _ in range(settings.NUM_FOOD_BLOBS):
            self.create_food_blob(settings.FOOD_BLOB_SIZE)

        self.colony = Colony()

        for _ in range(settings.NUM_ANTS):
            ant = Ant(settings.SCREEN_WIDTH / 2,
                      0,
                      self,
                      self.colony,
                      scale=settings.SCALE)
            self.ant_list.append(ant)

        arcade.set_background_color(settings.FIELD_COLOR)

        if self.generation_callback:
            self.generation_callback(self.generation, self)
Exemple #31
0
def main(commands: dict, ordered_colours: list):
    """
    The main function responsible for running and simulating the ant's movements
    """
    ant = Ant(commands, ordered_colours)
    board = Board(ant)
    run = True
    clock = pygame.time.Clock()
    rows, cols = ROWS, COLS

    while run:
        clock.tick(FPS)
        for event in pygame.event.get():

            if event.type == pygame.QUIT:
                pygame.quit()
                exit()

        board.draw_board(rows, cols, WIN)
        board.draw_ant(rows, WIN)

        board.update_ant_dir()
        board.update_ant_pos()

        if board.check_edge():
            rows, cols = (rows * 3), (cols * 3)
            board.increase_board()

        pygame.display.update()
def test_completable_path():
	num_nodes = 8
	delta_mat = [[0,1,1,1,1,1,1,1],[1,0,1,1,1,1,1,1],[1,1,0,1,1,1,1,1],[1,1,1,0,1,1,1,1],[1,1,1,1,0,1,1,1],[1,1,1,1,1,0,1,1],[1,1,1,1,1,1,0,1],[1,1,1,1,1,1,1,0]]
	num_ants = 1
	num_iterations = 10
	colors1 = "RRRRBBBB"

	graph1 = AntGraph(num_nodes,delta_mat,colors1)
	colony1 = AntColony(graph1,num_ants,num_iterations)

	
	ant1 = Ant(1, 1, colony1)

	print "testing reds_left initialization: " + str(ant1.reds_left)

	#Visited: 1,2,3
	ant1.currNode = 3 
	ant1.last_3_colors = ("R","R","R")
	self.reds_left = 1
Exemple #33
0
    def new_ant(self):
    	"""
    	Creates new ant and adds it to the Node's ant list.
	
    	Parameters:
    		None
	
    	Returns:
    		None
    	"""
        
        ant = Ant(self.num, random.randint(0, self.net_size - 2))
        
        if ant.dest >= self.num:
            ant.dest += 1
        
        ant.prev = self.num
        
        self.ants.append(ant)
Exemple #34
0
def spawnBlueAnts():
    global spawnBlueAnts
    global pos
    if(spawnBAnts):
        spawnedBlueAnt = Ant()
        spawnedBlueAnt.setPos(pos[0], pos[1], map)
        spawnedBlueAnt.setFaction("blue")
        spawnedBlueAnt.setColor()
        antList.append(spawnedBlueAnt)
Exemple #35
0
def spawnGreenAnts():
    global spawnGreenAnts
    global pos
    if(spawnGAnts):
        spawnedGreenAnt = Ant()
        spawnedGreenAnt.setPos(pos[0], pos[1], map)
        spawnedGreenAnt.setFaction("green")
        spawnedGreenAnt.setColor()
        antList.append(spawnedGreenAnt)
Exemple #36
0
def spawnRedAnts():
    global spawnRedAnts
    global pos
    if(spawnRAnts):
        spawnedRedAnt = Ant()
        spawnedRedAnt.setPos(pos[0], pos[1], map)
        spawnedRedAnt.setFaction("red")
        spawnedRedAnt.setColor()
        antList.append(spawnedRedAnt)
def test_valid_color():
	num_nodes = 6
	delta_mat = [[0,1,1,1,1,1],[1,0,1,1,1,1],[1,1,0,1,1,1],[1,1,1,0,1,1],[1,1,1,1,0,1],[1,1,1,1,1,0]]
	num_ants = 1
	num_iterations = 10
	colors1 = "RRRRRR"
	colors2 = "RRRBBB"
	colors3 = "BBBBBB"
	
	graph1 = AntGraph(num_nodes,delta_mat,colors1)
	colony1 = AntColony(graph1,num_ants,num_iterations)
	ant1 = Ant(1, 1, colony1)
	ant1.last_3_colors = ("R","R","R")
	print "False: " + str(ant1.valid_color(1))
	ant1.last_3_colors = ("B","B","B")
	print "True: " + str(ant1.valid_color(1))
	ant1.last_3_colors = ("R","R","B")
	print "True: " + str(ant1.valid_color(1))

	graph2 = AntGraph(num_nodes,delta_mat,colors2)
	colony2 = AntColony(graph2,num_ants,num_iterations)
	ant2 = Ant(1, 1, colony2)
	ant2.last_3_colors = ("R","R","R")
	print "True: " + str(ant2.valid_color(3))
	print "False: " + str(ant2.valid_color(1))

	graph3 = AntGraph(num_nodes,delta_mat,colors3)
	colony3 = AntColony(graph3,num_ants,num_iterations)
	ant3 = Ant(1, 1, colony3)
	ant3.last_3_colors = ("R","R","R")
	print "True: " + str(ant3.valid_color(1))
	ant3.last_3_colors = ("B","B","B")
	print "False: " + str(ant3.valid_color(1))
	ant3.last_3_colors = ("B","R","B")
	print "True: " + str(ant3.valid_color(1))
Exemple #38
0
def updatePhermone():
	if randint(0, 10) >= 0:
		count = 0
		for i in antGrid.storedInformation:
			sPhermoneLevel = antGrid.storedInformation[count][1]
			if sPhermoneLevel > 5:
				antGrid.storedInformation[count][1] = sPhermoneLevel - 1
			count += 1
			
			backlog = len(antGrid.storedIndex)
			
			if backlog > 40000:
				antGrid.storedIndex.pop(0)
				antGrid.storedInformation.pop(0)

ant 	= Ant(DEFAULT_COORDINATES)
antGrid	= Grid(ant.GRID_WIDTH, ant.GRID_HEIGHT)
screen 	= pygame.display.set_mode((ant.GRID_WIDTH, ant.GRID_HEIGHT))

running = True

herd = [Ant(DEFAULT_COORDINATES) for i in range(0, NUMBER_ANTS)]

iterations = 1 		# for debugging purposes

while running:
		
	displayAnts()
	updatePhermone()
	
	for ant in herd:
Exemple #39
0
def spawn_worker(cont):
    own = cont.owner
    worker = Ant(bge.logic.getCurrentScene().addObject("Ant"))
    worker.worldPosition.xy = own.worldPosition.xy
    bge.logic.sendMessage("GUI")
    worker.target = own.worldPosition + Vector((0, -3, 0))
Exemple #40
0
 def __init__(self, position):
     Ant.__init__(self, position)
     self.path = []
     self.index = 0
     self.target = None
Exemple #41
0
def spawn_test_ants():
    redLocation = [100, 100]
    greenLocation = [120, 120]
    
    redAnt = Ant()
    redAnt.setFaction("red")
    redAnt.setColor()
    redAnt.health = 25
    redAnt.setPos(redLocation[0], redLocation[1], map)
    antList.append(redAnt)
    
    greenAnt = Ant()
    greenAnt.setFaction("green")
    greenAnt.setColor()
    greenAnt.health = 100
    greenAnt.setPos(greenLocation[0], greenLocation[1], map)
    antList.append(greenAnt)
Exemple #42
0
 def __init__(self, position):
     Ant.__init__(self, position)
     self.path = []
     self.index = 0
Exemple #43
0
def gwas(start_snp, end_snp, individuals, ants_number, update_times, factor, threshold):
    """
     individuals: sum of cases and control.
     factor:  0<factor<1 user-adjustable distribution.if factor is near 1,snps with high scores are only slightly
              more likely to be selected.
     threshold <-> P-Value: 26.12<->0.001;20.09<->0.01;15.51<->.0.05
    """
    snps_number = end_snp - start_snp + 1
    dict_pair = Prepare.dict_pair(start_snp, end_snp)
    print('dict_pair done')

    n = 0
    for order in range(1, 101):
        dict_prob = Prepare.dict_prob1(start_snp, end_snp + 1)
        print('dict_prob done')
        label, data_set = Prepare.data_matrix(order, individuals, snps_number)
        dict_weka = Prepare.load_weka_ranking(order)
        snps_sequence = Prepare.snps_sequence1(start_snp, end_snp)
        snps_scores = [0] * snps_number
        # Rank dict on weight,return a list of tuples
        list_weka = sorted(dict_weka.items(), key=lambda weka: weka[1], reverse=True)
        rank = Prepare.scaling_rank(factor, snps_number)
        for snp_weight_tuple, new_weight in zip(list_weka, rank):
            # allocate scaling rank weight to corresponding snp
            snps_scores[snp_weight_tuple[0] - start_snp] = new_weight
        selected_pairs = {}
        for x in range(update_times):
            list_k1_threshold = []  # 存储chi2_statistics > 阈值的pair在dict_prob[first_snp]中的索引位置
            list_k2_threshold = []  # 存储chi2_statistics > 阈值的pair在dict_prob[second_snp]中的索引位置
            list_chi2_statistics = []  # 存储chi2_statistics > 阈值的pair的卡方值,在update的时候使用
            list_k1 = []  # 存储chi2_statistics < 阈值的pair在dict_prob[first_snp]中的索引位置
            list_k2 = []  # 存储chi2_statistics < 阈值的pair在dict_prob[second_snp]中的索引位置
            list_first_snp_threshold = []  # 存储chi2_statistics > 阈值的first_snp
            list_second_snp_threshold = []  # 存储chi2_statistics > 阈值的second_snp
            list_first_snp = []  # 存储chi2_statistics < 阈值的first_snp
            list_second_snp = []  # 存储chi2_statistics < 阈值的second_snp
            for y in range(ants_number):
                first_snp = Ant.ant_first_snp(snps_sequence, snps_scores)
                second_snp = Ant.ant_second_snp(first_snp, dict_pair, dict_prob)
                # print(first_snp, second_snp)
                if second_snp > first_snp:
                    k1 = second_snp - start_snp - 1
                    k2 = first_snp - start_snp
                else:
                    k1 = second_snp - start_snp
                    k2 = first_snp - start_snp - 1
                case_row, control_row = ChiSquareTest.chi2_table(data_set, label, first_snp, second_snp, individuals)
                sum_colum, A2_NcNr, chi2_statistics = ChiSquareTest.chi2_test(case_row, control_row, individuals)
                if chi2_statistics > threshold:
                    list_k1_threshold.append(k1)
                    list_k2_threshold.append(k2)
                    list_chi2_statistics.append(chi2_statistics)
                    list_first_snp_threshold.append(first_snp)
                    list_second_snp_threshold.append(second_snp)
                else:
                    list_k1.append(k1)
                    list_k2.append(k2)
                    list_first_snp.append(first_snp)
                    list_second_snp.append(second_snp)
            # 更新条件概率和snps_scores.
            # 除以 10 的目的是将卡方值转换到和weight同样的量级.snps_score_original[x]引入expert information
            for m, i, j in zip(list_first_snp_threshold, list_k1_threshold, list_chi2_statistics):
                dict_prob[m][i] += (int(j) / 10)
            for m, i, j in zip(list_second_snp_threshold, list_k2_threshold, list_chi2_statistics):
                dict_prob[m][i] += (int(j) / 10)
            for m, i in zip(list_first_snp, list_k1):
                dict_prob[m][i] = 0
            for m, i in zip(list_second_snp, list_k2):
                dict_prob[m][i] = 0
            for first, second, i in zip(list_first_snp_threshold, list_second_snp_threshold, list_k1_threshold):
                selected_pairs[(first, second)] = dict_prob[first][i]
            print(selected_pairs)
        result = sorted(selected_pairs.items(), key=lambda x: x[1], reverse=True)
        for x in result[0:20]:
            if x[0] == (999, 988) or x[0] == (998, 999):
                n += 1
                break
        f = open('result_conProb-H0.1-{ants}_{updates}-fac={factor}.txt'.format(
            ants=ants_number, updates=update_times, factor=factor), 'a')
        f.writelines('\n')
        f.writelines(str(x[0]) + '\t' + str(x[1]) + '\n' for x in result[0:20])
        f.writelines('----------------------------------')
        f.close()
    f = open('result_conProb-H0.1-{ants}_{updates}-fac={factor}.txt'.format(
        ants=ants_number, updates=update_times, factor=factor), 'a')
    f.writelines('\nThe pow of this ACO algorithm is ' + str(n) + '%')
    f.close()
Exemple #44
0
    def __checkPoint__(self, point):
        fake_ant = Ant('fake')
        fake_ant.picture = self.picture
        fake_ant.point = point

        return not self.__isAntIntersectAnything(fake_ant)
Exemple #45
0
 def __init__(self, position):
     Ant.__init__(self, position)
Exemple #46
0
 def step(self, start_node_name):
     ant = Ant(self.graph, start_node_name)
     distance = ant.run()
     if distance < self.best_distance:
         ant.pheromonize()
         self.best_distance = distance