SimonBlanke /
Hyperactive
| @@ 15-119 (lines=105) @@ | ||
| 12 | from ...hyperactive import Hyperactive |
|
| 13 | ||
| 14 | ||
| 15 | class Insight: |
|
| 16 | def __init__(self, search_config, X, y): |
|
| 17 | self.search_config = search_config |
|
| 18 | self.X = X |
|
| 19 | self.y = y |
|
| 20 | ||
| 21 | ||
| 22 | def plot_performance(self, runs=3, path=None, optimizers="all"): |
|
| 23 | if optimizers == "all": |
|
| 24 | optimizers = [ |
|
| 25 | "HillClimbing", |
|
| 26 | "StochasticHillClimbing", |
|
| 27 | "TabuSearch", |
|
| 28 | "RandomSearch", |
|
| 29 | "RandomRestartHillClimbing", |
|
| 30 | "RandomAnnealing", |
|
| 31 | "SimulatedAnnealing", |
|
| 32 | "StochasticTunneling", |
|
| 33 | "ParallelTempering", |
|
| 34 | "ParticleSwarm", |
|
| 35 | "EvolutionStrategy", |
|
| 36 | "Bayesian"] |
|
| 37 | ||
| 38 | eval_times = [] |
|
| 39 | total_times = [] |
|
| 40 | for run in range(runs): |
|
| 41 | ||
| 42 | eval_time = [] |
|
| 43 | total_time = [] |
|
| 44 | for optimizer in optimizers: |
|
| 45 | opt = Hyperactive(self.X, self.y, memory=False) |
|
| 46 | opt.search(self.search_config, n_iter=3, optimizer=optimizer) |
|
| 47 | ||
| 48 | eval_time.append(opt.eval_time) |
|
| 49 | total_time.append(opt.total_time) |
|
| 50 | ||
| 51 | eval_time = np.array(eval_time) |
|
| 52 | total_time = np.array(total_time) |
|
| 53 | ||
| 54 | eval_times.append(eval_time) |
|
| 55 | total_times.append(total_time) |
|
| 56 | ||
| 57 | eval_times = np.array(eval_times) |
|
| 58 | total_times = np.array(total_times) |
|
| 59 | opt_times = np.subtract(total_times, eval_times) |
|
| 60 | ||
| 61 | opt_time_mean = opt_times.mean(axis=0) |
|
| 62 | eval_time_mean = eval_times.mean(axis=0) |
|
| 63 | total_time_mean = total_times.mean(axis=0) |
|
| 64 | ||
| 65 | opt_time_std = opt_times.std(axis=0) |
|
| 66 | eval_time_std = eval_times.std(axis=0) |
|
| 67 | ||
| 68 | eval_time = eval_time_mean/total_time_mean |
|
| 69 | opt_time = opt_time_mean/total_time_mean |
|
| 70 | ||
| 71 | fig = go.Figure(data=[ |
|
| 72 | go.Bar(name='Eval time', x=optimizers, y=eval_time), |
|
| 73 | go.Bar(name='Opt time', x=optimizers, y=opt_time) |
|
| 74 | ]) |
|
| 75 | fig.update_layout(barmode='stack') |
|
| 76 | py.offline.plot(fig, filename="sampleplot.html") |
|
| 77 | ||
| 78 | ||
| 79 | def plot_search_path(self, path=None, optimizers=["HillClimbing"]): |
|
| 80 | for optimizer in optimizers: |
|
| 81 | opt = Hyperactive(self.X, self.y, memory=False, verbosity=10) |
|
| 82 | opt.search(self.search_config, n_iter=20, optimizer=optimizer) |
|
| 83 | ||
| 84 | pos_list = opt.pos_list |
|
| 85 | score_list = opt.score_list |
|
| 86 | ||
| 87 | pos_list = np.array(pos_list) |
|
| 88 | score_list = np.array(score_list) |
|
| 89 | ||
| 90 | pos_list = np.squeeze(pos_list) |
|
| 91 | score_list = np.squeeze(score_list) |
|
| 92 | ||
| 93 | df = pd.DataFrame( |
|
| 94 | {"n_neighbors": pos_list[:, 0], "leaf_size": pos_list[:, 1], "score": score_list} |
|
| 95 | ) |
|
| 96 | ||
| 97 | layout = go.Layout( |
|
| 98 | xaxis=dict( |
|
| 99 | range=[0, 50] |
|
| 100 | ), |
|
| 101 | yaxis=dict( |
|
| 102 | range=[0, 50] |
|
| 103 | ) |
|
| 104 | ) |
|
| 105 | fig = go.Figure(data=go.Scatter( |
|
| 106 | x = df["n_neighbors"], |
|
| 107 | y = df["leaf_size"], |
|
| 108 | mode='lines+markers', |
|
| 109 | marker=dict( |
|
| 110 | size=10, |
|
| 111 | color=df["score"], |
|
| 112 | colorscale='Viridis', # one of plotly colorscales |
|
| 113 | showscale=True |
|
| 114 | ) |
|
| 115 | ), |
|
| 116 | layout=layout |
|
| 117 | ) |
|
| 118 | ||
| 119 | py.offline.plot(fig, filename="search_path" + optimizer + ".html") |
|
| @@ 14-118 (lines=105) @@ | ||
| 11 | from hyperactive import Hyperactive |
|
| 12 | ||
| 13 | ||
| 14 | class Insight: |
|
| 15 | def __init__(self, search_config, X, y): |
|
| 16 | self.search_config = search_config |
|
| 17 | self.X = X |
|
| 18 | self.y = y |
|
| 19 | ||
| 20 | ||
| 21 | def plot_performance(self, runs=3, path=None, optimizers="all"): |
|
| 22 | if optimizers == "all": |
|
| 23 | optimizers = [ |
|
| 24 | "HillClimbing", |
|
| 25 | "StochasticHillClimbing", |
|
| 26 | "TabuSearch", |
|
| 27 | "RandomSearch", |
|
| 28 | "RandomRestartHillClimbing", |
|
| 29 | "RandomAnnealing", |
|
| 30 | "SimulatedAnnealing", |
|
| 31 | "StochasticTunneling", |
|
| 32 | "ParallelTempering", |
|
| 33 | "ParticleSwarm", |
|
| 34 | "EvolutionStrategy", |
|
| 35 | "Bayesian"] |
|
| 36 | ||
| 37 | eval_times = [] |
|
| 38 | total_times = [] |
|
| 39 | for run in range(runs): |
|
| 40 | ||
| 41 | eval_time = [] |
|
| 42 | total_time = [] |
|
| 43 | for optimizer in optimizers: |
|
| 44 | opt = Hyperactive(self.X, self.y, memory=False) |
|
| 45 | opt.search(self.search_config, n_iter=3, optimizer=optimizer) |
|
| 46 | ||
| 47 | eval_time.append(opt.eval_time) |
|
| 48 | total_time.append(opt.total_time) |
|
| 49 | ||
| 50 | eval_time = np.array(eval_time) |
|
| 51 | total_time = np.array(total_time) |
|
| 52 | ||
| 53 | eval_times.append(eval_time) |
|
| 54 | total_times.append(total_time) |
|
| 55 | ||
| 56 | eval_times = np.array(eval_times) |
|
| 57 | total_times = np.array(total_times) |
|
| 58 | opt_times = np.subtract(total_times, eval_times) |
|
| 59 | ||
| 60 | opt_time_mean = opt_times.mean(axis=0) |
|
| 61 | eval_time_mean = eval_times.mean(axis=0) |
|
| 62 | total_time_mean = total_times.mean(axis=0) |
|
| 63 | ||
| 64 | opt_time_std = opt_times.std(axis=0) |
|
| 65 | eval_time_std = eval_times.std(axis=0) |
|
| 66 | ||
| 67 | eval_time = eval_time_mean/total_time_mean |
|
| 68 | opt_time = opt_time_mean/total_time_mean |
|
| 69 | ||
| 70 | fig = go.Figure(data=[ |
|
| 71 | go.Bar(name='Eval time', x=optimizers, y=eval_time), |
|
| 72 | go.Bar(name='Opt time', x=optimizers, y=opt_time) |
|
| 73 | ]) |
|
| 74 | fig.update_layout(barmode='stack') |
|
| 75 | py.offline.plot(fig, filename="sampleplot.html") |
|
| 76 | ||
| 77 | ||
| 78 | def plot_search_path(self, path=None, optimizers=["HillClimbing"]): |
|
| 79 | for optimizer in optimizers: |
|
| 80 | opt = Hyperactive(self.X, self.y, memory=False, verbosity=10) |
|
| 81 | opt.search(self.search_config, n_iter=20, optimizer=optimizer) |
|
| 82 | ||
| 83 | pos_list = opt.pos_list |
|
| 84 | score_list = opt.score_list |
|
| 85 | ||
| 86 | pos_list = np.array(pos_list) |
|
| 87 | score_list = np.array(score_list) |
|
| 88 | ||
| 89 | pos_list = np.squeeze(pos_list) |
|
| 90 | score_list = np.squeeze(score_list) |
|
| 91 | ||
| 92 | df = pd.DataFrame( |
|
| 93 | {"n_neighbors": pos_list[:, 0], "leaf_size": pos_list[:, 1], "score": score_list} |
|
| 94 | ) |
|
| 95 | ||
| 96 | layout = go.Layout( |
|
| 97 | xaxis=dict( |
|
| 98 | range=[0, 50] |
|
| 99 | ), |
|
| 100 | yaxis=dict( |
|
| 101 | range=[0, 50] |
|
| 102 | ) |
|
| 103 | ) |
|
| 104 | fig = go.Figure(data=go.Scatter( |
|
| 105 | x = df["n_neighbors"], |
|
| 106 | y = df["leaf_size"], |
|
| 107 | mode='lines+markers', |
|
| 108 | marker=dict( |
|
| 109 | size=10, |
|
| 110 | color=df["score"], |
|
| 111 | colorscale='Viridis', # one of plotly colorscales |
|
| 112 | showscale=True |
|
| 113 | ) |
|
| 114 | ), |
|
| 115 | layout=layout |
|
| 116 | ) |
|
| 117 | ||
| 118 | py.offline.plot(fig, filename="search_path" + optimizer + ".html") |
|
