pycombinatorial 2.1.4__tar.gz → 2.1.7__tar.gz

{pycombinatorial-2.1.4 → pycombinatorial-2.1.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pycombinatorial
-Version: 2.1.4
+Version: 2.1.7
 Summary: A library to solve TSP (Travelling Salesman Problem) using Exact Algorithms, Heuristics, Metaheuristics and Reinforcement Learning
 Home-page: https://github.com/Valdecy/pyCombinatorial
 Author: Valdecy Pereira
@@ -121,7 +121,7 @@ print('Total Distance: ', round(distance, 2))
 - Space Filling Curve (Hilbert) ([ Colab Demo ](https://colab.research.google.com/drive/1FXzWrUBjdbJBngRFHv66CZw5pFN3yOs8?usp=sharing)) ( [ Paper ](https://doi.org/10.1016/0960-0779(95)80046-J))
 - Space Filling Curve (Morton) ([ Colab Demo ](https://colab.research.google.com/drive/1Z13kXyi7eaNQbBUmhvwuQjY4VaUfGVbs?usp=sharing)) ( [ Paper ](https://dominoweb.draco.res.ibm.com/reports/Morton1966.pdf))
 - Space Filling Curve (Sierpinski) ([ Colab Demo ](https://colab.research.google.com/drive/1w-Zptd5kOryCwvQ0qSNBNhPXC61c8QXF?usp=sharing)) ( [ Paper ](https://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.67.9061&rep=rep1&type=pdf))
-- Spectral Seriation Initializer ([ Colab Demo ](https://colab.research.google.com/drive/1lG0pYxASU75qh0jK-A_eMCoPpCWv0I4V?usp=sharing)) ( [ Paper ](https://doi.org/10.1137/S009753979528577))
+- Spectral Seriation Initializer ([ Colab Demo ](https://colab.research.google.com/drive/1lG0pYxASU75qh0jK-A_eMCoPpCWv0I4V?usp=sharing)) ( [ Paper ](https://doi.org/10.1137/S0097539795285771))
 - Stochastic Hill Climbing ([ Colab Demo ](https://colab.research.google.com/drive/1_wP6vg4JoRHGItGxEtXcf9Y9OuuoDlDl?usp=sharing)) ( [ Paper ](http://aima.cs.berkeley.edu/)) 
 - Sweep ([ Colab Demo ](https://colab.research.google.com/drive/1AkAn4yeomAp6POBslk3Asd6OrxfBrHT7?usp=sharing)) ( [ Paper ](http://dx.doi.org/10.1287/opre.22.2.340))
 - Tabu Search ([ Colab Demo ](https://colab.research.google.com/drive/1SRwQrBaxkKk18SDvQPy--0yNRWdl6Y1G?usp=sharing)) ( [ Paper ](https://doi.org/10.1287/ijoc.1.3.190))

{pycombinatorial-2.1.4 → pycombinatorial-2.1.7}/README.md

@@ -110,7 +110,7 @@ print('Total Distance: ', round(distance, 2))
 - Space Filling Curve (Hilbert) ([ Colab Demo ](https://colab.research.google.com/drive/1FXzWrUBjdbJBngRFHv66CZw5pFN3yOs8?usp=sharing)) ( [ Paper ](https://doi.org/10.1016/0960-0779(95)80046-J))
 - Space Filling Curve (Morton) ([ Colab Demo ](https://colab.research.google.com/drive/1Z13kXyi7eaNQbBUmhvwuQjY4VaUfGVbs?usp=sharing)) ( [ Paper ](https://dominoweb.draco.res.ibm.com/reports/Morton1966.pdf))
 - Space Filling Curve (Sierpinski) ([ Colab Demo ](https://colab.research.google.com/drive/1w-Zptd5kOryCwvQ0qSNBNhPXC61c8QXF?usp=sharing)) ( [ Paper ](https://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.67.9061&rep=rep1&type=pdf))
-- Spectral Seriation Initializer ([ Colab Demo ](https://colab.research.google.com/drive/1lG0pYxASU75qh0jK-A_eMCoPpCWv0I4V?usp=sharing)) ( [ Paper ](https://doi.org/10.1137/S009753979528577))
+- Spectral Seriation Initializer ([ Colab Demo ](https://colab.research.google.com/drive/1lG0pYxASU75qh0jK-A_eMCoPpCWv0I4V?usp=sharing)) ( [ Paper ](https://doi.org/10.1137/S0097539795285771))
 - Stochastic Hill Climbing ([ Colab Demo ](https://colab.research.google.com/drive/1_wP6vg4JoRHGItGxEtXcf9Y9OuuoDlDl?usp=sharing)) ( [ Paper ](http://aima.cs.berkeley.edu/)) 
 - Sweep ([ Colab Demo ](https://colab.research.google.com/drive/1AkAn4yeomAp6POBslk3Asd6OrxfBrHT7?usp=sharing)) ( [ Paper ](http://dx.doi.org/10.1287/opre.22.2.340))
 - Tabu Search ([ Colab Demo ](https://colab.research.google.com/drive/1SRwQrBaxkKk18SDvQPy--0yNRWdl6Y1G?usp=sharing)) ( [ Paper ](https://doi.org/10.1287/ijoc.1.3.190))

{pycombinatorial-2.1.4 → pycombinatorial-2.1.7}/pyCombinatorial/algorithm/aco.py

@@ -62,41 +62,52 @@ def update_thau(distance_matrix, thau, city_list):
     return thau
 
 # Function: Generate Ant Paths
-def ants_path(distance_matrix, h, thau, alpha, beta, full_list, ants, local_search):
-    best_path_distance = float('inf')
+def ants_path(distance_matrix, h, thau, alpha, beta, full_list, ants, local_search, deposit_mode = 'all'):
+    best_path_distance = float("inf")
     best_city_list     = None
+    all_tours          = []
     for _ in range(0, ants):
         city_list = [np.random.choice(full_list)]
-        while (len(city_list) < len(full_list)):
-            current_city  = city_list[-1]
-            probabilities = []
-            for next_city in full_list:
-                if (next_city not in city_list):
-                    p = (thau[current_city-1, next_city-1] ** alpha) * (h[current_city-1, next_city-1] ** beta)
-                    probabilities.append(p)
-                else:
-                    probabilities.append(0)
-            probabilities = np.array(probabilities) / np.sum(probabilities)
-            next_city     = np.random.choice(full_list, p = probabilities)
+        while len(city_list) < len(full_list):
+            current_city = city_list[-1]
+            candidates   = [c for c in full_list if c not in city_list]
+            weights      = []
+            for nxt in candidates:
+                tau = thau[current_city - 1, nxt - 1]
+                eta = h[current_city - 1, nxt - 1]
+                w   = (tau ** alpha) * (eta ** beta)
+                weights.append(w)
+            weights = np.array(weights, dtype = float)
+            s       = weights.sum()
+            if s <= 0 or not np.isfinite(s):
+                next_city = np.random.choice(candidates)
+            else:
+                probs     = weights / s
+                next_city = np.random.choice(candidates, p = probs)
             city_list.append(next_city)
         path_distance = calculate_distance(distance_matrix, city_list)
-        if (path_distance < best_path_distance):
-            best_city_list     = copy.deepcopy(city_list)
+        if path_distance < best_path_distance:
             best_path_distance = path_distance
-            
-    if (local_search == True):
+            best_city_list     = copy.deepcopy(city_list)
+        if deposit_mode == "all":
+            all_tours.append((city_list, path_distance))
+    if local_search:
         best_city_list, best_path_distance = local_search_2_opt(distance_matrix, city_tour = [best_city_list, best_path_distance])
-    thau = update_thau(distance_matrix, thau, city_list = best_city_list)
+    if deposit_mode == "all":
+        for tour, dist in all_tours:
+            thau = update_thau(distance_matrix, thau, city_list = tour)
+    else:
+        thau = update_thau(distance_matrix, thau, city_list = best_city_list)
     return best_city_list, best_path_distance, thau
 
 ############################################################################
 
 # ACO Function
-def ant_colony_optimization(distance_matrix, ants = 5, iterations = 50, alpha = 1, beta = 2, decay = 0.05, local_search = True, verbose = True):
+def ant_colony_optimization(distance_matrix, ants = 15, iterations = 100, alpha = 1, beta = 2, decay = 0.05, local_search = True, verbose = True):
     count      = 0
     best_route = []
     full_list  = list(range(1, distance_matrix.shape[0] + 1))
-    distance   = np.sum(distance_matrix.sum())
+    distance   = float('inf')
     h          = attractiveness(distance_matrix)
     thau       = np.ones((distance_matrix.shape[0], distance_matrix.shape[0]))
     while (count <= iterations):

{pycombinatorial-2.1.4 → pycombinatorial-2.1.7}/pyCombinatorial/algorithm/alns.py

@@ -80,10 +80,12 @@ def local_search_2_opt(distance_matrix, city_tour, recursive_seeding = -1, verbo
 # Function: Removal
 def removal_operators():
     def random_removal(city_tour, num_removals):
-        removed = set()
-        while (len(removed) < num_removals):
-            removed.add(random.choice(city_tour[1:]))
-        return list(removed)
+        available = city_tour[1:]
+        if (len(available) == 0):
+            return []
+        k = int(num_removals)
+        k = max(1, min(k, len(available)))
+        return random.sample(available, k)
     return [random_removal]
 
 # Function: Insertion
@@ -104,7 +106,7 @@ def insertion_operators():
 ############################################################################
 
 # Function: Adaptive Large Neighborhood Search
-def adaptive_large_neighborhood_search(distance_matrix, iterations = 100, removal_fraction = 0.2, rho = 0.1, local_search = True, verbose = True):
+def adaptive_large_neighborhood_search(distance_matrix, iterations = 100, removal_fraction = 0.2, rho = 0.1, local_search = True, verbose = True, sa = True, t0 = None, cooling = 0.995):
     initial_tour       = list(range(0, distance_matrix.shape[0]))
     random.shuffle(initial_tour)
     route              = initial_tour.copy()
@@ -113,20 +115,29 @@ def adaptive_large_neighborhood_search(distance_matrix, iterations = 100, remova
     insertion_ops      = insertion_operators()
     weights_removal    = [1.0] * len(removal_ops)
     weights_insertion  = [1.0] * len(insertion_ops)
+    rho                = max(0.0, min(float(rho), 0.99))
+    temp               = float(distance) if (t0 is None) else float(t0)
+    temp               = max(temp, 1e-12)
     count              = 0
-    while (count <= iterations):
+    while (count < iterations):
         if (verbose == True and count > 0):
             print('Iteration = ', count, 'Distance = ', round(distance, 2))     
         city_tour     = route.copy()
         removal_op    = random.choices(removal_ops,   weights = weights_removal)[0]
         insertion_op  = random.choices(insertion_ops, weights = weights_insertion)[0]
         num_removals  = int(removal_fraction * distance_matrix.shape[0])
+        num_removals  = max(1, num_removals)
+        num_removals  = min(num_removals, max(1, len(city_tour) - 1))
         removed_nodes = removal_op(city_tour, num_removals)
         for node in removed_nodes:
             city_tour.remove(node)
         new_tour          = insertion_op(removed_nodes, city_tour, distance_matrix)
         new_tour_distance = distance_point(distance_matrix, new_tour)
-        if (new_tour_distance < distance):
+        delta  = new_tour_distance - distance
+        accept = (delta < 0)
+        if (sa == True and accept == False):
+            accept = (random.random() < np.exp(-delta / temp))
+        if (accept == True):
             route                                                = new_tour
             distance                                             = new_tour_distance
             weights_removal[removal_ops.index(removal_op)]       = weights_removal[removal_ops.index(removal_op)]       * (1 + rho)
@@ -138,6 +149,8 @@ def adaptive_large_neighborhood_search(distance_matrix, iterations = 100, remova
         total_weight_insertion = sum(weights_insertion)
         weights_removal        = [w / total_weight_removal   for w in weights_removal]
         weights_insertion      = [w / total_weight_insertion for w in weights_insertion]
+        if (sa == True):
+            temp = max(temp * cooling, 1e-12)
         count                  = count + 1
     route = route + [route[0]]
     route = [item + 1 for item in route]

{pycombinatorial-2.1.4 → pycombinatorial-2.1.7}/pyCombinatorial/algorithm/opt_4.py

@@ -145,7 +145,7 @@ def local_search_4_opt(distance_matrix, city_tour, recursive_seeding = -1, verbo
                            [a + c + b + d],
                            [a + c + d + b],
                            
-                         ]   
+                         ]  
             for item in trial:   
                 best_route_1[0] = item[0]
                 best_route_1[1] = distance_calc(distance_matrix, [best_route_1[0] + [best_route_1[0][0]], 1])

{pycombinatorial-2.1.4 → pycombinatorial-2.1.7}/pycombinatorial.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pycombinatorial
-Version: 2.1.4
+Version: 2.1.7
 Summary: A library to solve TSP (Travelling Salesman Problem) using Exact Algorithms, Heuristics, Metaheuristics and Reinforcement Learning
 Home-page: https://github.com/Valdecy/pyCombinatorial
 Author: Valdecy Pereira
@@ -121,7 +121,7 @@ print('Total Distance: ', round(distance, 2))
 - Space Filling Curve (Hilbert) ([ Colab Demo ](https://colab.research.google.com/drive/1FXzWrUBjdbJBngRFHv66CZw5pFN3yOs8?usp=sharing)) ( [ Paper ](https://doi.org/10.1016/0960-0779(95)80046-J))
 - Space Filling Curve (Morton) ([ Colab Demo ](https://colab.research.google.com/drive/1Z13kXyi7eaNQbBUmhvwuQjY4VaUfGVbs?usp=sharing)) ( [ Paper ](https://dominoweb.draco.res.ibm.com/reports/Morton1966.pdf))
 - Space Filling Curve (Sierpinski) ([ Colab Demo ](https://colab.research.google.com/drive/1w-Zptd5kOryCwvQ0qSNBNhPXC61c8QXF?usp=sharing)) ( [ Paper ](https://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.67.9061&rep=rep1&type=pdf))
-- Spectral Seriation Initializer ([ Colab Demo ](https://colab.research.google.com/drive/1lG0pYxASU75qh0jK-A_eMCoPpCWv0I4V?usp=sharing)) ( [ Paper ](https://doi.org/10.1137/S009753979528577))
+- Spectral Seriation Initializer ([ Colab Demo ](https://colab.research.google.com/drive/1lG0pYxASU75qh0jK-A_eMCoPpCWv0I4V?usp=sharing)) ( [ Paper ](https://doi.org/10.1137/S0097539795285771))
 - Stochastic Hill Climbing ([ Colab Demo ](https://colab.research.google.com/drive/1_wP6vg4JoRHGItGxEtXcf9Y9OuuoDlDl?usp=sharing)) ( [ Paper ](http://aima.cs.berkeley.edu/)) 
 - Sweep ([ Colab Demo ](https://colab.research.google.com/drive/1AkAn4yeomAp6POBslk3Asd6OrxfBrHT7?usp=sharing)) ( [ Paper ](http://dx.doi.org/10.1287/opre.22.2.340))
 - Tabu Search ([ Colab Demo ](https://colab.research.google.com/drive/1SRwQrBaxkKk18SDvQPy--0yNRWdl6Y1G?usp=sharing)) ( [ Paper ](https://doi.org/10.1287/ijoc.1.3.190))

{pycombinatorial-2.1.4 → pycombinatorial-2.1.7}/setup.py

@@ -6,7 +6,7 @@ long_description = (this_directory / 'README.md').read_text()
 
 setup(
     name='pycombinatorial',
-    version='2.1.4',
+    version='2.1.7',
     license='GNU',
     author='Valdecy Pereira',
     author_email='valdecy.pereira@gmail.com',