fix verbosity

Author: SimonBlanke

src/hyperactive/composite_optimizer.py

@@ -21,27 +21,28 @@ def run(
         n_processes: Union[str, int] = "auto",
         verbosity: list = ["progress_bar", "print_results", "print_times"],
     ):
-        self.verbosity = verbosity
+        if not verbosity:
+            verbosity = []
 
         self.collected_searches = []
         for optimizer in self.optimizers:
             self.collected_searches += optimizer.searches
 
         for nth_process, search in enumerate(self.collected_searches):
-            search.pass_args(max_time, nth_process)
+            search.pass_args(max_time, nth_process, verbosity)
 
         self.results_list = run_search(
             self.collected_searches, distribution, n_processes
         )
 
         self.results_ = Results(self.results_list, self.collected_searches)
 
-        self._print_info()
+        self._print_info(verbosity)
 
-    def _print_info(self):
-        print_res = PrintResults(self.collected_searches, self.verbosity)
+    def _print_info(self, verbosity):
+        print_res = PrintResults(self.collected_searches, verbosity)
 
-        if self.verbosity:
+        if verbosity:
             for _ in range(len(self.collected_searches)):
                 print("")
 

src/hyperactive/optimizers/_optimizer_api.py

@@ -56,7 +56,6 @@ def add_search(
         n_iter: int,
         search_id=None,
         n_jobs: int = 1,
-        verbosity: list = ["progress_bar", "print_results", "print_times"],
         initialize: Dict[str, int] = {"grid": 4, "random": 2, "vertices": 4},
         constraints: List[callable] = None,
         pass_through: Dict = None,
@@ -97,7 +96,6 @@ def add_search(
 
         search_id = self._default_search_id(search_id, experiment.objective_function)
         s_space = SearchSpace(search_space)
-        self.verbosity = verbosity
 
         n_jobs = mp.cpu_count() if n_jobs == -1 else n_jobs
 
@@ -115,7 +113,6 @@ def add_search(
                 random_state=random_state,
                 memory=memory,
                 memory_warm_start=memory_warm_start,
-                verbosity=verbosity,
             )
             self.searches.append(search)
 
@@ -131,9 +128,10 @@ def run(
         max_time=None,
         distribution: str = "multiprocessing",
         n_processes: Union[str, int] = "auto",
+        verbosity: list = ["progress_bar", "print_results", "print_times"],
     ):
         self.comp_opt = CompositeOptimizer(self)
-        self.comp_opt.run(max_time, distribution, n_processes, self.verbosity)
+        self.comp_opt.run(max_time, distribution, n_processes, verbosity)
 
     def best_para(self, experiment):
         """

src/hyperactive/optimizers/backend_stuff/distribution.py

@@ -22,26 +22,21 @@ def multiprocessing_wrapper(process_func, process_infos, n_processes):
 
     process_infos = tuple(process_infos)
 
-    with mp.Pool(
-        n_processes, initializer=initializer, initargs=initargs
-    ) as pool:
+    print("\n process_infos ", process_infos)
+
+    with mp.Pool(n_processes, initializer=initializer, initargs=initargs) as pool:
         return pool.map(process_func, process_infos)
 
 
 def pathos_wrapper(process_func, search_processes_paras, n_processes):
     import pathos.multiprocessing as pmp
 
-    with pmp.Pool(
-        n_processes, initializer=initializer, initargs=initargs
-    ) as pool:
+    with pmp.Pool(n_processes, initializer=initializer, initargs=initargs) as pool:
         return pool.map(process_func, search_processes_paras)
 
 
 def joblib_wrapper(process_func, search_processes_paras, n_processes):
     from joblib import Parallel, delayed
 
-    jobs = [
-        delayed(process_func)(*info_dict)
-        for info_dict in search_processes_paras
-    ]
+    jobs = [delayed(process_func)(*info_dict) for info_dict in search_processes_paras]
     return Parallel(n_jobs=n_processes)(jobs)

src/hyperactive/optimizers/search.py

@@ -30,7 +30,6 @@ def setup(
         random_state,
         memory,
         memory_warm_start,
-        verbosity,
     ):
         self.experiment = experiment
         self.s_space = s_space
@@ -44,17 +43,16 @@ def setup(
         self.random_state = random_state
         self.memory = memory
         self.memory_warm_start = memory_warm_start
-        self.verbosity = verbosity
 
-        if "progress_bar" in self.verbosity:
+    def pass_args(self, max_time, nth_process, verbosity):
+        self.max_time = max_time
+        self.nth_process = nth_process
+
+        if "progress_bar" in verbosity:
             self.verbosity = ["progress_bar"]
         else:
             self.verbosity = []
 
-    def pass_args(self, max_time, nth_process):
-        self.max_time = max_time
-        self.nth_process = nth_process
-
     def convert_results2hyper(self):
         self.eval_times = sum(self.gfo_optimizer.eval_times)
         self.iter_times = sum(self.gfo_optimizer.iter_times)
@@ -86,15 +84,12 @@ def _setup_process(self):
 
         # conv warm start for smbo from values into positions
         if "warm_start_smbo" in self.opt_params:
-            self.opt_params["warm_start_smbo"] = (
-                self.hg_conv.conv_memory_warm_start(
-                    self.opt_params["warm_start_smbo"]
-                )
+            self.opt_params["warm_start_smbo"] = self.hg_conv.conv_memory_warm_start(
+                self.opt_params["warm_start_smbo"]
             )
 
         gfo_constraints = [
-            Constraint(constraint, self.s_space)
-            for constraint in self.constraints
+            Constraint(constraint, self.s_space) for constraint in self.constraints
         ]
 
         self.gfo_optimizer = self.optimizer_class(
@@ -116,9 +111,7 @@ def _search(self, p_bar):
         )
         gfo_wrapper_model.pass_through = self.pass_through
 
-        memory_warm_start = self.hg_conv.conv_memory_warm_start(
-            self.memory_warm_start
-        )
+        memory_warm_start = self.hg_conv.conv_memory_warm_start(self.memory_warm_start)
 
         gfo_objective_function = gfo_wrapper_model(self.s_space())