Override __repr__ method

Author: lixfz

hypernets/core/searcher.py

@@ -2,9 +2,11 @@
 """
 
 """
-from .stateful import Stateful
 import enum
 
+from hypernets.utils import to_repr
+from .stateful import Stateful
+
 
 class OptimizeDirection(enum.Enum):
     Minimize = 'min'
@@ -63,3 +65,6 @@ def reset(self):
 
     def export(self):
         raise NotImplementedError
+
+    def __repr__(self):
+        return to_repr(self)

hypernets/core/trial.py

@@ -6,6 +6,7 @@
 import os
 import pickle
 import shutil
+from collections import OrderedDict
 
 import pandas as pd
 
@@ -80,6 +81,13 @@ def __getstate__(self):
         state = {k: v for k, v in state.items() if k != 'memo'}
         return state
 
+    def to_df(self, include_params=False):
+        out = OrderedDict(trial_no=self.trial_no, succeeded=self.succeeded, reward=self.reward, elapsed=self.elapsed)
+        if include_params:
+            for p in self.space_sample.get_assigned_params():
+                out[p.alias] = p.value
+        return pd.DataFrame({k: [v] for k, v in out.items()})
+
 
 class TrialHistory():
     def __init__(self, optimize_direction):
@@ -111,15 +119,23 @@ def get_best(self):
         else:
             return top1[0]
 
-    def get_top(self, n=10):
+    def get_worst(self):
+        topn = self.get_top()
+        return topn[-1] if len(topn) > 0 else None
+
+    def get_top(self, n=None):
+        assert n is None or isinstance(n, int)
+
         valid_trials = [t for t in self.trials if t.succeeded]
         if len(valid_trials) <= 0:
             return []
         sorted_trials = sorted(valid_trials, key=lambda t: t.reward,
                                reverse=self.optimize_direction in ['max', OptimizeDirection.Maximize])
-        if n > len(sorted_trials):
-            n = len(sorted_trials)
-        return sorted_trials[:n]
+
+        if isinstance(n, int) and n < len(sorted_trials):
+            sorted_trials = sorted_trials[:n]
+
+        return sorted_trials
 
     def get_space_signatures(self):
         signatures = set()
@@ -200,6 +216,24 @@ def load_history(space_fn, filepath):
                 history.append(trial)
             return history
 
+    def __repr__(self):
+        out = OrderedDict(direction=self.optimize_direction)
+        if len(self.trials) > 0:
+            tops = self.get_top()
+            out['size'] = len(self.trials)
+            out['succeeded'] = len(tops)
+            if len(tops) > 0:
+                out['best_reward'] = tops[0].reward
+                out['worst_reward'] = tops[-1].reward
+
+        repr_ = ', '.join('%s=%r' % (k, v) for k, v in out.items())
+        return f'{type(self).__name__}({repr_})'
+
+    def to_df(self, include_params=False):
+        df = pd.concat([t.to_df(include_params) for t in self.trials], axis=0)
+        df.reset_index(drop=True, inplace=True)
+        return df
+
     def plot_hyperparams(self, destination='notebook', output='hyperparams.html'):
         """Plot hyperparams in a parallel line chart
 

hypernets/model/hyper_model.py

@@ -10,7 +10,7 @@
 from ..core.trial import *
 from ..discriminators import UnPromisingTrial
 from ..dispatchers import get_dispatcher
-from ..utils import logging, infer_task_type as _infer_task_type, hash_data, const
+from ..utils import logging, infer_task_type as _infer_task_type, hash_data, const, to_repr
 
 logger = logging.get_logger(__name__)
 
@@ -97,6 +97,11 @@ def _run_trial(self, space_sample, trial_no, X, y, X_eval, y_eval, cv=False, num
             elapsed = time.time() - start_time
             trial = Trial(space_sample, trial_no, 0, elapsed, succeeded=succeeded)
 
+            if self.history is not None:
+                t = self.history.get_worst()
+                if t is not None:
+                    self.searcher.update_result(space_sample, t.reward)
+
         return trial
 
     def _get_reward(self, value, key=None):
@@ -220,3 +225,6 @@ def infer_task_type(self, y):
 
     def plot_hyperparams(self, destination='notebook', output='hyperparams.html'):
         return self.history.plot_hyperparams(destination, output)
+
+    def __repr__(self):
+        return to_repr(self)

hypernets/searchers/evolution_searcher.py

@@ -2,10 +2,9 @@
 """
 
 """
-import numpy as np
 
-from ..core.searcher import Searcher, OptimizeDirection
 from ..core import get_random_state
+from ..core.searcher import Searcher, OptimizeDirection
 from ..utils import logging
 
 logger = logging.get_logger(__name__)
@@ -96,6 +95,7 @@ class EvolutionSearcher(Searcher):
     ----------
         Real, Esteban, et al. "Regularized evolution for image classifier architecture search." Proceedings of the aaai conference on artificial intelligence. Vol. 33. 2019.
     """
+
     def __init__(self, space_fn, population_size, sample_size, regularized=False,
                  candidates_size=10, optimize_direction=OptimizeDirection.Minimize, use_meta_learner=True,
                  space_sample_validation_fn=None, random_state=None):
@@ -123,10 +123,15 @@ def __init__(self, space_fn, population_size, sample_size, regularized=False,
         Searcher.__init__(self, space_fn=space_fn, optimize_direction=optimize_direction,
                           use_meta_learner=use_meta_learner, space_sample_validation_fn=space_sample_validation_fn)
         self.random_state = random_state if random_state is not None else get_random_state()
-        self.population = Population(size=population_size, optimize_direction=optimize_direction, random_state=self.random_state)
+        self.population = Population(size=population_size, optimize_direction=optimize_direction,
+                                     random_state=self.random_state)
         self.sample_size = sample_size
         self.regularized = regularized
-        self.candidate_size = candidates_size
+        self.candidates_size = candidates_size
+
+    @property
+    def population_size(self):
+        return self.population.size
 
     @property
     def parallelizable(self):
@@ -151,7 +156,7 @@ def _get_offspring(self, space_sample):
             candidates = []
             scores = []
             no = 0
-            for i in range(self.candidate_size):
+            for i in range(self.candidates_size):
                 new_space = self.space_fn()
                 try:
                     candidate = self._sample_and_check(lambda: self.population.mutate(space_sample, new_space))

hypernets/searchers/mcts_searcher.py

@@ -39,7 +39,11 @@ def __init__(self, space_fn, policy=None, max_node_space=10, candidates_size=10,
         Searcher.__init__(self, space_fn, optimize_direction, use_meta_learner=use_meta_learner,
                           space_sample_validation_fn=space_sample_validation_fn)
         self.nodes_map = {}
-        self.candidate_size = candidates_size
+        self.candidates_size = candidates_size
+
+    @property
+    def max_node_space(self):
+        return self.tree.max_node_space
 
     def parallelizable(self):
         return self.use_meta_learner and self.meta_learner is not None
@@ -71,7 +75,7 @@ def sample():
     def _select_best_candidate(self, node):
         candidates = []
         scores = []
-        for i in range(self.candidate_size):
+        for i in range(self.candidates_size):
             candidate = self._roll_out(node)
             candidates.append(candidate)
             scores.append(self.meta_learner.predict(candidate, 0.5))

hypernets/searchers/playback_searcher.py

@@ -8,13 +8,13 @@
 
 
 class PlaybackSearcher(Searcher):
-    def __init__(self, trail_history: TrialHistory, top_n=None, reverse=False,
+    def __init__(self, history: TrialHistory, top_n=None, reverse=False,
                  optimize_direction=OptimizeDirection.Minimize):
-        assert trail_history is not None
-        assert len(trail_history.trials) > 0
+        assert history is not None
+        assert len(history.trials) > 0
 
-        self.history = trail_history
-        self.top_n = top_n if top_n is not None else len(trail_history.trials)
+        self.history = history
+        self.top_n = top_n if top_n is not None else len(history.trials)
         self.samples = [t.space_sample for t in self.history.get_top(self.top_n)]
         self.index = 0
         self.reverse = reverse

hypernets/utils/__init__.py

@@ -7,5 +7,5 @@
 from ._doc_lens import DocLens
 from ._fsutils import filesystem as fs
 from ._tic_tok import tic_toc, report as tic_toc_report, report_as_dataframe as tic_toc_report_as_dataframe
-from .common import generate_id, combinations, isnotebook, Counter, to_repr
+from .common import generate_id, combinations, isnotebook, Counter, to_repr, get_params
 from .common import infer_task_type, hash_data, hash_dataframe, load_data, load_module

hypernets/utils/common.py

@@ -9,6 +9,7 @@
 import math
 import pickle
 import uuid
+from collections import OrderedDict
 from functools import partial
 from io import BytesIO
 
@@ -27,9 +28,9 @@ def generate_id():
     return str(uuid.uuid1())
 
 
-def to_repr(obj):
+def get_params(obj, include_default=False):
     def _get_init_params(cls):
-        init = cls.__init__  # getattr(cls.__init__, 'deprecated_original', cls.__init__)
+        init = cls.__init__
         if init is object.__init__:
             return []
 
@@ -38,15 +39,22 @@ def _get_init_params(cls):
                       if p.name != 'self' and p.kind != p.VAR_KEYWORD]
         return parameters
 
-    out = []
-    cls_ = type(obj)
-    for p in _get_init_params(cls_):
+    out = OrderedDict()
+    for p in _get_init_params(type(obj)):
         name = p.name
         value = getattr(obj, name, None)
-        if value is not p.default:
-            out.append('%s=%r' % (name, value))
+        if include_default or value is not p.default:
+            out[name] = value
+
+    return out
+
+
+def to_repr(obj, excludes=None):
+    if excludes is None:
+        excludes = []
+    out = ['%s=%r' % (k, v) for k, v in get_params(obj).items() if k not in excludes]
     repr_ = ', '.join(out)
-    return f'{cls_.__name__}({repr_})'
+    return f'{type(obj).__name__}({repr_})'
 
 
 def combinations(n, m_max, m_min=1):