Merge pull request #4 from rsarai/aco

Adds ACO

Author: rsarai

ACO Convergence Average 30 Runs.png

@@ -111,7 +111,6 @@ def scount_bees_exploration(self):
         probability_distribution = self.calculate_probabilities_for_onlookers(employer_bees)
 
         for bee in self.colony:
-            assert len(bee.current_position) == self.dimensions
             if bee.failures > self.fail_limit:
                 bee.current_position = self._get_random_positions()
                 onlookers = [b for b in self.colony if bee.food_source == b.food_source]

ACO Found Solution.png

@@ -0,0 +1,129 @@
+"""
+The TSPLIB Symmetric Traveling Salesman Problem Instances
+http://elib.zib.de/pub/mp-testdata/tsp/tsplib/tsp/
+https://people.sc.fsu.edu/~jburkardt/datasets/tsp/tsp.html
+"""
+import random
+import math
+import numpy as np
+
+from particle import Ant
+
+# np.random.seed(42)
+# random.seed(42)
+
+class Graph:
+
+    def __init__(self, cities):
+        self.cities = cities
+        self.pheromones = [[0.0 for _ in cities] for _ in cities]
+        self.distance_matrix = [[]]
+        self._create_distance_matrix()
+
+    def _create_distance_matrix(self):
+        self.distance_matrix = []
+        for city in self.cities:
+            row = []
+            for other_city in self.cities:
+                row.append(np.linalg.norm(np.array(city) - np.array(other_city)))
+            self.distance_matrix.append(row)
+
+class ACO:
+
+    def __init__(self, graph, algorithm_type=1, rho_evaporation_rate=0.85, tour_counter=1000,
+                 ants_count=30, alpha=1, beta=5, t_max=0.8, t_min=0.2):
+        """
+        :alpha: relative importance of pheromone
+        :beta: relative importance of heuristic information
+        :algorithm_type: 1 for regular ACO | 2 for MMACO
+        """
+        self.graph = graph
+        self.town_count = len(graph.cities)
+        self.tour_counter = tour_counter
+        self.ants_count = ants_count
+        self.alpha = alpha
+        self.beta = beta
+        self.rho_evaporation_rate = rho_evaporation_rate
+        self.t_max = t_max
+        self.t_min = t_min
+        self.algorithm_type = algorithm_type
+
+        self.best_solution = []
+        self.best_cost = float("inf")
+        self.best_cost_list = []
+        self.all_ants = []
+
+        if self.algorithm_type != 1:
+            self.graph.pheromones = [[self.t_max for _ in self.graph.cities] for _ in self.graph.cities]
+
+    def initialize_all_ants(self):
+        self.all_ants = []
+        for _ in range(self.ants_count):
+            self.all_ants.append(
+                Ant(current_town=random.randint(0, self.town_count - 1))
+            )
+
+    def construct_tour_for_each_ant(self):
+        for _ in range(self.town_count - 1):
+            for ant in self.all_ants:
+                old_town = ant.current_town
+                ant.move_next_city_to_construct_tour(self.graph, self.alpha, self.beta)
+                assert old_town != ant.current_town
+
+    def update_pheromone_trails(self):
+        for ant in self.all_ants:
+            ant.update_pheromone_trails(self.graph)
+
+        for i, row in enumerate(self.graph.pheromones):
+            for j, _ in enumerate(row):
+                self.graph.pheromones[i][j] *= (1 - self.rho_evaporation_rate)
+
+                if self.algorithm_type == 1:
+                    for ant in self.all_ants:
+                        self.graph.pheromones[i][j] += ant.pheromones_delta[i][j]
+                else:
+                    ant = self.get_best_ant_from_iteration()
+                    self.graph.pheromones[i][j] += ant.pheromones_delta[i][j]
+                    if self.graph.pheromones[i][j] > self.t_max:
+                        self.graph.pheromones[i][j] = self.t_max
+                    if self.graph.pheromones[i][j] < self.t_min:
+                        self.graph.pheromones[i][j] = self.t_min
+
+    def get_best_ant_from_iteration(self):
+        best_ant = None
+        best_distance = float('inf')
+        for ant in self.all_ants:
+            distance = ant.total_cost
+            # distance = self.calculate_tour_distance(self.graph, ant.tabu_list)
+            # assert distance == ant.total_cost
+            if distance < best_distance:
+                best_ant = ant
+        return best_ant
+
+    def update_best_solution(self):
+        for ant in self.all_ants:
+            ant.complet_tour_cost(self.graph)
+            distance = ant.total_cost
+            # distance = self.calculate_tour_distance(self.graph, ant.tabu_list)
+            # assert round(distance, 5) == round(ant.total_cost, 5)
+            if distance < self.best_cost:
+                self.best_cost = distance
+                self.best_solution = ant.tabu_list
+
+    def search(self):
+        for i in range(self.tour_counter):
+            self.initialize_all_ants()
+            self.construct_tour_for_each_ant()
+            self.update_pheromone_trails()
+            self.update_best_solution()
+            print(f"Iteration {i}. Best cost: {self.best_cost}")
+            self.best_cost_list.append(self.best_cost)
+        return self.best_cost_list
+
+    @classmethod
+    def calculate_tour_distance(cls, graph, best_solution):
+        result = 0
+        for i in range(len(best_solution)):
+            # result += math.sqrt((graph.cities[best_solution[i]][0] - graph.cities[best_solution[i - 1]][0])**2 + (graph.cities[best_solution[i]][1] - graph.cities[best_solution[i - 1]][1])**2)
+            result += np.linalg.norm(np.array(graph.cities[best_solution[i]]) - np.array(graph.cities[best_solution[i - 1]]))
+        return result

Boxplot ACO Average 30 Runs.png

@@ -0,0 +1,48 @@
+1 6734 1453
+2 2233 10
+3 5530 1424
+4 401 841
+5 3082 1644
+6 7608 4458
+7 7573 3716
+8 7265 1268
+9 6898 1885
+10 1112 2049
+11 5468 2606
+12 5989 2873
+13 4706 2674
+14 4612 2035
+15 6347 2683
+16 6107 669
+17 7611 5184
+18 7462 3590
+19 7732 4723
+20 5900 3561
+21 4483 3369
+22 6101 1110
+23 5199 2182
+24 1633 2809
+25 4307 2322
+26 675 1006
+27 7555 4819
+28 7541 3981
+29 3177 756
+30 7352 4506
+31 7545 2801
+32 3245 3305
+33 6426 3173
+34 4608 1198
+35 23 2216
+36 7248 3779
+37 7762 4595
+38 7392 2244
+39 3484 2829
+40 6271 2135
+41 4985 140
+42 1916 1569
+43 7280 4899
+44 7509 3239
+45 10 2676
+46 6807 2993
+47 5185 3258
+48 3023 1942

Boxplot MMACO Average 30 Runs.png

@@ -0,0 +1,48 @@
+1
+8
+38
+31
+44
+18
+7
+28
+6
+37
+19
+27
+17
+43
+30
+36
+46
+33
+20
+47
+21
+32
+39
+48
+5
+42
+24
+10
+45
+35
+4
+26
+2
+29
+34
+41
+16
+22
+3
+23
+14
+25
+13
+11
+12
+15
+40
+9

MMACO Convergence Average 30 Runs.png

@@ -0,0 +1,29 @@
+1 1150.0 1760.0
+2 630.0 1660.0
+3 40.0 2090.0
+4 750.0 1100.0
+5 750.0 2030.0
+6 1030.0 2070.0
+7 1650.0 650.0
+8 1490.0 1630.0
+9 790.0 2260.0
+10 710.0 1310.0
+11 840.0 550.0
+12 1170.0 2300.0
+13 970.0 1340.0
+14 510.0 700.0
+15 750.0 900.0
+16 1280.0 1200.0
+17 230.0 590.0
+18 460.0 860.0
+19 1040.0 950.0
+20 590.0 1390.0
+21 830.0 1770.0
+22 490.0 500.0
+23 1840.0 1240.0
+24 1260.0 1500.0
+25 1280.0 790.0
+26 490.0 2130.0
+27 1460.0 1420.0
+28 1260.0 1910.0
+29 360.0 1980.0

MMACO Found Solution.png

@@ -0,0 +1,29 @@
+1
+28
+6
+12
+9
+5
+26
+29
+3
+2
+20
+10
+4
+15
+18
+17
+14
+22
+11
+19
+25
+7
+23
+27
+8
+24
+16
+13
+21

Optimal Solution.png

@@ -0,0 +1,77 @@
+import numpy as np
+import math
+from aco import ACO, Graph
+from plot_graphs import plot_path, plot_boxplot, plot_convergence_graphs
+
+
+SIMULATIONS = 30
+
+
+with open("data/att48.txt", "r") as f:
+    matrix_cities = []
+    for line in f.readlines():
+        _, pos1, pos2 = line.split(" ")
+        matrix_cities.append([float(pos1), float(pos2)])
+
+with open("data/att48_optimal_tour.txt", "r") as f:
+    best_solution = [int(line) for line in f.readlines()]
+best_solution = [i - 1 for i in best_solution]
+
+graph = Graph(cities=matrix_cities)
+optimal = ACO.calculate_tour_distance(graph, best_solution)
+
+
+best_fitness = []
+for _ in range(SIMULATIONS):
+    aco = ACO(graph=graph, algorithm_type=1, rho_evaporation_rate=0.9)
+    best_cost_list = aco.search()
+    best_fitness.append(best_cost_list)
+    print("Optimal: ", optimal)
+    print("Found: ", ACO.calculate_tour_distance(graph, aco.best_solution))
+print("ACO Min: ", np.array(best_fitness).min())
+
+# plot_boxplot(best_fitness, "Boxplot ACO Average 30 Runs")
+# average_best_fitness = np.sum(np.array(best_fitness), axis=0) / SIMULATIONS
+
+# plot_path(graph.cities, aco.best_solution, "ACO Found Solution")
+# plot_convergence_graphs(average_best_fitness, optimal, "ACO Convergence Average 30 Runs")
+
+
+best_fitness = []
+for _ in range(SIMULATIONS):
+    aco = ACO(graph=graph, algorithm_type=2, rho_evaporation_rate=0.9)
+    best_cost_list = aco.search()
+    best_fitness.append(best_cost_list)
+    print("Optimal: ", optimal)
+    print("Found: ", ACO.calculate_tour_distance(graph, aco.best_solution))
+    print(aco.best_solution)
+print("MMACO Min: ", np.array(best_fitness).min())
+
+
+# plot_boxplot(best_fitness, "Boxplot MMACO Average 30 Runs")
+# average_best_fitness = np.sum(np.array(best_fitness), axis=0) / SIMULATIONS
+
+# plot_path(graph.cities, aco.best_solution, "MMACO Found Solution")
+# plot_convergence_graphs(average_best_fitness, optimal, "MMACO Convergence Average 30 Runs")
+
+
+# total_distance = 0
+# for i in range(len(best_solution)):
+#     total_distance += np.linalg.norm(
+#         np.array(matrix_cities[best_solution[i]]) - np.array(matrix_cities[best_solution[i - 1]])
+#     )
+# print(total_distance)
+
+
+# result = 0
+# result_2 = 0
+# for i in range(len(best_solution)):
+#     # partial_result = math.sqrt((graph.cities[best_solution[i]][0] - graph.cities[best_solution[i - 1]][0])**2 + (graph.cities[best_solution[i]][1] - graph.cities[best_solution[i - 1]][1])**2)
+#     partial_result = np.linalg.norm(np.array(graph.cities[best_solution[i]]) - np.array(graph.cities[best_solution[i - 1]]))
+#     partial_result_2 = graph.distance_matrix[best_solution[i]][best_solution[i - 1]]
+#     assert partial_result == partial_result_2
+#     result += partial_result
+#     result_2 += partial_result_2
+
+# print(result)
+# print(result_2)