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

Passed

Push — master ( 502a6e...660aa4 )

by Simon

created 2024-05-09 13:43 UTC

tests.test_parameters.test_simulated_annealing A

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	211
Duplicated Lines	63.03 %

Importance

Changes

Metric	Value
eloc	154
dl	133
loc	211
rs	10
c	0
b	0
f	0
wmc	3

3 Functions

Rating	Name	Duplication	Size	Complexity
B	test_start_temp_0()	69	69	1
B	test_annealing_rate_0()	0	52	1
B	test_start_temp_1()	64	64	1

How to fix Duplicated Code

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

import pytest
import numpy as np

from surfaces.test_functions.mathematical import SphereFunction

from gradient_free_optimizers import SimulatedAnnealingOptimizer


sphere_function = SphereFunction(n_dim=2)
objective_function = sphere_function.objective_function
search_space = sphere_function.search_space()


n_iter = 1000


def test_start_temp_0():

    n_initialize = 1

    start_temp_0 = 0
    start_temp_1 = 0.1
    start_temp_10 = 1
    start_temp_100 = 100
    start_temp_inf = np.inf

    epsilon = 1 / np.inf

    opt = SimulatedAnnealingOptimizer(
        search_space,
        start_temp=start_temp_0,
        epsilon=epsilon,
        initialize={"random": n_initialize},
    )
    opt.search(objective_function, n_iter=n_iter)
    n_transitions_0 = opt.n_transitions

    opt = SimulatedAnnealingOptimizer(
        search_space,
        start_temp=start_temp_1,
        epsilon=epsilon,
        initialize={"random": n_initialize},
    )
    opt.search(objective_function, n_iter=n_iter)
    n_transitions_1 = opt.n_transitions

    opt = SimulatedAnnealingOptimizer(
        search_space,
        start_temp=start_temp_10,
        epsilon=epsilon,
        initialize={"random": n_initialize},
    )
    opt.search(objective_function, n_iter=n_iter)
    n_transitions_10 = opt.n_transitions

    opt = SimulatedAnnealingOptimizer(
        search_space,
        start_temp=start_temp_100,
        epsilon=epsilon,
        initialize={"random": n_initialize},
    )
    opt.search(objective_function, n_iter=n_iter)
    n_transitions_100 = opt.n_transitions

    opt = SimulatedAnnealingOptimizer(
        search_space,
        start_temp=start_temp_inf,
        epsilon=epsilon,
        initialize={"random": n_initialize},
    )
    opt.search(objective_function, n_iter=n_iter)
    n_transitions_inf = opt.n_transitions

    print("\n n_transitions_0", n_transitions_0)
    print("\n n_transitions_1", n_transitions_1)
    print("\n n_transitions_10", n_transitions_10)
    print("\n n_transitions_100", n_transitions_100)
    print("\n n_transitions_inf", n_transitions_inf)

    assert n_transitions_0 == start_temp_0
    assert (
        n_transitions_1
        == n_transitions_10
        == n_transitions_100
        == n_transitions_inf
        == n_iter - n_initialize
    )


def test_start_temp_1():

    n_initialize = 1

    start_temp_0 = 0
    start_temp_1 = 0.1
    start_temp_10 = 1
    start_temp_100 = 100
    start_temp_inf = np.inf

    epsilon = 0.03

    opt = SimulatedAnnealingOptimizer(
        search_space,
        start_temp=start_temp_0,
        epsilon=epsilon,
        initialize={"random": n_initialize},
    )
    opt.search(objective_function, n_iter=n_iter)
    n_transitions_0 = opt.n_transitions

    opt = SimulatedAnnealingOptimizer(
        search_space,
        start_temp=start_temp_1,
        epsilon=epsilon,
        initialize={"random": n_initialize},
    )
    opt.search(objective_function, n_iter=n_iter)
    n_transitions_1 = opt.n_transitions

    opt = SimulatedAnnealingOptimizer(
        search_space,
        start_temp=start_temp_10,
        epsilon=epsilon,
        initialize={"random": n_initialize},
    )
    opt.search(objective_function, n_iter=n_iter)
    n_transitions_10 = opt.n_transitions

    opt = SimulatedAnnealingOptimizer(
        search_space,
        start_temp=start_temp_100,
        epsilon=epsilon,
        initialize={"random": n_initialize},
    )
    opt.search(objective_function, n_iter=n_iter)
    n_transitions_100 = opt.n_transitions

    opt = SimulatedAnnealingOptimizer(
        search_space,
        start_temp=start_temp_inf,
        epsilon=epsilon,
        initialize={"random": n_initialize},
    )
    opt.search(objective_function, n_iter=n_iter)
    n_transitions_inf = opt.n_transitions

    print("\n n_transitions_0", n_transitions_0)
    print("\n n_transitions_1", n_transitions_1)
    print("\n n_transitions_10", n_transitions_10)
    print("\n n_transitions_100", n_transitions_100)
    print("\n n_transitions_inf", n_transitions_inf)

    assert n_transitions_0 == start_temp_0
    assert n_transitions_1 < n_transitions_10 < n_transitions_100 < n_transitions_inf


def test_annealing_rate_0():
    n_initialize = 1

    annealing_rate_0 = 0
    annealing_rate_1 = 0.1
    annealing_rate_10 = 0.5
    annealing_rate_100 = 0.9

    epsilon = 0.03

    opt = SimulatedAnnealingOptimizer(
        search_space,
        annealing_rate=annealing_rate_0,
        epsilon=epsilon,
        initialize={"random": n_initialize},
    )
    opt.search(objective_function, n_iter=n_iter)
    n_transitions_0 = opt.n_transitions

    opt = SimulatedAnnealingOptimizer(
        search_space,
        annealing_rate=annealing_rate_1,
        epsilon=epsilon,
        initialize={"random": n_initialize},
    )
    opt.search(objective_function, n_iter=n_iter)
    n_transitions_1 = opt.n_transitions

    opt = SimulatedAnnealingOptimizer(
        search_space,
        annealing_rate=annealing_rate_10,
        epsilon=epsilon,
        initialize={"random": n_initialize},
    )
    opt.search(objective_function, n_iter=n_iter)
    n_transitions_10 = opt.n_transitions

    opt = SimulatedAnnealingOptimizer(
        search_space,
        annealing_rate=annealing_rate_100,
        epsilon=epsilon,
        initialize={"random": n_initialize},
    )
    opt.search(objective_function, n_iter=n_iter)
    n_transitions_100 = opt.n_transitions

    print("\n n_transitions_0", n_transitions_0)
    print("\n n_transitions_1", n_transitions_1)
    print("\n n_transitions_10", n_transitions_10)
    print("\n n_transitions_100", n_transitions_100)

    assert n_transitions_0 in [0, 1]
    # assert n_transitions_1 < n_transitions_10 < n_transitions_100


1		# Author: Simon Blanke
2		# Email: [email protected]
3		# License: MIT License
4
5		import pytest
6		import numpy as np
7
8		from surfaces.test_functions.mathematical import SphereFunction
9
10		from gradient_free_optimizers import SimulatedAnnealingOptimizer
11
12
13		sphere_function = SphereFunction(n_dim=2)
14		objective_function = sphere_function.objective_function
15		search_space = sphere_function.search_space()
16
17
18		n_iter = 1000
19
20
21	View Code Duplication	def test_start_temp_0():
		0 ignored issues – show Duplication introduced 2024-05-09 13:48 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
22		n_initialize = 1
23
24		start_temp_0 = 0
25		start_temp_1 = 0.1
26		start_temp_10 = 1
27		start_temp_100 = 100
28		start_temp_inf = np.inf
29
30		epsilon = 1 / np.inf
31
32		opt = SimulatedAnnealingOptimizer(
33		search_space,
34		start_temp=start_temp_0,
35		epsilon=epsilon,
36		initialize={"random": n_initialize},
37		)
38		opt.search(objective_function, n_iter=n_iter)
39		n_transitions_0 = opt.n_transitions
40
41		opt = SimulatedAnnealingOptimizer(
42		search_space,
43		start_temp=start_temp_1,
44		epsilon=epsilon,
45		initialize={"random": n_initialize},
46		)
47		opt.search(objective_function, n_iter=n_iter)
48		n_transitions_1 = opt.n_transitions
49
50		opt = SimulatedAnnealingOptimizer(
51		search_space,
52		start_temp=start_temp_10,
53		epsilon=epsilon,
54		initialize={"random": n_initialize},
55		)
56		opt.search(objective_function, n_iter=n_iter)
57		n_transitions_10 = opt.n_transitions
58
59		opt = SimulatedAnnealingOptimizer(
60		search_space,
61		start_temp=start_temp_100,
62		epsilon=epsilon,
63		initialize={"random": n_initialize},
64		)
65		opt.search(objective_function, n_iter=n_iter)
66		n_transitions_100 = opt.n_transitions
67
68		opt = SimulatedAnnealingOptimizer(
69		search_space,
70		start_temp=start_temp_inf,
71		epsilon=epsilon,
72		initialize={"random": n_initialize},
73		)
74		opt.search(objective_function, n_iter=n_iter)
75		n_transitions_inf = opt.n_transitions
76
77		print("\n n_transitions_0", n_transitions_0)
78		print("\n n_transitions_1", n_transitions_1)
79		print("\n n_transitions_10", n_transitions_10)
80		print("\n n_transitions_100", n_transitions_100)
81		print("\n n_transitions_inf", n_transitions_inf)
82
83		assert n_transitions_0 == start_temp_0
84		assert (
85		n_transitions_1
86		== n_transitions_10
87		== n_transitions_100
88		== n_transitions_inf
89		== n_iter - n_initialize
90		)
91
92
93	View Code Duplication	def test_start_temp_1():
		0 ignored issues – show Duplication introduced 2024-05-09 13:48 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
94		n_initialize = 1
95
96		start_temp_0 = 0
97		start_temp_1 = 0.1
98		start_temp_10 = 1
99		start_temp_100 = 100
100		start_temp_inf = np.inf
101
102		epsilon = 0.03
103
104		opt = SimulatedAnnealingOptimizer(
105		search_space,
106		start_temp=start_temp_0,
107		epsilon=epsilon,
108		initialize={"random": n_initialize},
109		)
110		opt.search(objective_function, n_iter=n_iter)
111		n_transitions_0 = opt.n_transitions
112
113		opt = SimulatedAnnealingOptimizer(
114		search_space,
115		start_temp=start_temp_1,
116		epsilon=epsilon,
117		initialize={"random": n_initialize},
118		)
119		opt.search(objective_function, n_iter=n_iter)
120		n_transitions_1 = opt.n_transitions
121
122		opt = SimulatedAnnealingOptimizer(
123		search_space,
124		start_temp=start_temp_10,
125		epsilon=epsilon,
126		initialize={"random": n_initialize},
127		)
128		opt.search(objective_function, n_iter=n_iter)
129		n_transitions_10 = opt.n_transitions
130
131		opt = SimulatedAnnealingOptimizer(
132		search_space,
133		start_temp=start_temp_100,
134		epsilon=epsilon,
135		initialize={"random": n_initialize},
136		)
137		opt.search(objective_function, n_iter=n_iter)
138		n_transitions_100 = opt.n_transitions
139
140		opt = SimulatedAnnealingOptimizer(
141		search_space,
142		start_temp=start_temp_inf,
143		epsilon=epsilon,
144		initialize={"random": n_initialize},
145		)
146		opt.search(objective_function, n_iter=n_iter)
147		n_transitions_inf = opt.n_transitions
148
149		print("\n n_transitions_0", n_transitions_0)
150		print("\n n_transitions_1", n_transitions_1)
151		print("\n n_transitions_10", n_transitions_10)
152		print("\n n_transitions_100", n_transitions_100)
153		print("\n n_transitions_inf", n_transitions_inf)
154
155		assert n_transitions_0 == start_temp_0
156		assert n_transitions_1 < n_transitions_10 < n_transitions_100 < n_transitions_inf
157
158
159		def test_annealing_rate_0():
160		n_initialize = 1
161
162		annealing_rate_0 = 0
163		annealing_rate_1 = 0.1
164		annealing_rate_10 = 0.5
165		annealing_rate_100 = 0.9
166
167		epsilon = 0.03
168
169		opt = SimulatedAnnealingOptimizer(
170		search_space,
171		annealing_rate=annealing_rate_0,
172		epsilon=epsilon,
173		initialize={"random": n_initialize},
174		)
175		opt.search(objective_function, n_iter=n_iter)
176		n_transitions_0 = opt.n_transitions
177
178		opt = SimulatedAnnealingOptimizer(
179		search_space,
180		annealing_rate=annealing_rate_1,
181		epsilon=epsilon,
182		initialize={"random": n_initialize},
183		)
184		opt.search(objective_function, n_iter=n_iter)
185		n_transitions_1 = opt.n_transitions
186
187		opt = SimulatedAnnealingOptimizer(
188		search_space,
189		annealing_rate=annealing_rate_10,
190		epsilon=epsilon,
191		initialize={"random": n_initialize},
192		)
193		opt.search(objective_function, n_iter=n_iter)
194		n_transitions_10 = opt.n_transitions
195
196		opt = SimulatedAnnealingOptimizer(
197		search_space,
198		annealing_rate=annealing_rate_100,
199		epsilon=epsilon,
200		initialize={"random": n_initialize},
201		)
202		opt.search(objective_function, n_iter=n_iter)
203		n_transitions_100 = opt.n_transitions
204
205		print("\n n_transitions_0", n_transitions_0)
206		print("\n n_transitions_1", n_transitions_1)
207		print("\n n_transitions_10", n_transitions_10)
208		print("\n n_transitions_100", n_transitions_100)
209
210		assert n_transitions_0 in [0, 1]
211		# assert n_transitions_1 < n_transitions_10 < n_transitions_100
212

SimonBlanke / Gradient-Free-Optimizers

Push — master ( 502a6e...660aa4 )

tests.test_parameters.test_simulated_annealing A

Complexity

Size/Duplication

Importance

3 Functions

How to fix Duplicated Code

Duplicated Code

Duplication Side-by-Side

Filter issues like