Fix timeout-related issues in tuners (#281)

* SequentialTuner fix

* round up timeout for iOpt.Solver using np.ceil

* refactored _tune in SequentialTuner

* excluded non-project code from PYPI package

* remove redundant try_tree_edit_distance function

golem/core/tuning/iopt_tuner.py

@@ -91,7 +91,7 @@ class GolemProblem(Problem, Generic[DomainGraphForTune]):
 
 class IOptTuner(BaseTuner):
     """
-    Base class for hyperparameters optimization based on hyperopt library
+    Class for hyperparameters optimization based on iOpt library
 
     Args:
         objective_evaluate: objective to optimize
@@ -139,7 +139,8 @@ class IOptTuner(BaseTuner):
                                                   eps_r=np.double(eps_r),
                                                   refine_solution=refine_solution,
                                                   number_of_parallel_points=self.n_jobs,
-                                                  timeout=round(timeout.total_seconds()/60) if self.timeout else -1)
+                                                  # round timeout up to avoid timeout=0 (minutes) passing to iOpt
+                                                  timeout=np.ceil(timeout.total_seconds()/60) if self.timeout else -1)
 
     def _tune(self, graph: DomainGraphForTune, show_progress: bool = True) -> DomainGraphForTune:
         problem_parameters, initial_parameters = self._get_parameters_for_tune(graph)

golem/core/tuning/sequential.py

-from copy import deepcopy
 from datetime import timedelta
 from functools import partial
 from typing import Callable, Optional
@@ -64,8 +63,6 @@ class SequentialTuner(HyperoptTuner):
 
             # Tuning performed sequentially for every node - so get ids of nodes
             nodes_ids = self.get_nodes_order(nodes_number=nodes_amount)
-            final_graph = deepcopy(self.init_graph)
-            best_metric = self.init_metric
             for node_id in nodes_ids:
                 node = graph.nodes[node_id]
 
@@ -75,17 +72,14 @@ class SequentialTuner(HyperoptTuner):
                     self.log.info(f'"{node.name}" operation has no parameters to optimize')
                 else:
                     # Apply tuning for current node
-                    graph, metric = self._optimize_node(node_id=node_id,
-                                                        graph=graph,
-                                                        node_params=node_params,
-                                                        init_params=init_params,
-                                                        iterations_per_node=iterations_per_node,
-                                                        seconds_per_node=seconds_per_node)
-                    if metric <= best_metric:
-                        final_graph = deepcopy(graph)
-                        best_metric = metric
+                    graph, _ = self._optimize_node(node_id=node_id,
+                                                   graph=graph,
+                                                   node_params=node_params,
+                                                   init_params=init_params,
+                                                   iterations_per_node=iterations_per_node,
+                                                   seconds_per_node=seconds_per_node)
             self.was_tuned = True
-        return final_graph
+        return graph
 
     def get_nodes_order(self, nodes_number: int) -> range:
         """ Method returns list with indices of nodes in the graph

golem/core/tuning/tuner_interface.py

@@ -232,7 +232,7 @@ class BaseTuner(Generic[DomainGraphForTune]):
 
     @staticmethod
     def set_arg_node(graph: OptGraph, node_id: int, node_params: dict) -> OptGraph:
-        """ Method for parameters setting to a graph
+        """ Method for parameters setting to a node
 
         Args:
             graph: graph which contains the node
@@ -240,13 +240,13 @@ class BaseTuner(Generic[DomainGraphForTune]):
             node_params: dictionary with labeled parameters to set
 
         Returns:
-            graph with new hyperparameters in each node
+            graph with new hyperparameters in the specified node
         """
 
         # Remove label prefixes
         node_params = convert_parameters(node_params)
 
-        # Update parameters in nodes
+        # Update parameters in the specified node
         graph.nodes[node_id].parameters = node_params
 
         return graph

golem/metrics/edit_distance.py

-from datetime import timedelta, datetime
-from itertools import zip_longest
+from datetime import timedelta
 from typing import Optional, Callable, Dict, Sequence
 
 import networkx as nx
@@ -7,7 +6,6 @@ import numpy as np
 import zss
 from networkx import graph_edit_distance, is_tree
 
-from examples.synthetic_graph_evolution.generators import generate_labeled_graph
 from golem.core.optimisers.optimization_parameters import GraphRequirements
 from golem.metrics.graph_metrics import min_max
 from libs.netcomp import edit_distance
@@ -59,8 +57,7 @@ def get_edit_dist_metric(target_graph: nx.DiGraph,
                          requirements: Optional[GraphRequirements] = None,
                          ) -> Callable[[nx.DiGraph], float]:
     def node_match(node_content_1: Dict, node_content_2: Dict) -> bool:
-        operations_do_match = node_content_1.get('name') == node_content_2.get('name')
-        return True or operations_do_match
+        return node_content_1.get('name') == node_content_2.get('name')
 
     if requirements:
         upper_bound = upper_bound or int(np.sqrt(requirements.max_depth * requirements.max_arity)),
@@ -87,31 +84,3 @@ def matrix_edit_dist(target_graph: nx.DiGraph, graph: nx.DiGraph) -> float:
         adj.resize(shape)
     value = edit_distance(target_adj, adj)
     return value
-
-
-def try_tree_edit_distance(sizes1=None, sizes2=None, node_types=None,
-                           print_trees=False):
-    if not sizes1:
-        sizes1 = list(range(5, 100, 5))
-    if not sizes2:
-        sizes2 = sizes1
-    if not node_types:
-        node_types = ['X']
-
-    for i, (n1, n2) in enumerate(zip_longest(sizes1, sizes2)):
-        g1 = generate_labeled_graph('tree', n1, node_types)
-        g2 = generate_labeled_graph('tree', n2, node_types)
-
-        start_time = datetime.now()
-        dist = tree_edit_dist(g1, g2)
-        duration = datetime.now() - start_time
-
-        print(f'iter {i} with sizes={(n1, n2)} dist={dist}, '
-              f't={duration.total_seconds():.3f}s')
-        if print_trees:
-            print(nx.forest_str(g1))
-            print(nx.forest_str(g2))
-
-
-if __name__ == "__main__":
-    try_tree_edit_distance(print_trees=False, node_types=list('XYZWQ'))

setup.py

@@ -44,7 +44,7 @@ setuptools.setup(
     url=URL,
     python_requires=REQUIRES_PYTHON,
     license=LICENSE,
-    packages=setuptools.find_packages(exclude=['test*']),
+    packages=setuptools.find_packages(exclude=['test*', 'docs*', 'examples*', 'experiments*']),
     include_package_data=True,
     install_requires=_get_requirements('requirements.txt'),
     extras_require={