minor fixes

Author: VirtualRoyalty

algorithm/guided_local_search.py

@@ -52,14 +52,11 @@ def solve(self):
             cost = tools.compute_solution(self.problem, tmp_solution)
             self.history.append(cost)
             if self.cur_cost > cost:
-                # print('less')
                 self.solution = tmp_solution
                 self.cur_cost = cost
                 self.last_state = epoch
                 unimprove_counter = 0
             else:
-                # self.solution = tmp_solution
-                # self.cur_cost = cost
                 no_improve_counter += 1
             self.update_penalty()
             self.refresh_params()
@@ -78,19 +75,13 @@ def update_penalty(self):
         self.utility = np.zeros((self.n, self.n), dtype=np.float32)
         for i in range(self.n):
             for j in range(self.n):
-                # dist = self.dist[self.solution[i]][self.solution[j]]
                 dist = self.dist[i][self.solution[i]]
                 flow = self.flow[i][j]
                 c    = dist * flow
-                # self.utility[self.solution[i]][self.solution[j]] = \
-                #         c / (1 + self.penalty[self.solution[i]][self.solution[j]])
                 self.utility[i][self.solution[i]] = \
                         c / (1 + self.penalty[i][self.solution[i]])
         maximized = self.utility.max()
         for i in range(self.n):
-            # for j in range(self.n):
-            #     if self.utility[self.solution[i]][self.solution[j]] == maximized:
-            #         self.penalty[self.solution[i]][self.solution[j]] += 1
             if self.utility[i][self.solution[i]] == maximized:
                 self.penalty[i][self.solution[i]] += 1
 
@@ -101,13 +92,9 @@ def augmented_cost(problem, solution, params):
         mu      = params['mu']
         n       = params['n']
         total_penalty = 0
-        # for i in range(n):
-        #     for j in range(n):
-        #         total_penalty += penalty[solution[i]][solution[j]]
         for i in range(n):
             total_penalty += penalty[i][solution[i]]
         _lambda = cost / n
-        # print( mu * _lambda )
         return cost + mu * _lambda * total_penalty
 
 
@@ -139,5 +126,4 @@ def get_history(self):
         plt.grid()
         plt.legend()
         plt.title(self.name)
-        # plt.show()
         return self.history

utils/tools.py

@@ -30,55 +30,3 @@ def get_problem_dct(path) -> dict:
     return dict(n=n,
                 dists=distances,
                 flows=flows)
-
-
-def generate_stat(algorithms,
-                  benchmarks,
-                  alg_params,
-                  n_observations=3,
-                  **params):
-
-    for algorithm, params in zip(algorithms, alg_params):
-        test_knap = dict(benchmarks[1], **params)
-        assert isinstance(algorithm(test_knap), Algorithm)
-
-    info_dct    = {
-                     'algorithm':     [],
-                     'benchmark':     [],
-                     'capacity':      [],
-                     'preprocessing': [],
-                     'execution':     [],
-                     'observation':   [],
-                     'optim_weight':  [],
-                     'optim_profit':  [],
-                   }
-    for observation in range(n_observations):
-
-        for key in benchmarks:
-
-            knapsack = benchmarks[key]
-
-            for algorithm, params in zip(algorithms, alg_params):
-
-                knapsack = dict(knapsack, **params)
-
-                start_time = datetime.now()
-                alg = algorithm(knapsack)
-                preprocess = datetime.now() - start_time
-
-                start_time = datetime.now()
-                optimal    = alg.solve()
-                execution  = datetime.now() - start_time
-
-                w, p = compute_knapsack(knapsack, optimal)
-
-
-                info_dct['algorithm']     += [alg.name]
-                info_dct['benchmark']     += [key]
-                info_dct['capacity']      += [knapsack['capacity'][0]]
-                info_dct['preprocessing'] += [preprocess.total_seconds()]
-                info_dct['execution']     += [execution.total_seconds()]
-                info_dct['observation']   += [observation]
-                info_dct['optim_weight']  += [w]
-                info_dct['optim_profit']  += [p]
-    return pd.DataFrame.from_dict(info_dct)