الگوریتم کلونی مورچگان (ACO): الهام‌گیری از طبیعت برای حل مسائل بهینه‌سازی 🐜✨

import numpy as np

class ACO_TSP:
    def __init__(self, distances, n_ants=10, n_iter=100, alpha=1, beta=2, rho=0.1, Q=1):
        self.distances = distances
        self.n_ants = n_ants
        self.n_iter = n_iter
        self.alpha = alpha
        self.beta = beta
        self.rho = rho
        self.Q = Q
        self.n_cities = len(distances)
        self.pheromone = np.ones((self.n_cities, self.n_cities))

    def run(self):
        best_path = None
        best_distance = float('inf')
        
        for _ in range(self.n_iter):
            paths = self._build_paths()
            self._update_pheromone(paths)
            
            current_best = min(paths, key=lambda x: x[1])
            if current_best[1] < best_distance:
                best_path, best_distance = current_best
                
        return best_path, best_distance

    def _build_paths(self):
        paths = []
        for _ in range(self.n_ants):
            path = [0]  # شروع از شهر 0
            visited = set([0])
            
            while len(path) < self.n_cities:
                current = path[-1]
                probs = []
                for city in range(self.n_cities):
                    if city not in visited:
                        phe = self.pheromone[current][city] ** self.alpha
                        eta = (1 / self.distances[current][city]) ** self.beta
                        probs.append(phe * eta)
                    else:
                        probs.append(0)
                        
                probs = np.array(probs) / sum(probs)
                next_city = np.random.choice(range(self.n_cities), p=probs)
                path.append(next_city)
                visited.add(next_city)
            
            path.append(0)  # بازگشت به شهر شروع
            distance = sum(self.distances[path[i]][path[i+1]] for i in range(len(path)-1))
            paths.append((path, distance))
            
        return paths

    def _update_pheromone(self, paths):
        self.pheromone *= (1 - self.rho)  # تبخیر
        for path, distance in paths:
            contribution = self.Q / distance
            for i in range(len(path)-1):
                self.pheromone[path[i]][path[i+1]] += contribution

# مثال:
distances = [
    [0, 2, 5, 1, 3],
    [2, 0, 4, 6, 2],
    [5, 4, 0, 3, 7],
    [1, 6, 3, 0, 4],
    [3, 2, 7, 4, 0]
]

aco = ACO_TSP(distances, n_ants=15, n_iter=200)
best_path, best_distance = aco.run()
print(f"بهترین مسیر: {best_path}، کمترین مسافت: {best_distance}")