_test_long_term_memory.compare_0() - Code Metrics - Inspection of "remove unused code" - SimonBlanke/Hyperactive - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( b8f359...927840 )

by Simon

created 2021-01-30 18:51 UTC

_test_long_term_memory.compare_0() A

↳ Parent: _test_long_term_memory

Complexity

Conditions

Size

Total Lines	2
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes

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

import os
import inspect
import pytest

from sklearn.datasets import load_iris
from sklearn.neighbors import KNeighborsClassifier
from sklearn.model_selection import cross_val_score

import numpy as np
import pandas as pd

from hyperactive import Hyperactive, LongTermMemory

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


def func1():
    pass


def func2():
    pass


def func3():
    pass


class class1:
    pass


class class2:
    pass


class class3:
    pass


class class1_:
    def __init__(self):
        pass


class class2_:
    def __init__(self):
        pass


class class3_:
    def __init__(self):
        pass


search_space_int0 = {
    "x1": list(range(2, 30, 1)),
}

search_space_int1 = {
    "x1": list(range(2, 30, 1)),
    "x2": list(range(0, 101, 1)),
}

search_space_int2 = {
    "x1": list(range(2, 30, 1)),
    "x2": list(range(-100, 1, 1)),
}

search_space_float = {
    "x1": list(range(2, 30, 1)),
    "x2": list(np.arange(0, 0.003, 0.001)),
}

search_space_str = {
    "x1": list(range(2, 30, 1)),
    "x2": ["0", "1", "2"],
}

search_space_func = {
    "x1": list(range(2, 30, 1)),
    "x2": [func1, func2, func3],
}


search_space_class = {
    "x1": list(range(2, 30, 1)),
    "x2": [class1, class2, class3],
}


search_space_obj = {
    "x1": list(range(2, 30, 1)),
    "x2": [class1_(), class2_(), class3_()],
}

search_space_lists = {
    "x1": list(range(2, 30, 1)),
    "x2": [[1, 1, 1], [1, 2, 1], [1, 1, 2]],
}


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


def model(para):
    knr = KNeighborsClassifier(n_neighbors=para["x1"])
    scores = cross_val_score(knr, X, y, cv=2)
    score = scores.mean()

    return score


def keras_model(para):
    pass


def compare_0(results1, results2):
    assert results1.equals(results2)


def compare_obj(results1, results2):
    obj1_list = list(results1["x2"].values)
    obj2_list = list(results1["x2"].values)

    for obj1, obj2 in zip(obj1_list, obj2_list):
        if obj1 != obj2:
            assert False


search_space_para = (
    "search_space",
    [
        (search_space_int0, compare_0),
        (search_space_int1, compare_0),
        (search_space_int2, compare_0),
        (search_space_float, compare_0),
        (search_space_str, compare_0),
        (search_space_func, compare_obj),
        (search_space_class, compare_obj),
        (search_space_obj, compare_obj),
        (search_space_lists, compare_obj),
    ],
)

path_para = (
    "path",
    [("."), ("./"), (None), ("./dir/dir/")],
)


objective_function_para = (
    "objective_function",
    [
        (objective_function),
        (model),
    ],
)


@pytest.mark.parametrize(*objective_function_para)
@pytest.mark.parametrize(*path_para)
@pytest.mark.parametrize(*search_space_para)
def test_ltm_0(objective_function, search_space, path):
    (search_space, compare) = search_space

    print("\n objective_function \n", objective_function)
    print("\n search_space \n", search_space)
    print("\n compare \n", compare)
    print("\n path \n", path)

    model_name = str(objective_function.__name__)

    hyper = Hyperactive()
    hyper.add_search(
        objective_function, search_space, n_iter=10, initialize={"random": 1}
    )
    hyper.run()
    results1 = hyper.results(objective_function)

    memory = LongTermMemory(model_name, path=path)
    memory.save(results1, objective_function)
    results2 = memory.load()

    print("\n results1 \n", results1)
    print("\n results2 \n", results2)

    memory.remove_model_data()

    compare(results1, results2)


@pytest.mark.parametrize(*objective_function_para)
@pytest.mark.parametrize(*path_para)
@pytest.mark.parametrize(*search_space_para)
def test_ltm_1(objective_function, search_space, path):
    (search_space, compare) = search_space

    print("\n objective_function \n", objective_function)
    print("\n search_space \n", search_space)
    print("\n compare \n", compare)
    print("\n path \n", path)

    model_name = str(objective_function.__name__)
    memory = LongTermMemory(model_name, path=path)

    hyper1 = Hyperactive()
    hyper1.add_search(
        objective_function,
        search_space,
        n_iter=10,
        initialize={"random": 1},
        long_term_memory=memory,
    )
    hyper1.run()
    results1 = hyper1.results(objective_function)

    hyper2 = Hyperactive()
    hyper2.add_search(
        objective_function,
        search_space,
        n_iter=10,
        initialize={"random": 1},
        long_term_memory=memory,
    )
    hyper2.run()
    results2 = hyper2.results(objective_function)
    memory.remove_model_data()

    print("\n results1 \n", results1)
    print("\n results2 \n", results2)


1			import os
2			import inspect
3			import pytest
4
5			from sklearn.datasets import load_iris
6			from sklearn.neighbors import KNeighborsClassifier
7			from sklearn.model_selection import cross_val_score
8
9			import numpy as np
10			import pandas as pd
11
12			from hyperactive import Hyperactive, LongTermMemory
13
14			data = load_iris()
15			X, y = data.data, data.target
16
17
18			def func1():
19			pass
20
21
22			def func2():
23			pass
24
25
26			def func3():
27			pass
28
29
30			class class1:
31			pass
32
33
34			class class2:
35			pass
36
37
38			class class3:
39			pass
40
41
42			class class1_:
43			def __init__(self):
44			pass
45
46
47			class class2_:
48			def __init__(self):
49			pass
50
51
52			class class3_:
53			def __init__(self):
54			pass
55
56
57			search_space_int0 = {
58			"x1": list(range(2, 30, 1)),
59			}
60
61			search_space_int1 = {
62			"x1": list(range(2, 30, 1)),
63			"x2": list(range(0, 101, 1)),
64			}
65
66			search_space_int2 = {
67			"x1": list(range(2, 30, 1)),
68			"x2": list(range(-100, 1, 1)),
69			}
70
71			search_space_float = {
72			"x1": list(range(2, 30, 1)),
73			"x2": list(np.arange(0, 0.003, 0.001)),
74			}
75
76			search_space_str = {
77			"x1": list(range(2, 30, 1)),
78			"x2": ["0", "1", "2"],
79			}
80
81			search_space_func = {
82			"x1": list(range(2, 30, 1)),
83			"x2": [func1, func2, func3],
84			}
85
86
87			search_space_class = {
88			"x1": list(range(2, 30, 1)),
89			"x2": [class1, class2, class3],
90			}
91
92
93			search_space_obj = {
94			"x1": list(range(2, 30, 1)),
95			"x2": [class1_(), class2_(), class3_()],
96			}
97
98			search_space_lists = {
99			"x1": list(range(2, 30, 1)),
100			"x2": [[1, 1, 1], [1, 2, 1], [1, 1, 2]],
101			}
102
103
104			def objective_function(opt):
105			score = -opt["x1"] * opt["x1"]
106			return score
107
108
109			def model(para):
110			knr = KNeighborsClassifier(n_neighbors=para["x1"])
111			scores = cross_val_score(knr, X, y, cv=2)
112			score = scores.mean()
113
114			return score
115
116
117			def keras_model(para):
118			pass
119
120
121			def compare_0(results1, results2):
122			assert results1.equals(results2)
123
124
125			def compare_obj(results1, results2):
126			obj1_list = list(results1["x2"].values)
127			obj2_list = list(results1["x2"].values)
128
129			for obj1, obj2 in zip(obj1_list, obj2_list):
130			if obj1 != obj2:
131			assert False
132
133
134			search_space_para = (
135			"search_space",
136			[
137			(search_space_int0, compare_0),
138			(search_space_int1, compare_0),
139			(search_space_int2, compare_0),
140			(search_space_float, compare_0),
141			(search_space_str, compare_0),
142			(search_space_func, compare_obj),
143			(search_space_class, compare_obj),
144			(search_space_obj, compare_obj),
145			(search_space_lists, compare_obj),
146			],
147			)
148
149			path_para = (
150			"path",
151			[("."), ("./"), (None), ("./dir/dir/")],
152			)
153
154
155			objective_function_para = (
156			"objective_function",
157			[
158			(objective_function),
159			(model),
160			],
161			)
162
163
164			@pytest.mark.parametrize(*objective_function_para)
165			@pytest.mark.parametrize(*path_para)
166			@pytest.mark.parametrize(*search_space_para)
167			def test_ltm_0(objective_function, search_space, path):
168			(search_space, compare) = search_space
169
170			print("\n objective_function \n", objective_function)
171			print("\n search_space \n", search_space)
172			print("\n compare \n", compare)
173			print("\n path \n", path)
174
175			model_name = str(objective_function.__name__)
176
177			hyper = Hyperactive()
178			hyper.add_search(
179			objective_function, search_space, n_iter=10, initialize={"random": 1}
180			)
181			hyper.run()
182			results1 = hyper.results(objective_function)
183
184			memory = LongTermMemory(model_name, path=path)
185			memory.save(results1, objective_function)
186			results2 = memory.load()
187
188			print("\n results1 \n", results1)
189			print("\n results2 \n", results2)
190
191			memory.remove_model_data()
192
193			compare(results1, results2)
194
195
196			@pytest.mark.parametrize(*objective_function_para)
197			@pytest.mark.parametrize(*path_para)
198			@pytest.mark.parametrize(*search_space_para)
199			def test_ltm_1(objective_function, search_space, path):
200			(search_space, compare) = search_space
201
202			print("\n objective_function \n", objective_function)
203			print("\n search_space \n", search_space)
204			print("\n compare \n", compare)
205			print("\n path \n", path)
206
207			model_name = str(objective_function.__name__)
208			memory = LongTermMemory(model_name, path=path)
209
210			hyper1 = Hyperactive()
211			hyper1.add_search(
212			objective_function,
213			search_space,
214			n_iter=10,
215			initialize={"random": 1},
216			long_term_memory=memory,
217			)
218			hyper1.run()
219			results1 = hyper1.results(objective_function)
220
221			hyper2 = Hyperactive()
222			hyper2.add_search(
223			objective_function,
224			search_space,
225			n_iter=10,
226			initialize={"random": 1},
227			long_term_memory=memory,
228			)
229			hyper2.run()
230			results2 = hyper2.results(objective_function)
231			memory.remove_model_data()
232
233			print("\n results1 \n", results1)
234			print("\n results2 \n", results2)
235

SimonBlanke / Hyperactive

Push — master ( b8f359...927840 )

_test_long_term_memory.compare_0() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like