tests._test_memory.objective_function() - Code Metrics - Inspection of "Merge branch 'dev'" - SimonBlanke/Gradient-Free-Optimizers - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 836b12...9641c9 )

by Simon

created 2023-03-24 16:23 UTC

tests._test_memory.objective_function() A

↳ Parent: tests._test_memory

Complexity

Conditions

Size

Total Lines	3
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	3
nop	1
dl	0
loc	3
rs	10
c	0
b	0
f	0

import time
import numpy as np
import pandas as pd
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import cross_val_score
from sklearn.tree import DecisionTreeClassifier
from gradient_free_optimizers import RandomSearchOptimizer
from sklearn.ensemble import GradientBoostingClassifier


def objective_function(para):
    score = -para["x1"] * para["x1"]
    return score


search_space = {
    "x1": np.arange(0, 10, 1),
}


def test_memory_timeSave_0():

    data = load_breast_cancer()
    X, y = data.data, data.target

    def objective_function(para):
        dtc = DecisionTreeClassifier(min_samples_split=para["min_samples_split"])
        scores = cross_val_score(dtc, X, y, cv=5)

        return scores.mean()

    search_space = {
        "min_samples_split": np.arange(2, 20),
    }

    c_time1 = time.time()
    opt = RandomSearchOptimizer(search_space)
    opt.search(objective_function, n_iter=100)
    diff_time1 = time.time() - c_time1

    c_time2 = time.time()
    opt = RandomSearchOptimizer(search_space)
    opt.search(objective_function, n_iter=100, memory=False)
    diff_time2 = time.time() - c_time2

    print("\n diff_time1 ", diff_time1)
    print("\n diff_time2 ", diff_time2)

    assert diff_time1 < diff_time2 * 0.5


def test_memory_timeSave_1():
    data = load_breast_cancer()
    X, y = data.data, data.target

    def objective_function(para):
        dtc = DecisionTreeClassifier(max_depth=para["max_depth"])
        scores = cross_val_score(dtc, X, y, cv=10)

        return scores.mean()

    search_space = {
        "max_depth": np.arange(1, 101),
    }

    results = pd.DataFrame(np.arange(1, 101), columns=["max_depth"])
    results["score"] = 0

    c_time1 = time.time()
    opt = RandomSearchOptimizer(search_space)
    opt.search(objective_function, n_iter=300, memory_warm_start=results)
    diff_time1 = time.time() - c_time1
    print("\n diff_time1 ", diff_time1)

    assert diff_time1 < 0.5


def test_memory_warm_start():

    data = load_breast_cancer()
    X, y = data.data, data.target

    def objective_function(para):
        dtc = DecisionTreeClassifier(
            max_depth=para["max_depth"],
            min_samples_split=para["min_samples_split"],
        )
        scores = cross_val_score(dtc, X, y, cv=5)

        return scores.mean()

    search_space = {
        "max_depth": np.arange(1, 10),
        "min_samples_split": np.arange(2, 20),
    }

    c_time1 = time.time()
    opt0 = RandomSearchOptimizer(search_space)
    opt0.search(objective_function, n_iter=300)
    diff_time1 = time.time() - c_time1

    c_time2 = time.time()
    opt1 = RandomSearchOptimizer(search_space)
    opt1.search(objective_function, n_iter=300, memory_warm_start=opt0.search_data)
    diff_time2 = time.time() - c_time2

    print("\n diff_time1 ", diff_time1)
    print("\n diff_time2 ", diff_time2)

    assert diff_time2 < diff_time1 * 0.5


def test_memory_warm_start_manual():
    data = load_breast_cancer()
    X, y = data.data, data.target

    def objective_function(para):
        dtc = GradientBoostingClassifier(
            n_estimators=para["n_estimators"],
        )
        scores = cross_val_score(dtc, X, y, cv=5)

        return scores.mean()

    search_space = {
        "n_estimators": np.arange(500, 502),
    }

    c_time_1 = time.time()
    opt = RandomSearchOptimizer(search_space)
    opt.search(objective_function, n_iter=1)
    diff_time_1 = time.time() - c_time_1

    memory_warm_start = pd.DataFrame(
        [[500, 0.9], [501, 0.91]], columns=["n_estimators", "score"]
    )

    c_time = time.time()
    opt = RandomSearchOptimizer(search_space)
    opt.search(objective_function, n_iter=30, memory_warm_start=memory_warm_start)
    diff_time_2 = time.time() - c_time

    print("\n diff_time1 ", diff_time_1)
    print("\n diff_time2 ", diff_time_2)

    assert diff_time_1 * 0.5 > diff_time_2


def test_memory_warm_start_wrong_type():
    data = load_breast_cancer()
    X, y = data.data, data.target

    def objective_function(para):
        dtc = GradientBoostingClassifier(
            n_estimators=para["n_estimators"],
        )
        scores = cross_val_score(dtc, X, y, cv=3)

        return scores.mean()

    search_space = {
        "n_estimators": np.arange(500, 502),
    }

    memory_warm_start = pd.DataFrame(
        [[500, 0.9], [501, 0.91]], columns=["n_estimators", "score"]
    )

    opt = RandomSearchOptimizer(search_space)
    opt.search(
        objective_function, n_iter=10, memory_warm_start=memory_warm_start.values
    )


def test_memory_warm_start_wrong_search_space():
    data = load_breast_cancer()
    X, y = data.data, data.target

    def objective_function(para):
        dtc = GradientBoostingClassifier(
            n_estimators=para["n_estimators"],
        )
        scores = cross_val_score(dtc, X, y, cv=3)

        return scores.mean()

    search_space = {
        "n_estimators": np.arange(400, 402),
    }

    c_time_1 = time.time()
    opt = RandomSearchOptimizer(search_space)
    opt.search(objective_function, n_iter=1)
    diff_time_1 = time.time() - c_time_1

    memory_warm_start = pd.DataFrame(
        [[500, 0.9], [501, 0.91]], columns=["n_estimators", "score"]
    )

    c_time = time.time()
    opt = RandomSearchOptimizer(search_space)
    opt.search(objective_function, n_iter=10, memory_warm_start=memory_warm_start)
    diff_time = time.time() - c_time

    assert (diff_time_1 - diff_time) < diff_time / 10


1		import time
2		import numpy as np
3		import pandas as pd
4		from sklearn.datasets import load_breast_cancer
5		from sklearn.model_selection import cross_val_score
6		from sklearn.tree import DecisionTreeClassifier
7		from gradient_free_optimizers import RandomSearchOptimizer
8		from sklearn.ensemble import GradientBoostingClassifier
9
10
11		def objective_function(para):
12		score = -para["x1"] * para["x1"]
13		return score
14
15
16		search_space = {
17		"x1": np.arange(0, 10, 1),
18		}
19
20
21	View Code Duplication	def test_memory_timeSave_0():
		0 ignored issues – show Duplication introduced 2021-10-02 10:11 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
22		data = load_breast_cancer()
23		X, y = data.data, data.target
24
25		def objective_function(para):
26		dtc = DecisionTreeClassifier(min_samples_split=para["min_samples_split"])
27		scores = cross_val_score(dtc, X, y, cv=5)
28
29		return scores.mean()
30
31		search_space = {
32		"min_samples_split": np.arange(2, 20),
33		}
34
35		c_time1 = time.time()
36		opt = RandomSearchOptimizer(search_space)
37		opt.search(objective_function, n_iter=100)
38		diff_time1 = time.time() - c_time1
39
40		c_time2 = time.time()
41		opt = RandomSearchOptimizer(search_space)
42		opt.search(objective_function, n_iter=100, memory=False)
43		diff_time2 = time.time() - c_time2
44
45		print("\n diff_time1 ", diff_time1)
46		print("\n diff_time2 ", diff_time2)
47
48		assert diff_time1 < diff_time2 * 0.5
49
50
51		def test_memory_timeSave_1():
52		data = load_breast_cancer()
53		X, y = data.data, data.target
54
55		def objective_function(para):
56		dtc = DecisionTreeClassifier(max_depth=para["max_depth"])
57		scores = cross_val_score(dtc, X, y, cv=10)
58
59		return scores.mean()
60
61		search_space = {
62		"max_depth": np.arange(1, 101),
63		}
64
65		results = pd.DataFrame(np.arange(1, 101), columns=["max_depth"])
66		results["score"] = 0
67
68		c_time1 = time.time()
69		opt = RandomSearchOptimizer(search_space)
70		opt.search(objective_function, n_iter=300, memory_warm_start=results)
71		diff_time1 = time.time() - c_time1
72		print("\n diff_time1 ", diff_time1)
73
74		assert diff_time1 < 0.5
75
76
77	View Code Duplication	def test_memory_warm_start():
		0 ignored issues – show Duplication introduced 2021-10-02 10:11 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
78		data = load_breast_cancer()
79		X, y = data.data, data.target
80
81		def objective_function(para):
82		dtc = DecisionTreeClassifier(
83		max_depth=para["max_depth"],
84		min_samples_split=para["min_samples_split"],
85		)
86		scores = cross_val_score(dtc, X, y, cv=5)
87
88		return scores.mean()
89
90		search_space = {
91		"max_depth": np.arange(1, 10),
92		"min_samples_split": np.arange(2, 20),
93		}
94
95		c_time1 = time.time()
96		opt0 = RandomSearchOptimizer(search_space)
97		opt0.search(objective_function, n_iter=300)
98		diff_time1 = time.time() - c_time1
99
100		c_time2 = time.time()
101		opt1 = RandomSearchOptimizer(search_space)
102		opt1.search(objective_function, n_iter=300, memory_warm_start=opt0.search_data)
103		diff_time2 = time.time() - c_time2
104
105		print("\n diff_time1 ", diff_time1)
106		print("\n diff_time2 ", diff_time2)
107
108		assert diff_time2 < diff_time1 * 0.5
109
110
111		def test_memory_warm_start_manual():
112		data = load_breast_cancer()
113		X, y = data.data, data.target
114
115		def objective_function(para):
116		dtc = GradientBoostingClassifier(
117		n_estimators=para["n_estimators"],
118		)
119		scores = cross_val_score(dtc, X, y, cv=5)
120
121		return scores.mean()
122
123		search_space = {
124		"n_estimators": np.arange(500, 502),
125		}
126
127		c_time_1 = time.time()
128		opt = RandomSearchOptimizer(search_space)
129		opt.search(objective_function, n_iter=1)
130		diff_time_1 = time.time() - c_time_1
131
132		memory_warm_start = pd.DataFrame(
133		[[500, 0.9], [501, 0.91]], columns=["n_estimators", "score"]
134		)
135
136		c_time = time.time()
137		opt = RandomSearchOptimizer(search_space)
138		opt.search(objective_function, n_iter=30, memory_warm_start=memory_warm_start)
139		diff_time_2 = time.time() - c_time
140
141		print("\n diff_time1 ", diff_time_1)
142		print("\n diff_time2 ", diff_time_2)
143
144		assert diff_time_1 * 0.5 > diff_time_2
145
146
147		def test_memory_warm_start_wrong_type():
148		data = load_breast_cancer()
149		X, y = data.data, data.target
150
151		def objective_function(para):
152		dtc = GradientBoostingClassifier(
153		n_estimators=para["n_estimators"],
154		)
155		scores = cross_val_score(dtc, X, y, cv=3)
156
157		return scores.mean()
158
159		search_space = {
160		"n_estimators": np.arange(500, 502),
161		}
162
163		memory_warm_start = pd.DataFrame(
164		[[500, 0.9], [501, 0.91]], columns=["n_estimators", "score"]
165		)
166
167		opt = RandomSearchOptimizer(search_space)
168		opt.search(
169		objective_function, n_iter=10, memory_warm_start=memory_warm_start.values
170		)
171
172
173		def test_memory_warm_start_wrong_search_space():
174		data = load_breast_cancer()
175		X, y = data.data, data.target
176
177		def objective_function(para):
178		dtc = GradientBoostingClassifier(
179		n_estimators=para["n_estimators"],
180		)
181		scores = cross_val_score(dtc, X, y, cv=3)
182
183		return scores.mean()
184
185		search_space = {
186		"n_estimators": np.arange(400, 402),
187		}
188
189		c_time_1 = time.time()
190		opt = RandomSearchOptimizer(search_space)
191		opt.search(objective_function, n_iter=1)
192		diff_time_1 = time.time() - c_time_1
193
194		memory_warm_start = pd.DataFrame(
195		[[500, 0.9], [501, 0.91]], columns=["n_estimators", "score"]
196		)
197
198		c_time = time.time()
199		opt = RandomSearchOptimizer(search_space)
200		opt.search(objective_function, n_iter=10, memory_warm_start=memory_warm_start)
201		diff_time = time.time() - c_time
202
203		assert (diff_time_1 - diff_time) < diff_time / 10
204

SimonBlanke / Gradient-Free-Optimizers

Push — master ( 836b12...9641c9 )

tests._test_memory.objective_function() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like