Merge remote-tracking branch 'origin/Test' into Test

tests/03_cluster_recuit_no_animation_no_random_colling_rate_variation.py

@@ -0,0 +1,87 @@
+import matplotlib.pyplot as plt
+import random, time
+from libs.clustering import split_tour_across_clusters
+from libs.simulated_annealing_stats import SimulatedAnnealing, total_distance
+
+def generate_cities(nb, max_coords=1000):
+    return [random.sample(range(max_coords), 2) for _ in range(nb)]
+
+nb_ville = 100
+max_coords = 1000
+nb_truck = 1
+temperature =  10000
+cooling_rates = [ 0.999 , 0.99, 0.9 , 0.8]
+temperature_ok = 0.001
+
+start_time_generate = time.time()
+cities = [[6734, 1453], [2233, 10], [5530, 1424], [401, 841], [3082, 1644], [7608, 4458], [7573, 3716], [7265, 1268], [6898, 1885], [1112, 2049], [5468, 2606], [5989, 2873], [4706, 2674], [4612, 2035], [6347, 2683], [6107, 669], [7611, 5184], [7462, 3590], [7732, 4723], [5900, 3561], [4483, 3369], [6101, 1110], [5199, 2182], [1633, 2809], [4307, 2322], [675, 1006], [7555, 4819], [7541, 3981], [3177, 756], [7352, 4506], [7545, 2801], [3245, 3305], [6426, 3173], [4608, 1198], [23, 2216], [7248, 3779], [7762, 4595], [7392, 2244], [3484, 2829], [6271, 2135], [4985, 140], [1916, 1569], [7280, 4899], [7509, 3239], [10, 2676], [6807, 2993], [5185, 3258], [3023, 1942]]   
+cities[0] = [max_coords/2, max_coords/2]
+stop_time_generate = time.time()
+
+optimal = 33523
+
+start_time_split = time.time()
+clusters = split_tour_across_clusters(cities, nb_truck)
+stop_time_split = time.time()
+
+for cluster in clusters.values():
+    print(len(cluster))
+print("\n---- TIME ----")
+print("generate cities time: ", stop_time_generate - start_time_generate)
+print("split cities time: ", stop_time_split - start_time_split)
+
+# create new figure for annealing paths
+plt.figure()
+colors = [
+    '#1f77b4',  # Bleu moyen
+    '#ff7f0e',  # Orange
+    '#2ca02c',  # Vert
+    '#9467bd',  # Violet
+    '#d62728',  # Rouge
+    '#8c564b',  # Marron
+    '#e377c2',  # Rose
+    '#7f7f7f',  # Gris
+    '#bcbd22',  # Vert olive
+    '#17becf',  # Turquoise
+    '#1b9e77',  # Vert Teal
+    '#d95f02',  # Orange foncé
+    '#7570b3',  # Violet moyen
+    '#e7298a',  # Fuchsia
+    '#66a61e',  # Vert pomme
+    '#e6ab02',  # Jaune or
+    '#a6761d',  # Bronze
+    '#666666',  # Gris foncé
+    '#f781bf',  # Rose clair
+    '#999999',  # Gris moyen
+]
+
+
+results = []
+
+for cooling_rate in cooling_rates:
+    print(f"\n---- Running with cooling rate: {cooling_rate} ----")
+    
+    distances_over_time = []
+    
+    for i, cluster_indices in enumerate(clusters.values()):
+        cluster_cities = [cities[index] for index in cluster_indices]
+        simulated_annealing = SimulatedAnnealing(cluster_cities, temperature=10000, cooling_rate=cooling_rate, temperature_ok=0.01)
+        best_route, distances = simulated_annealing.run()
+        distances_over_time.extend(distances)
+
+    # Record results for this cooling rate
+    results.append({
+        'cooling_rate': cooling_rate,
+        'distances': distances_over_time,
+    })
+
+# Plotting total distances for each cooling rate over time
+plt.figure()
+for result in results:
+    plt.plot(result['distances'], label=f'Cooling rate: {result["cooling_rate"]}')
+plt.xlabel('Iteration')
+plt.ylabel('Total distance')
+plt.legend(loc='upper right')
+plt.title('Total distance over iterations for different cooling rates')
+plt.axhline(y=optimal, color='black', linestyle='--')
+plt.show()

tests/04_cluster_ant_colony_no_animation_elbow_algo.py

@@ -0,0 +1,111 @@
+from sklearn.cluster import KMeans
+import matplotlib.pyplot as plt
+import numpy as np
+import random, time, math
+from libs.clustering import split_tour_across_clusters
+from libs.aco import AntColony, total_distance
+
+def generate_cities(nb, max_coords=1000):
+    return [random.sample(range(max_coords), 2) for _ in range(nb)]
+
+nb_ville = 1500
+max_coords = 1000
+nb_truck = 2
+max_time = 10
+nb_ants = 10
+
+max_time_per_cluster = max_time / nb_truck
+
+start_time_generate = time.time()
+cities = generate_cities(nb_ville, max_coords)
+stop_time_generate = time.time()
+
+
+start_time_split = time.time()
+clusters = split_tour_across_clusters(cities, nb_truck)
+stop_time_split = time.time()
+
+def elbow_method(cities, max_clusters):
+    inertias = []
+    for i in range(1, max_clusters+1):
+        kmeans = KMeans(n_clusters=i, random_state=0).fit(cities)
+        inertias.append(kmeans.inertia_)
+    return inertias
+
+cities = generate_cities(nb_ville, max_coords) # Assurez-vous que les villes sont générées avant de les passer à la méthode du coude
+inertias = elbow_method(cities, max_clusters=50)
+
+plt.figure()
+plt.plot(range(1, len(inertias)+1), inertias, marker='o')
+plt.title('Elbow Method')
+plt.xlabel('Number of clusters')
+plt.ylabel('Inertia')
+plt.show()
+
+
+
+
+for cluster in clusters.values():
+    print(len(cluster))
+print("\n---- TIME ----")
+print("generate cities time: ", stop_time_generate - start_time_generate)
+print("split cities time: ", stop_time_split - start_time_split)
+
+# create new figure for annealing paths
+plt.figure()
+colors = [
+    '#1f77b4',  # Bleu moyen
+    '#ff7f0e',  # Orange
+    '#2ca02c',  # Vert
+    '#d62728',  # Rouge
+    '#9467bd',  # Violet
+    '#8c564b',  # Marron
+    '#e377c2',  # Rose
+    '#7f7f7f',  # Gris
+    '#bcbd22',  # Vert olive
+    '#17becf',  # Turquoise
+    '#1b9e77',  # Vert Teal
+    '#d95f02',  # Orange foncé
+    '#7570b3',  # Violet moyen
+    '#e7298a',  # Fuchsia
+    '#66a61e',  # Vert pomme
+    '#e6ab02',  # Jaune or
+    '#a6761d',  # Bronze
+    '#666666',  # Gris foncé
+    '#f781bf',  # Rose clair
+    '#999999',  # Gris moyen
+]
+
+best_routes = []
+
+for i, cluster_indices in enumerate(clusters.values()):
+    # Sélection d'une couleur pour le cluster
+    color = colors[i % len(colors)]
+    
+    # Récupération des coordonnées de la ville
+    cluster_cities = [cities[index] for index in cluster_indices]
+
+    # Appel de la fonction AntColony.run
+    ant_colony = AntColony(cluster_cities, n_ants=nb_ants, max_time=max_time_per_cluster, alpha=1, beta=5)
+    best_route = ant_colony.run()
+    best_routes.append((best_route, color))
+
+    print("Total distance for cluster", i, ": ", total_distance(best_route))
+
+# calculate total distance for all clusters
+full_total_distance = 0
+for route, color in best_routes:
+    full_total_distance += total_distance(route)
+
+print("Total distance for all clusters: ", full_total_distance)
+
+for i, (route, color) in enumerate(best_routes):
+    x = [city[0] for city in route]
+    y = [city[1] for city in route]
+    x.append(x[0])
+    y.append(y[0])
+    plt.plot(x, y, color="blue", marker='o', linestyle='-', label=f"Cluster {i}")
+    # add title with nb_ville, nb_truck and max_time
+    plt.title(f"nb_ville = {len(cities)}, nb_truck = {nb_truck}, max_time = {max_time}")   
+
+plt.show()

tests/libs/simulated_annealing_stats.py

@@ -0,0 +1,46 @@
+import math, random
+
+def distance(city1, city2):
+    return math.sqrt((city1[0] - city2[0]) ** 2 + (city1[1] - city2[1]) ** 2)
+
+def total_distance(cities):
+    return sum([distance(cities[i - 1], cities[i]) for i in range(len(cities))])
+
+class SimulatedAnnealing:
+    def __init__(self, cities, temperature=10000, cooling_rate=0.9999, temperature_ok=0.001):
+        self.cities = cities
+        self.temperature = temperature
+        self.cooling_rate = cooling_rate
+        self.temperature_ok = temperature_ok
+        self.distances = []
+        self.temperatures = []
+
+    def run(self):
+        interration = 0
+        current_solution = self.cities.copy()
+        best_solution = self.cities.copy()
+        while self.temperature > self.temperature_ok:
+            new_solution = current_solution.copy()
+            # Swap two cities in the route
+            i = random.randint(0, len(new_solution) - 1)
+            j = random.randint(0, len(new_solution) - 1)
+            new_solution[i], new_solution[j] = new_solution[j], new_solution[i]
+            # Calculate the acceptance probability
+            current_energy = total_distance(current_solution)
+            new_energy = total_distance(new_solution)
+            delta = new_energy - current_energy
+            
+            if delta < 0 or random.random() < math.exp(-delta / self.temperature):
+                current_solution = new_solution
+                if total_distance(current_solution) < total_distance(best_solution):
+                    best_solution = current_solution
+
+            if interration % 10 == 0:
+                self.distances.append(total_distance(current_solution))
+            # Cool down
+            self.temperature *= self.cooling_rate
+            interration += 1
+            # Print every 1000 iterations
+            if interration % 10 == 0:
+                print("Iteration", interration, "with distance", total_distance(current_solution))
+        return best_solution, self.distances