tests.test_parameters.test_simulated_annealing - Code Metrics - Inspection of "make statistical tests saver" - SimonBlanke/Gradient-Free-Optimizers - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 4ad3f7...f321c8 )

by Simon

created 2024-06-01 09:46 UTC

tests.test_parameters.test_simulated_annealing A

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	179
Duplicated Lines	0 %

Importance

Changes

Metric	Value
eloc	128
dl	0
loc	179
rs	10
c	0
b	0
f	0
wmc	3

3 Functions

Rating	Name	Size	Complexity
B	test_start_temp_0()	69	1
A	test_annealing_rate_0()	42	1
A	test_start_temp_1()	42	1

# 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.001
    start_temp_100 = 10000

    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_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_100", n_transitions_100)

    assert n_transitions_0 == start_temp_0
    assert n_transitions_1 < n_transitions_100


def test_annealing_rate_0():
    n_initialize = 1

    annealing_rate_0 = 0
    annealing_rate_1 = 0.1
    annealing_rate_100 = 0.99

    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_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_100", n_transitions_100)

    assert n_transitions_0 in [0, 1]
    assert n_transitions_1 < 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			def test_start_temp_0():
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			def test_start_temp_1():
94			n_initialize = 1
95
96			start_temp_0 = 0
97			start_temp_1 = 0.001
98			start_temp_100 = 10000
99
100			epsilon = 0.03
101
102			opt = SimulatedAnnealingOptimizer(
103			search_space,
104			start_temp=start_temp_0,
105			epsilon=epsilon,
106			initialize={"random": n_initialize},
107			)
108			opt.search(objective_function, n_iter=n_iter)
109			n_transitions_0 = opt.n_transitions
110
111			opt = SimulatedAnnealingOptimizer(
112			search_space,
113			start_temp=start_temp_1,
114			epsilon=epsilon,
115			initialize={"random": n_initialize},
116			)
117			opt.search(objective_function, n_iter=n_iter)
118			n_transitions_1 = opt.n_transitions
119
120			opt = SimulatedAnnealingOptimizer(
121			search_space,
122			start_temp=start_temp_100,
123			epsilon=epsilon,
124			initialize={"random": n_initialize},
125			)
126			opt.search(objective_function, n_iter=n_iter)
127			n_transitions_100 = opt.n_transitions
128
129			print("\n n_transitions_0", n_transitions_0)
130			print("\n n_transitions_1", n_transitions_1)
131			print("\n n_transitions_100", n_transitions_100)
132
133			assert n_transitions_0 == start_temp_0
134			assert n_transitions_1 < n_transitions_100
135
136
137			def test_annealing_rate_0():
138			n_initialize = 1
139
140			annealing_rate_0 = 0
141			annealing_rate_1 = 0.1
142			annealing_rate_100 = 0.99
143
144			epsilon = 0.03
145
146			opt = SimulatedAnnealingOptimizer(
147			search_space,
148			annealing_rate=annealing_rate_0,
149			epsilon=epsilon,
150			initialize={"random": n_initialize},
151			)
152			opt.search(objective_function, n_iter=n_iter)
153			n_transitions_0 = opt.n_transitions
154
155			opt = SimulatedAnnealingOptimizer(
156			search_space,
157			annealing_rate=annealing_rate_1,
158			epsilon=epsilon,
159			initialize={"random": n_initialize},
160			)
161			opt.search(objective_function, n_iter=n_iter)
162			n_transitions_1 = opt.n_transitions
163
164			opt = SimulatedAnnealingOptimizer(
165			search_space,
166			annealing_rate=annealing_rate_100,
167			epsilon=epsilon,
168			initialize={"random": n_initialize},
169			)
170			opt.search(objective_function, n_iter=n_iter)
171			n_transitions_100 = opt.n_transitions
172
173			print("\n n_transitions_0", n_transitions_0)
174			print("\n n_transitions_1", n_transitions_1)
175			print("\n n_transitions_100", n_transitions_100)
176
177			assert n_transitions_0 in [0, 1]
178			assert n_transitions_1 < n_transitions_100
179

SimonBlanke / Gradient-Free-Optimizers

Push — master ( 4ad3f7...f321c8 )

tests.test_parameters.test_simulated_annealing A

Complexity

Size/Duplication

Importance

3 Functions

Duplication Side-by-Side

Filter issues like