327 KiB
327 KiB
Projet algorithme¶
Contexte du projet:¶
L'ADEME a lancé un appel à manifestation d'intérêt pour développer des solutions de mobilité adaptées à différents territoires. CesiCDP, en collaboration avec des partenaires, s'est spécialisé dans la Mobilité Multimodale Intelligente. Dans le cadre de cet appel, l'équipe de CesiCDP travaille sur la gestion de tournées de livraison pour minimiser les trajets et optimiser l'efficacité. L'objectif est d'obtenir de nouveaux marchés et des financements pour poursuivre le développement de l'entreprise. Des contraintes supplémentaires seront ajoutées pour rendre le problème plus réaliste et intéressant pour l'ADEME.
Notre but est de réaliser un algorithme permettant de passer par tous les points de livraisons avec un temps optimisé.
Contraintes choisies :¶
Les contraintes que nous avons choisi sont les suivantes:
- Avoir plusieurs camions disponible simultanément pour effectuer les livraisons.
- Fenêtre de temps de livraison pour chaque object
Formulation du problème¶
Soit un graphe $G=(V,E)$, où $V$ est l'ensemble des villes (ou points de livraison) et $E$ est l'ensemble des routes entre les villes. Chaque ville $v∈V$ a une fenêtre de temps de livraison $[a_v,b_v]$, où $a_v$ est le début de la fenêtre et $b_v$ est la fin de la fenêtre. Il y a $k$ camions disponibles pour effectuer les livraisons.
Le problème consiste à trouver une tournée pour chaque camion, de manière à ce que toutes les livraisons soient effectuées dans leurs fenêtres de temps respectives et que la date de retour du dernier camion à la base soit minimisée.
Le problème que nous avons avec les contraintes ci-dessus est le problème du VRPTW (Vehicule Routing Problem avec la contrainte supplémentaire de fenêtres d'ouverture).
Contraintes du problème¶
Liste des contraintes du problème:
- Tous les clients doivent être déservis
- Un client ne peut être servi que par un et un seul véhicule.
- En quittant un client, un véhicule peut aller que vers un seul autre client.
- Un véhicule ne peut servir un client que s'il a assez de capacité pour servir le client.
On va donc affecter chaque client à une tournée effectué par un seul véhicule.
Modélisation mathématique¶
Ensemble et paramètres:¶
$V=\{0,1,2,...,n\}$ : l'ensemble des villes, où 0 est la base (ou le dépôt) et $1,2,...,n$ sont les villes de livraison.
$K=\{1,2,...,k\}$ : l'ensemble des camions.
$d_{ij}$ : la distance (ou le temps de trajet) de la ville ii à la ville $j$.
$[a_i,b_i]$ : la fenêtre de temps de livraison pour la ville $i$.
$M$ : une grande constante.
Variables de décision:¶
$x_{ijk}$ : variable binaire qui vaut 1 si le camion $k$ se déplace de la ville $i$ à la ville $j$, et 0 sinon.
$t_{ik}$ : le moment où le camion $k$ arrive à la ville $i$.
Fonction objective:¶
Minimiser $Z=max_{k∈K}t_{0k}$
Contraintes:¶
Chaque ville est visitée une fois et une seule fois : $$\sum_{k∈K} \sum_{j∈V} x_{ijk} = 1, ∀i \in V∖ \{0\}$$
Si un camion se déplace de la ville ii à la ville $j$, alors le moment d'arrivée à la ville $j$ doit être plus grand que le moment d'arrivée à la ville $i$ plus le temps de trajet : $$t_{ik}+d_{ij} \leq t_{jk}+M(1−x_{ijk}),∀i,j \in V,i \ne j,∀k \in K$$
Les fenêtres de temps de livraison doivent être respectées : $$a_i \leq t_{ik} \leq b_i, ∀i \in V∖ \{0 \},∀k \in K$$
Les contraintes de flux pour garantir que si un camion entre dans une ville, il doit également en sortir : $$i \in V,i \ne j∑xijk=i∈V,i \ne j∑xjik=yjk,∀j∈V,∀k∈K$$
Nous allons représenter notre problème par un graphe
$G=(V,E)$
$V$ représente les sommets du graphe qui correspondent aux clients
$E$ représente les arcs entre deux clients $i,j \in V$
On a un ensemble $C=\{1,2,...,n_c\}$ de clients qui doivent obtenir leur livraison qui provient du dépot.
L'ensemble des emplacements des clients est défini comme : $V = C \cup \{0, n_c+1\} $
$0$ et $n_c+1$ représente le dépot, puisqu'on doit revenir au point de départ le dépots est le dernier client plus un.
On a un ensemble $V=\{1,2,...,n_v\}$ de véhicule disponible et chaque véhicule possède une capacité $Q$.
Variables de décisions:¶
Variables de décision:
- Un ensemble de k véhicule
Initialisation de la matrice¶
In [46]:
import random import numpy as np import networkx as nx import matplotlib.pyplot as plt def generate_graph(num_nodes): G = nx.Graph() G.add_nodes_from(range(num_nodes + 1)) for node in G.nodes(): connected_nodes = sorted(set(G.nodes()) - {node}) if len(connected_nodes) < 2: continue distance1 = random.randint(1, 10) distance2 = random.randint(1, 10) random_nodes = random.sample(connected_nodes, 2) G.add_edges_from([(node, random_nodes[0], {'distance': distance1}), (node, random_nodes[1], {'distance': distance2})]) while not nx.is_connected(G): node1, node2 = random.sample(G.nodes(), 2) if not G.has_edge(node1, node2): distance = random.randint(1, 10) G.add_edge(node1, node2, distance=distance) # Assigner des positions aléatoires aux nœuds pos = {node: (random.uniform(0, 10), random.uniform(0, 10)) for node in G.nodes()} nx.set_node_attributes(G, pos, 'pos') return G graph = generate_graph(20) A = nx.adjacency_matrix(graph).todense() def generate_distance_matrix(graph): distance_matrix = dict(nx.floyd_warshall(graph)) num_nodes = graph.number_of_nodes() distance_array = np.zeros((num_nodes, num_nodes)) for i, row in distance_matrix.items(): for j, distance in row.items(): distance_array[i][j] = distance return distance_array # Générer la matrice de distances distance_matrix = generate_distance_matrix(graph) # Afficher la matrice de distances print(distance_matrix) print(A) pos = nx.get_node_attributes(graph, 'pos') # Dessiner le graphe nx.draw(graph, with_labels=True) plt.show()
[[0. 2. 2. 2. 3. 1. 3. 2. 3. 3. 1. 3. 2. 1. 2. 2. 3. 2. 2. 2. 1.] [2. 0. 3. 3. 2. 3. 3. 3. 3. 3. 1. 2. 2. 2. 1. 1. 2. 2. 3. 3. 2.] [2. 3. 0. 2. 3. 3. 3. 1. 2. 1. 2. 1. 2. 1. 2. 2. 2. 2. 2. 2. 1.] [2. 3. 2. 0. 2. 1. 2. 3. 2. 2. 3. 2. 1. 1. 2. 2. 2. 1. 1. 2. 2.] [3. 2. 3. 2. 0. 2. 1. 4. 3. 2. 3. 2. 1. 2. 1. 3. 3. 2. 3. 2. 3.] [1. 3. 3. 1. 2. 0. 3. 3. 3. 2. 2. 3. 1. 2. 2. 3. 3. 2. 2. 3. 2.] [3. 3. 3. 2. 1. 3. 0. 3. 2. 3. 3. 3. 2. 2. 2. 2. 2. 1. 3. 1. 2.] [2. 3. 1. 3. 4. 3. 3. 0. 3. 2. 2. 2. 3. 2. 3. 3. 3. 2. 3. 3. 1.] [3. 3. 2. 2. 3. 3. 2. 3. 0. 1. 3. 3. 2. 2. 3. 2. 2. 1. 3. 1. 2.] [3. 3. 1. 2. 2. 2. 3. 2. 1. 0. 3. 2. 1. 2. 2. 2. 1. 2. 3. 2. 2.] [1. 1. 2. 3. 3. 2. 3. 2. 3. 3. 0. 3. 3. 2. 2. 2. 3. 2. 3. 3. 1.] [3. 2. 1. 2. 2. 3. 3. 2. 3. 2. 3. 0. 2. 2. 1. 2. 1. 2. 1. 3. 2.] [2. 2. 2. 1. 1. 1. 2. 3. 2. 1. 3. 2. 0. 2. 1. 3. 2. 2. 2. 3. 3.] [1. 2. 1. 1. 2. 2. 2. 2. 2. 2. 2. 2. 2. 0. 1. 1. 2. 2. 1. 1. 2.] [2. 1. 2. 2. 1. 2. 2. 3. 3. 2. 2. 1. 1. 1. 0. 2. 2. 3. 2. 2. 3.] [2. 1. 2. 2. 3. 3. 2. 3. 2. 2. 2. 2. 3. 1. 2. 0. 1. 1. 2. 2. 2.] [3. 2. 2. 2. 3. 3. 2. 3. 2. 1. 3. 1. 2. 2. 2. 1. 0. 1. 2. 3. 2.] [2. 2. 2. 1. 2. 2. 1. 2. 1. 2. 2. 2. 2. 2. 3. 1. 1. 0. 2. 2. 1.] [2. 3. 2. 1. 3. 2. 3. 3. 3. 3. 3. 1. 2. 1. 2. 2. 2. 2. 0. 2. 3.] [2. 3. 2. 2. 2. 3. 1. 3. 1. 2. 3. 3. 3. 1. 2. 2. 3. 2. 2. 0. 3.] [1. 2. 1. 2. 3. 2. 2. 1. 2. 2. 1. 2. 3. 2. 3. 2. 2. 1. 3. 3. 0.]] [[0 0 0 0 0 1 0 0 0 0 1 0 0 1 0 0 0 0 0 0 1] [0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 1 0 0 0 0 0] [0 0 0 0 0 0 0 1 0 1 0 1 0 1 0 0 0 0 0 0 1] [0 0 0 0 0 1 0 0 0 0 0 0 1 1 0 0 0 1 1 0 0] [0 0 0 0 0 0 1 0 0 0 0 0 1 0 1 0 0 0 0 0 0] [1 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0] [0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0] [0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1] [0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 1 0] [0 0 1 0 0 0 0 0 1 0 0 0 1 0 0 0 1 0 0 0 0] [1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1] [0 0 1 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 1 0 0] [0 0 0 1 1 1 0 0 0 1 0 0 0 0 1 0 0 0 0 0 0] [1 0 1 1 0 0 0 0 0 0 0 0 0 0 1 1 0 0 1 1 0] [0 1 0 0 1 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0] [0 1 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 1 0 0 0] [0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 1 0 1 0 0 0] [0 0 0 1 0 0 1 0 1 0 0 0 0 0 0 1 1 0 0 0 1] [0 0 0 1 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0] [0 0 0 0 0 0 1 0 1 0 0 0 0 1 0 0 0 0 0 0 0] [1 0 1 0 0 0 0 1 0 0 1 0 0 0 0 0 0 1 0 0 0]]
ACO appliqué sur notre graphe¶
In [47]:
import time # Fonction d'évaluation de la qualité d'une solution (ici, la distance totale) def evaluate_solution(solution, distances): total_distance = 0 num_nodes = len(solution) for i in range(num_nodes - 1): current_node = solution[i] next_node = solution[i + 1] total_distance += distances[current_node][next_node] # Ajouter la distance de retour au dépôt total_distance += distances[solution[-1]][solution[0]] return total_distance # Algorithme ACO def ant_colony_optimization(distances, num_ants, num_iterations, evaporation_rate, alpha, beta): num_nodes = len(distances) pheromone = np.ones((num_nodes, num_nodes)) # Matrice de phéromones initiale best_solution = None best_distance = float('inf') start_time = time.time() for iteration in range(num_iterations): # Construction de solutions par les fourmis solutions = [] for ant in range(num_ants): visited = set() current_node = random.randint(0, num_nodes - 1) visited.add(current_node) solution = [current_node] while len(visited) < num_nodes: next_node = None probabilities = [] # Calcul des probabilités de choisir chaque prochain nœud for node in range(num_nodes): if node not in visited: pheromone_value = pheromone[current_node][node] distance_value = distances[current_node][node] probability = (pheromone_value ** alpha) * ((1 / distance_value) ** beta) probabilities.append((node, probability)) total_probability = sum(prob for _, prob in probabilities) probabilities = [(node, prob / total_probability) for node, prob in probabilities] # Choix du prochain nœud basé sur les probabilités roulette_wheel = random.random() probability_sum = 0 for node, probability in probabilities: probability_sum += probability if probability_sum >= roulette_wheel: next_node = node break visited.add(next_node) solution.append(next_node) current_node = next_node # Ajouter le retour au dépôt central à la fin du trajet solution.append(0) solutions.append(solution) # Évaluation des solutions et mise à jour de la meilleure solution for solution in solutions: distance = evaluate_solution(solution, distances) if distance < best_distance: best_solution = solution best_distance = distance # Mise à jour des phéromones pheromone *= evaporation_rate # Évaporation des phéromones existantes for solution in solutions: delta_pheromone = 1 / evaluate_solution(solution, distances) for i in range(num_nodes - 1): node1 = solution[i] node2 = solution[i + 1] pheromone[node1][node2] += delta_pheromone pheromone[node2][node1] += delta_pheromone return best_solution, best_distance num_ants = 10 num_iterations = 50 evaporation_rate = 0.5 alpha = 1 beta = 1 best_solution, best_distance = ant_colony_optimization(distance_matrix, num_ants, num_iterations, evaporation_rate, alpha, beta) print("Meilleure solution :", best_solution) print("Distance totale :", best_distance)
Meilleure solution : [0, 10, 1, 15, 13, 14, 4, 6, 19, 8, 9, 12, 5, 3, 18, 11, 16, 17, 20, 2, 7, 0] Distance totale : 22.0
Tracé du chemin¶
In [96]:
x_values = [graph.nodes[x]['pos'][0] for x in best_solution] y_values = [graph.nodes[x]['pos'][1] for x in best_solution] # Création de la figure et des axes fig, ax = plt.subplots() ax.set_aspect('equal') ax.set_xlabel('Coordonnée X') ax.set_ylabel('Coordonnée Y') ax.set_title("Tracé du trajet emprunté par les fourmis") # Tracer le graphe sans les arêtes nx.draw_networkx_nodes(graph, pos=nx.get_node_attributes(graph, 'pos'), ax=ax) nx.draw_networkx_labels(graph, pos=nx.get_node_attributes(graph, 'pos'), ax=ax) # Tracer uniquement le trajet emprunté par les fourmis ax.plot(x_values, y_values, linestyle='-', marker='o') # Tracer une ligne du dernier nœud au premier nœud pour fermer la boucle ax.plot([x_values[-1], x_values[0]], [y_values[-1], y_values[0]], linestyle='-', color='r') # Afficher le graphique plt.show()
Avec un nombre de camion disponible¶
In [48]:
import concurrent.futures num_trucks = 3 # Nombre de camions disponibles # Fonction d'évaluation de la qualité d'une solution (ici, la distance totale) def evaluate_solution(solution, distances): total_distance = 0 num_nodes = len(solution) for i in range(num_nodes - 1): current_node = solution[i] next_node = solution[i + 1] total_distance += distances[current_node][next_node] #if solution[-1] == 0 and len(solution) < num_nodes: #return float('inf') # Ajouter la distance de retour au dépôt total_distance += distances[solution[-1]][solution[0]] return total_distance def ant_colony_optimization(distances, num_ants, num_iterations, evaporation_rate, alpha, beta, num_trucks): num_nodes = len(distances) pheromone = np.ones((num_nodes, num_nodes)) # Matrice de phéromones initiale best_solution = None best_distance = float('inf') start_time = time.time() for iteration in range(num_iterations): # Construction de solutions par les fourmis solutions = [] for ant in range(num_ants): visited = set() current_node = random.randint(0, num_nodes - 1) visited.add(current_node) solution = [current_node] while len(visited) < num_nodes: next_node = None probabilities = [] # Calcul des probabilités de choisir chaque prochain nœud for node in range(num_nodes): if node not in visited and (node !=0 or len(visited) == num_nodes - 1): pheromone_value = pheromone[current_node][node] distance_value = distances[current_node][node] probability = (pheromone_value ** alpha) * ((1 / distance_value) ** beta) probabilities.append((node, probability)) total_probability = sum(prob for _, prob in probabilities) probabilities = [(node, prob / total_probability) for node, prob in probabilities] roulette_wheel = random.random() probability_sum = 0 for node, probability in probabilities: probability_sum += probability if probability_sum >= roulette_wheel: next_node = node break visited.add(next_node) solution.append(next_node) current_node = next_node # Ajouter le retour au dépôt central à la fin du trajet solution.append(0) solutions.append(solution) # Évaluation des solutions et mise à jour de la meilleure solution for solution in solutions: distance = evaluate_solution(solution, distances) if distance < best_distance: best_solution = solution best_distance = distance # Mise à jour des phéromones pheromone *= evaporation_rate # Évaporation des phéromones existantes for solution in solutions: delta_pheromone = 1 / evaluate_solution(solution, distances) for i in range(num_nodes - 1): node1 = solution[i] node2 = solution[i + 1] pheromone[node1][node2] += delta_pheromone pheromone[node2][node1] += delta_pheromone # Séparer la meilleure solution en trajets pour chaque camion truck_solutions = [] num_nodes_per_truck = num_nodes // num_trucks for i in range(num_trucks): start_index = i * num_nodes_per_truck end_index = start_index + num_nodes_per_truck truck_solution = best_solution[start_index:end_index] truck_solutions.append(truck_solution + [0]) return truck_solutions, best_distance def trucks_thread(i, num_nodes_per_truck, best_solution, truck_solutions): start_index = i * num_nodes_per_truck end_index = start_index + num_nodes_per_truck truck_solution = best_solution[start_index:end_index] truck_solutions.append(truck_solution) return truck_solutions num_ants = 10 num_iterations = 100 evaporation_rate = 0.5 alpha = 1 beta = 1 best_truck_solutions, best_distance = ant_colony_optimization(distance_matrix, num_ants, num_iterations, evaporation_rate, alpha, beta, num_trucks) print("Meilleure solution :", best_truck_solutions) print("Distance totale :", best_distance)
Meilleure solution : [[10, 1, 15, 17, 20, 7, 2, 0], [13, 14, 4, 6, 19, 8, 9, 0], [16, 11, 18, 3, 12, 5, 0, 0]] Distance totale : 21.0
In [8]:
# Créer une liste de couleurs pour chaque véhicule colors = ['red', 'blue', 'green', 'orange', 'purple'] # Ajoutez plus de couleurs si nécessaire # Création de la figure et des axes fig, ax = plt.subplots() ax.set_aspect('equal') ax.set_xlabel('Coordonnée X') ax.set_ylabel('Coordonnée Y') ax.set_title("Tracé du trajet emprunté par les fourmis") # Tracer le graphe sans les arêtes nx.draw_networkx_nodes(graph, pos=nx.get_node_attributes(graph, 'pos'), ax=ax) nx.draw_networkx_labels(graph, pos=nx.get_node_attributes(graph, 'pos'), ax=ax) # Tracer chaque trajet de chaque véhicule avec une couleur différente for i, truck_solution in enumerate(best_truck_solutions): x_values = [graph.nodes[x]['pos'][0] for x in truck_solution] y_values = [graph.nodes[x]['pos'][1] for x in truck_solution] ax.plot(x_values, y_values, linestyle='-', marker='o', color=colors[i % len(colors)]) # Tracer une ligne du dernier nœud au premier nœud pour fermer la boucle ax.plot([x_values[-1], x_values[0]], [y_values[-1], y_values[0]], linestyle='-', color=colors[i % len(colors)]) # Afficher le graphique plt.show()
En rajoutant la contrainte de Time Window pour une instance de VRPTW¶
In [50]:
# 2. Attribuer les fenêtres de temps aux clients def assign_time_windows(graph): # Créer un dictionnaire pour stocker les fenêtres de temps des clients time_windows = {} # Définir la fenêtre de temps pour le dépôt central (nœud 0) time_windows[0] = (0, float('inf')) # Assigner une fenêtre de temps à chaque client for node in graph.nodes(): if node !=0 and node != graph.number_of_nodes() : # Générer une fenêtre de temps aléatoire pour chaque client start_time = random.randint(0, 100) end_time = start_time + random.randint(10, 50) time_windows[node] = (start_time, end_time) return time_windows # Attribuer les fenêtres de temps aux clients time_windows = assign_time_windows(graph) print(max(graph.nodes())) # Afficher les fenêtres de temps assignées for node, window in time_windows.items(): print("Client", node, ":", window) #paramètres ACO print(graph.nodes()) print(graph.edges())
20 Client 0 : (0, inf) Client 1 : (28, 47) Client 2 : (96, 116) Client 3 : (49, 79) Client 4 : (78, 91) Client 5 : (13, 51) Client 6 : (17, 55) Client 7 : (95, 132) Client 8 : (24, 44) Client 9 : (75, 116) Client 10 : (15, 32) Client 11 : (21, 65) Client 12 : (72, 118) Client 13 : (45, 84) Client 14 : (2, 46) Client 15 : (26, 38) Client 16 : (83, 107) Client 17 : (9, 43) Client 18 : (21, 33) Client 19 : (58, 89) Client 20 : (62, 109) [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20] [(0, 5), (0, 13), (0, 10), (0, 20), (1, 10), (1, 14), (1, 15), (2, 13), (2, 20), (2, 7), (2, 9), (2, 11), (3, 13), (3, 18), (3, 5), (3, 12), (3, 17), (4, 14), (4, 12), (4, 6), (5, 12), (6, 17), (6, 19), (7, 20), (8, 9), (8, 17), (8, 19), (9, 16), (9, 12), (10, 20), (11, 16), (11, 14), (11, 18), (12, 14), (13, 14), (13, 19), (13, 15), (13, 18), (15, 16), (15, 17), (16, 17), (17, 20)]
In [52]:
import concurrent.futures import random import numpy as np import time num_trucks = 4 # Nombre de camions disponibles # Fonction d'évaluation de la qualité d'une solution (ici, la distance totale) def evaluate_solution(solution, distances, time_windows): total_distance = 0 total_delay = 0 arrival_time = 0 num_nodes = len(solution) waiting_times = [] for i in range(num_nodes - 1): current_node = solution[i] next_node = solution[i + 1] total_distance += distances[current_node][next_node] arrival_time += distances[current_node][next_node] if arrival_time < time_windows[next_node][0]: waiting_time = time_windows[next_node][0] - arrival_time waiting_times.append((next_node, waiting_time)) arrival_time = time_windows[next_node][0] elif arrival_time > time_windows[next_node][1]: total_delay += arrival_time - time_windows[next_node][1] # Ajouter la distance de retour au dépôt total_distance += distances[solution[-1]][solution[0]] return total_distance, total_delay, waiting_times num_ants = 10 num_iterations = 100 evaporation_rate = 0.5 alpha = 1 beta = 1 def ant_colony_optimization(distances, num_ants, num_iterations, evaporation_rate, alpha, beta, num_trucks): num_nodes = len(distances) pheromone = np.ones((num_nodes, num_nodes)) best_solution = None best_distance = float('inf') best_delay = float('inf') best_score = float('inf') # Initialize the best_score best_waiting_times = None for iteration in range(num_iterations): solutions = [] for ant in range(num_ants): visited = set() current_node = random.randint(0, num_nodes - 1) visited.add(current_node) solution = [current_node] while len(visited) < num_nodes: next_node = None probabilities = [] arrival_time = 0 for node in range(num_nodes): if node not in visited and (node !=0 or len(visited) == num_nodes - 1): pheromone_value = pheromone[current_node][node] distance_value = distances[current_node][node] wait_time = max(0, time_windows[node][0]- (arrival_time + distance_value)) probability = (pheromone_value ** alpha) * ((1 / (distance_value + wait_time)) ** beta) probabilities.append((node, probability)) total_probability = sum(prob for _, prob in probabilities) probabilities = [(node, prob / total_probability) for node, prob in probabilities] roulette_wheel = random.random() probability_sum = 0 for node, probability in probabilities: probability_sum += probability if probability_sum >= roulette_wheel: next_node = node break visited.add(next_node) solution.append(next_node) current_node = next_node solution.append(0) solutions.append(solution) for solution in solutions: distance, delay, waiting_times = evaluate_solution(solution, distances, time_windows) score = distance + delay if score < best_score: best_solution = solution best_distance = distance best_delay = delay best_waiting_times = waiting_times pheromone *= evaporation_rate for solution in solutions: delta_pheromone = 1 / (evaluate_solution(solution, distances, time_windows)[0] + 0.01) for i in range(num_nodes - 1): node1 = solution[i] node2 = solution[i + 1] pheromone[node1][node2] += delta_pheromone pheromone[node2][node1] += delta_pheromone truck_solutions = [] num_nodes_per_truck = num_nodes // num_trucks for i in range(num_trucks): start_index = i * num_nodes_per_truck end_index = start_index + num_nodes_per_truck truck_solution = best_solution[start_index:end_index] truck_solutions.append(truck_solution + [0]) return truck_solutions, best_distance, best_waiting_times best_truck_solutions, best_distance, best_waiting_times = ant_colony_optimization(distance_matrix, num_ants, num_iterations, evaporation_rate, alpha, beta, num_trucks) print("Meilleure solution :", best_truck_solutions) print("Distance totale :", best_distance)
Meilleure solution : [[9, 15, 10, 8, 3, 0], [13, 17, 14, 18, 6, 0], [1, 5, 11, 12, 19, 0], [16, 20, 2, 7, 4, 0]] Distance totale : 51.0