Issues in _test_memory_warm_start.py (master) - Issues in master - SimonBlanke/Hyperactive - Measure and Improve Code Quality continuously with Scrutinizer

Issues (61)

_local_test_timings/_test_memory_warm_start.py (1 issue)

Labels

Duplication 1

Severity

Informational 1

import time
import pytest
import numpy as np
import pandas as pd

from hyperactive import Hyperactive

############################## create search spaces
size = 1000

dim_full = list(range(0, size))
dim_cat = list(range(round(size / 3)))
dim_10 = list(range(round(size ** 0.1)))

search_space_0 = {
    "x1": dim_full,
}

search_space_1 = {
    "x1": dim_cat,
    "x2": list(range(3)),
}

search_space_2 = {
    "x1": dim_10,
    "x2": dim_10,
    "x3": dim_10,
    "x4": dim_10,
    "x5": dim_10,
    "x6": dim_10,
    "x7": dim_10,
    "x8": dim_10,
    "x9": dim_10,
    "x10": dim_10,
}

search_space_3 = {
    "x1": dim_10,
    "x2": dim_10,
    "x3": dim_10,
    "x4": dim_10,
    "x5": dim_10,
    "x6": dim_10,
    "x7": dim_10,
    "x8": dim_10,
    "x9": dim_10,
    "x10": dim_10,
    "x11": [1],
    "x12": [1],
    "x13": [1],
    "x14": [1],
    "x15": [1],
}

search_space_4 = {
    "x1": dim_cat,
    "str1": ["0", "1", "2"],
}


def func1():
    pass


def func2():
    pass


def func3():
    pass


search_space_5 = {
    "x1": dim_cat,
    "func1": [func1, func2, func3],
}


class class1:
    pass


class class2:
    pass


class class3:
    pass


def wr_func_1():
    return class1


def wr_func_2():
    return class2


def wr_func_3():
    return class3


search_space_6 = {
    "x1": dim_cat,
    "class_1": [wr_func_1, wr_func_2, wr_func_3],
}


class class1_o:
    def __init__(self):
        pass


class class2_o:
    def __init__(self):
        pass


class class3_o:
    def __init__(self):
        pass


def wr_func_1():
    return class1_o()


def wr_func_2():
    return class2_o()


def wr_func_3():
    return class3_o()


search_space_7 = {
    "x1": dim_cat,
    "class_obj_1": [wr_func_1, wr_func_2, wr_func_3],
}


def wr_func_1():
    return [1, 0, 0]


def wr_func_2():
    return [0, 1, 0]


def wr_func_3():
    return [0, 0, 1]


search_space_8 = {
    "x1": dim_cat,
    "list_1": [wr_func_1, wr_func_2, wr_func_3],
}


def wr_func_1():
    return np.array([1, 0, 0])


def wr_func_2():
    return np.array([0, 1, 0])


def wr_func_3():
    return np.array([0, 0, 1])


search_space_9 = {
    "x1": dim_cat,
    "array_1": [wr_func_1, wr_func_2, wr_func_3],
}


def wr_func_1():
    return pd.DataFrame(np.array([1, 0, 0]))


def wr_func_2():
    return pd.DataFrame(np.array([0, 1, 0]))


def wr_func_3():
    return pd.DataFrame(np.array([0, 0, 1]))


search_space_10 = {
    "x1": dim_cat,
    "df_1": [wr_func_1, wr_func_2, wr_func_3],
}

search_space_list = [
    (search_space_0),
    (search_space_1),
    (search_space_2),
    (search_space_3),
    (search_space_4),
    (search_space_5),
    (search_space_6),
    (search_space_7),
    (search_space_8),
    (search_space_9),
    (search_space_10),
]

############################## start tests


def objective_function(opt):
    time.sleep(0.001)
    return 0


"""
@pytest.mark.parametrize("search_space", search_space_list)
def test_memory_warm_start_0(search_space):
    hyper0 = Hyperactive()
    hyper0.add_search(objective_function, search_space, n_iter=20)
    hyper0.run()

    search_data0 = hyper0.search_data(objective_function)

    hyper1 = Hyperactive()
    hyper1.add_search(
        objective_function, search_space, n_iter=20, memory_warm_start=search_data0
    )
    hyper1.run()



@pytest.mark.parametrize("search_space", search_space_list)
def test_memory_warm_start_1(search_space):
    hyper0 = Hyperactive()
    hyper0.add_search(
        objective_function,
        search_space,
        n_iter=20,
        n_jobs=2,
    )
    hyper0.run()

    search_data0 = hyper0.search_data(objective_function)

    hyper1 = Hyperactive()
    hyper1.add_search(
        objective_function,
        search_space,
        n_iter=20,
        n_jobs=2,
        memory_warm_start=search_data0,
    )
    hyper1.run()


@pytest.mark.parametrize("search_space", search_space_list)
def test_memory_warm_start_2(search_space):
    hyper0 = Hyperactive()
    hyper0.add_search(
        objective_function,
        search_space,
        n_iter=20,
        n_jobs=2,
    )
    hyper0.run()

    search_data0 = hyper0.search_data(objective_function)

    hyper1 = Hyperactive()
    hyper1.add_search(
        objective_function,
        search_space,
        n_iter=20,
        memory_warm_start=search_data0,
    )
    hyper1.run()





@pytest.mark.parametrize("search_space", search_space_list)
def test_memory_warm_start_0(search_space):
    n_iter = 1500

    c_time = time.perf_counter()
    hyper0 = Hyperactive()
    hyper0.add_search(objective_function, search_space, n_iter=n_iter)
    hyper0.run()
    d_time_1 = time.perf_counter() - c_time

    search_data0 = hyper0.search_data(objective_function)

    c_time = time.perf_counter()
    hyper1 = Hyperactive()
    hyper1.add_search(
        objective_function, search_space, n_iter=n_iter, memory_warm_start=search_data0
    )
    hyper1.run()
    d_time_2 = time.perf_counter() - c_time

    d_time_frac = d_time_1 / d_time_2

    print("\n d_time_1 ", d_time_1)
    print("\n d_time_2 ", d_time_2)

    assert d_time_frac > 1.5
"""


@pytest.mark.parametrize("search_space", search_space_list)

def test_memory_warm_start_1(search_space):
    n_iter = 1500

    c_time = time.perf_counter()
    hyper0 = Hyperactive()
    hyper0.add_search(objective_function, search_space, n_iter=n_iter, memory=True)
    hyper0.run()
    d_time_1 = time.perf_counter() - c_time

    search_data0 = hyper0.search_data(objective_function)

    c_time = time.perf_counter()
    hyper1 = Hyperactive(distribution="joblib")
    hyper1.add_search(
        objective_function,
        search_space,
        n_iter=n_iter,
        n_jobs=1,
        memory=True,
        memory_warm_start=search_data0,
    )
    hyper1.run()
    d_time_2 = time.perf_counter() - c_time

    d_time_frac = d_time_1 / d_time_2

    print("\n d_time_1 ", d_time_1)
    print("\n d_time_2 ", d_time_2)

    assert d_time_frac > 1.5


"""
@pytest.mark.parametrize("search_space", search_space_list)
def test_memory_warm_start_2(search_space):
    n_iter = 1500

    c_time = time.perf_counter()
    hyper0 = Hyperactive()
    hyper0.add_search(
        objective_function, search_space, n_iter=n_iter, n_jobs=3, memory=True
    )
    hyper0.run()
    d_time_1 = time.perf_counter() - c_time

    search_data0 = hyper0.search_data(objective_function)

    c_time = time.perf_counter()
    hyper1 = Hyperactive()
    hyper1.add_search(
        objective_function,
        search_space,
        n_iter=n_iter,
        n_jobs=2,
        memory_warm_start=search_data0,
    )
    hyper1.run()
    d_time_2 = time.perf_counter() - c_time

    d_time_frac = d_time_1 / d_time_2

    print("\n d_time_1 ", d_time_1)
    print("\n d_time_2 ", d_time_2)

    assert d_time_frac > 1.5



@pytest.mark.parametrize("search_space", search_space_list)
def test_memory_warm_start_4(search_space):

    c_time = time.perf_counter()
    hyper0 = Hyperactive()
    hyper0.add_search(objective_function, search_space, n_iter=2000, n_jobs=2)
    hyper0.run()
    d_time_1 = time.perf_counter() - c_time

    search_data0 = hyper0.search_data(objective_function)

    c_time = time.perf_counter()
    hyper1 = Hyperactive()
    hyper1.add_search(
        objective_function,
        search_space,
        n_iter=2000,
        memory_warm_start=search_data0,
    )
    hyper1.run()
    d_time_2 = time.perf_counter() - c_time

    print("\n d_time_1 ", d_time_1)
    print("\n d_time_2 ", d_time_2)
    # assert False

    assert d_time_1 * 0.75 > d_time_2



@pytest.mark.parametrize("search_space", search_space_list)
def test_memory_warm_start_5(search_space):

    c_time = time.perf_counter()
    hyper0 = Hyperactive()
    hyper0.add_search(
        objective_function, search_space, n_iter=2000, n_jobs=2
    )
    hyper0.run()
    d_time_1 = time.perf_counter() - c_time

    search_data0 = hyper0.search_data(objective_function)

    c_time = time.perf_counter()
    hyper1 = Hyperactive()
    hyper1.add_search(
        objective_function,
        search_space,
        n_iter=2000,
        n_jobs=2,
        memory_warm_start=search_data0,
    )
    hyper1.run()
    d_time_2 = time.perf_counter() - c_time

    print("\n d_time_1 ", d_time_1)
    print("\n d_time_2 ", d_time_2)
    assert d_time_1 * 0.75 > d_time_2
"""


1		import time
2		import pytest
3		import numpy as np
4		import pandas as pd
5
6		from hyperactive import Hyperactive
7
8		############################## create search spaces
9		size = 1000
10
11		dim_full = list(range(0, size))
12		dim_cat = list(range(round(size / 3)))
13		dim_10 = list(range(round(size ** 0.1)))
14
15		search_space_0 = {
16		"x1": dim_full,
17		}
18
19		search_space_1 = {
20		"x1": dim_cat,
21		"x2": list(range(3)),
22		}
23
24		search_space_2 = {
25		"x1": dim_10,
26		"x2": dim_10,
27		"x3": dim_10,
28		"x4": dim_10,
29		"x5": dim_10,
30		"x6": dim_10,
31		"x7": dim_10,
32		"x8": dim_10,
33		"x9": dim_10,
34		"x10": dim_10,
35		}
36
37		search_space_3 = {
38		"x1": dim_10,
39		"x2": dim_10,
40		"x3": dim_10,
41		"x4": dim_10,
42		"x5": dim_10,
43		"x6": dim_10,
44		"x7": dim_10,
45		"x8": dim_10,
46		"x9": dim_10,
47		"x10": dim_10,
48		"x11": [1],
49		"x12": [1],
50		"x13": [1],
51		"x14": [1],
52		"x15": [1],
53		}
54
55		search_space_4 = {
56		"x1": dim_cat,
57		"str1": ["0", "1", "2"],
58		}
59
60
61		def func1():
62		pass
63
64
65		def func2():
66		pass
67
68
69		def func3():
70		pass
71
72
73		search_space_5 = {
74		"x1": dim_cat,
75		"func1": [func1, func2, func3],
76		}
77
78
79		class class1:
80		pass
81
82
83		class class2:
84		pass
85
86
87		class class3:
88		pass
89
90
91		def wr_func_1():
92		return class1
93
94
95		def wr_func_2():
96		return class2
97
98
99		def wr_func_3():
100		return class3
101
102
103		search_space_6 = {
104		"x1": dim_cat,
105		"class_1": [wr_func_1, wr_func_2, wr_func_3],
106		}
107
108
109		class class1_o:
110		def __init__(self):
111		pass
112
113
114		class class2_o:
115		def __init__(self):
116		pass
117
118
119		class class3_o:
120		def __init__(self):
121		pass
122
123
124		def wr_func_1():
125		return class1_o()
126
127
128		def wr_func_2():
129		return class2_o()
130
131
132		def wr_func_3():
133		return class3_o()
134
135
136		search_space_7 = {
137		"x1": dim_cat,
138		"class_obj_1": [wr_func_1, wr_func_2, wr_func_3],
139		}
140
141
142		def wr_func_1():
143		return [1, 0, 0]
144
145
146		def wr_func_2():
147		return [0, 1, 0]
148
149
150		def wr_func_3():
151		return [0, 0, 1]
152
153
154		search_space_8 = {
155		"x1": dim_cat,
156		"list_1": [wr_func_1, wr_func_2, wr_func_3],
157		}
158
159
160		def wr_func_1():
161		return np.array([1, 0, 0])
162
163
164		def wr_func_2():
165		return np.array([0, 1, 0])
166
167
168		def wr_func_3():
169		return np.array([0, 0, 1])
170
171
172		search_space_9 = {
173		"x1": dim_cat,
174		"array_1": [wr_func_1, wr_func_2, wr_func_3],
175		}
176
177
178		def wr_func_1():
179		return pd.DataFrame(np.array([1, 0, 0]))
180
181
182		def wr_func_2():
183		return pd.DataFrame(np.array([0, 1, 0]))
184
185
186		def wr_func_3():
187		return pd.DataFrame(np.array([0, 0, 1]))
188
189
190		search_space_10 = {
191		"x1": dim_cat,
192		"df_1": [wr_func_1, wr_func_2, wr_func_3],
193		}
194
195		search_space_list = [
196		(search_space_0),
197		(search_space_1),
198		(search_space_2),
199		(search_space_3),
200		(search_space_4),
201		(search_space_5),
202		(search_space_6),
203		(search_space_7),
204		(search_space_8),
205		(search_space_9),
206		(search_space_10),
207		]
208
209		############################## start tests
210
211
212		def objective_function(opt):
213		time.sleep(0.001)
214		return 0
215
216
217		"""
218		@pytest.mark.parametrize("search_space", search_space_list)
219		def test_memory_warm_start_0(search_space):
220		hyper0 = Hyperactive()
221		hyper0.add_search(objective_function, search_space, n_iter=20)
222		hyper0.run()
223
224		search_data0 = hyper0.search_data(objective_function)
225
226		hyper1 = Hyperactive()
227		hyper1.add_search(
228		objective_function, search_space, n_iter=20, memory_warm_start=search_data0
229		)
230		hyper1.run()
231
232
233
234		@pytest.mark.parametrize("search_space", search_space_list)
235		def test_memory_warm_start_1(search_space):
236		hyper0 = Hyperactive()
237		hyper0.add_search(
238		objective_function,
239		search_space,
240		n_iter=20,
241		n_jobs=2,
242		)
243		hyper0.run()
244
245		search_data0 = hyper0.search_data(objective_function)
246
247		hyper1 = Hyperactive()
248		hyper1.add_search(
249		objective_function,
250		search_space,
251		n_iter=20,
252		n_jobs=2,
253		memory_warm_start=search_data0,
254		)
255		hyper1.run()
256
257
258		@pytest.mark.parametrize("search_space", search_space_list)
259		def test_memory_warm_start_2(search_space):
260		hyper0 = Hyperactive()
261		hyper0.add_search(
262		objective_function,
263		search_space,
264		n_iter=20,
265		n_jobs=2,
266		)
267		hyper0.run()
268
269		search_data0 = hyper0.search_data(objective_function)
270
271		hyper1 = Hyperactive()
272		hyper1.add_search(
273		objective_function,
274		search_space,
275		n_iter=20,
276		memory_warm_start=search_data0,
277		)
278		hyper1.run()
279
280
281
282
283
284		@pytest.mark.parametrize("search_space", search_space_list)
285		def test_memory_warm_start_0(search_space):
286		n_iter = 1500
287
288		c_time = time.perf_counter()
289		hyper0 = Hyperactive()
290		hyper0.add_search(objective_function, search_space, n_iter=n_iter)
291		hyper0.run()
292		d_time_1 = time.perf_counter() - c_time
293
294		search_data0 = hyper0.search_data(objective_function)
295
296		c_time = time.perf_counter()
297		hyper1 = Hyperactive()
298		hyper1.add_search(
299		objective_function, search_space, n_iter=n_iter, memory_warm_start=search_data0
300		)
301		hyper1.run()
302		d_time_2 = time.perf_counter() - c_time
303
304		d_time_frac = d_time_1 / d_time_2
305
306		print("\n d_time_1 ", d_time_1)
307		print("\n d_time_2 ", d_time_2)
308
309		assert d_time_frac > 1.5
310		"""
311
312
313	View Code Duplication	@pytest.mark.parametrize("search_space", search_space_list)
		0 ignored issues – show Duplication introduced 2022-03-16 12:55 UTC by Report Bug Copy Issue Report Show Similar Issues like this This code seems to be duplicated in your project. Loading history...
314		def test_memory_warm_start_1(search_space):
315		n_iter = 1500
316
317		c_time = time.perf_counter()
318		hyper0 = Hyperactive()
319		hyper0.add_search(objective_function, search_space, n_iter=n_iter, memory=True)
320		hyper0.run()
321		d_time_1 = time.perf_counter() - c_time
322
323		search_data0 = hyper0.search_data(objective_function)
324
325		c_time = time.perf_counter()
326		hyper1 = Hyperactive(distribution="joblib")
327		hyper1.add_search(
328		objective_function,
329		search_space,
330		n_iter=n_iter,
331		n_jobs=1,
332		memory=True,
333		memory_warm_start=search_data0,
334		)
335		hyper1.run()
336		d_time_2 = time.perf_counter() - c_time
337
338		d_time_frac = d_time_1 / d_time_2
339
340		print("\n d_time_1 ", d_time_1)
341		print("\n d_time_2 ", d_time_2)
342
343		assert d_time_frac > 1.5
344
345
346		"""
347		@pytest.mark.parametrize("search_space", search_space_list)
348		def test_memory_warm_start_2(search_space):
349		n_iter = 1500
350
351		c_time = time.perf_counter()
352		hyper0 = Hyperactive()
353		hyper0.add_search(
354		objective_function, search_space, n_iter=n_iter, n_jobs=3, memory=True
355		)
356		hyper0.run()
357		d_time_1 = time.perf_counter() - c_time
358
359		search_data0 = hyper0.search_data(objective_function)
360
361		c_time = time.perf_counter()
362		hyper1 = Hyperactive()
363		hyper1.add_search(
364		objective_function,
365		search_space,
366		n_iter=n_iter,
367		n_jobs=2,
368		memory_warm_start=search_data0,
369		)
370		hyper1.run()
371		d_time_2 = time.perf_counter() - c_time
372
373		d_time_frac = d_time_1 / d_time_2
374
375		print("\n d_time_1 ", d_time_1)
376		print("\n d_time_2 ", d_time_2)
377
378		assert d_time_frac > 1.5
379
380
381
382		@pytest.mark.parametrize("search_space", search_space_list)
383		def test_memory_warm_start_4(search_space):
384
385		c_time = time.perf_counter()
386		hyper0 = Hyperactive()
387		hyper0.add_search(objective_function, search_space, n_iter=2000, n_jobs=2)
388		hyper0.run()
389		d_time_1 = time.perf_counter() - c_time
390
391		search_data0 = hyper0.search_data(objective_function)
392
393		c_time = time.perf_counter()
394		hyper1 = Hyperactive()
395		hyper1.add_search(
396		objective_function,
397		search_space,
398		n_iter=2000,
399		memory_warm_start=search_data0,
400		)
401		hyper1.run()
402		d_time_2 = time.perf_counter() - c_time
403
404		print("\n d_time_1 ", d_time_1)
405		print("\n d_time_2 ", d_time_2)
406		# assert False
407
408		assert d_time_1 * 0.75 > d_time_2
409
410
411
412		@pytest.mark.parametrize("search_space", search_space_list)
413		def test_memory_warm_start_5(search_space):
414
415		c_time = time.perf_counter()
416		hyper0 = Hyperactive()
417		hyper0.add_search(
418		objective_function, search_space, n_iter=2000, n_jobs=2
419		)
420		hyper0.run()
421		d_time_1 = time.perf_counter() - c_time
422
423		search_data0 = hyper0.search_data(objective_function)
424
425		c_time = time.perf_counter()
426		hyper1 = Hyperactive()
427		hyper1.add_search(
428		objective_function,
429		search_space,
430		n_iter=2000,
431		n_jobs=2,
432		memory_warm_start=search_data0,
433		)
434		hyper1.run()
435		d_time_2 = time.perf_counter() - c_time
436
437		print("\n d_time_1 ", d_time_1)
438		print("\n d_time_2 ", d_time_2)
439		assert d_time_1 * 0.75 > d_time_2
440		"""
441

SimonBlanke / Hyperactive

Issues (61)

_local_test_timings/_test_memory_warm_start.py (1 issue)

Labels

Severity

Introduced By

Duplication Side-by-Side

Filter issues like