hyperactive.extentions.insight.insight.Insight.plot_performance() - Code Metrics - Inspection of "Add files via upload" - SimonBlanke/Hyperactive - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 87f4bb...19b221 )

by Simon

created 2019-12-18 12:28 UTC

Insight.plot_performance() B

↳ Parent: hyperactive.extentions.insight.insight

Complexity

Conditions

Size

Total Lines	55
Code Lines	44

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
eloc	44
dl	0
loc	55
rs	8.824
c	0
b	0
f	0
cc	4
nop	4

How to fix Long Method

# Author: Simon Blanke
# Email: [email protected]
# License: MIT License

import numpy as np
import pandas as pd
import plotly as py
import plotly.graph_objects as go
import plotly.express as px

from hyperactive import Hyperactive


class Insight:
    def __init__(self, search_config, X, y):
        self.search_config = search_config
        self.X = X
        self.y = y


    def plot_performance(self, runs=3, path=None, optimizers="all"):
        if optimizers == "all":
            optimizers = [
                "HillClimbing",
                "StochasticHillClimbing",
                "TabuSearch",
                "RandomSearch",
                "RandomRestartHillClimbing",
                "RandomAnnealing",
                "SimulatedAnnealing",
                "StochasticTunneling",
                "ParallelTempering",
                "ParticleSwarm",
                "EvolutionStrategy",
                "Bayesian"]

        eval_times = []
        total_times = []
        for run in range(runs):

            eval_time = []
            total_time = []
            for optimizer in optimizers:
                opt = Hyperactive(self.X, self.y, memory=False)
                opt.search(self.search_config, n_iter=3, optimizer=optimizer)

                eval_time.append(opt.eval_time)
                total_time.append(opt.total_time)

            eval_time = np.array(eval_time)
            total_time = np.array(total_time)

            eval_times.append(eval_time)
            total_times.append(total_time)

        eval_times = np.array(eval_times)
        total_times = np.array(total_times)
        opt_times = np.subtract(total_times, eval_times)

        opt_time_mean = opt_times.mean(axis=0)
        eval_time_mean = eval_times.mean(axis=0)
        total_time_mean = total_times.mean(axis=0)

        opt_time_std = opt_times.std(axis=0)
        eval_time_std = eval_times.std(axis=0)

        eval_time = eval_time_mean/total_time_mean
        opt_time = opt_time_mean/total_time_mean

        fig = go.Figure(data=[
            go.Bar(name='Eval time', x=optimizers, y=eval_time),
            go.Bar(name='Opt time', x=optimizers, y=opt_time)
        ])
        fig.update_layout(barmode='stack')
        py.offline.plot(fig, filename="sampleplot.html")


    def plot_search_path(self, path=None, optimizers=["HillClimbing"]):
        for optimizer in optimizers:
            opt = Hyperactive(self.X, self.y, memory=False, verbosity=10)
            opt.search(self.search_config, n_iter=20, optimizer=optimizer)

            pos_list = opt.pos_list
            score_list = opt.score_list

            pos_list = np.array(pos_list)
            score_list = np.array(score_list)

            pos_list = np.squeeze(pos_list)
            score_list = np.squeeze(score_list)

            df = pd.DataFrame(
                {"n_neighbors": pos_list[:, 0], "leaf_size": pos_list[:, 1], "score": score_list}
            )

            layout = go.Layout(
                xaxis=dict(
                    range=[0, 50]
                ),
                yaxis=dict(
                    range=[0, 50]
                )
            )
            fig = go.Figure(data=go.Scatter(
                x = df["n_neighbors"],
                y = df["leaf_size"],
                mode='lines+markers',
                marker=dict(
                    size=10,
                    color=df["score"],
                    colorscale='Viridis', # one of plotly colorscales
                    showscale=True
                )
            ),
            layout=layout
            )

            py.offline.plot(fig, filename="search_path" + optimizer + ".html")

1			# Author: Simon Blanke
2			# Email: [email protected]
3			# License: MIT License
4
5			import numpy as np
6			import pandas as pd
7			import plotly as py
8			import plotly.graph_objects as go
9			import plotly.express as px
10
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")

SimonBlanke / Hyperactive

Push — master ( 87f4bb...19b221 )

Insight.plot_performance() B

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like