hyperactive.optimizers.DictClass.__getitem__() - 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

hyperactive.optimizers.DictClass.getitem() A

↳ Parent: hyperactive.optimizers

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

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

import numpy as np
import pandas as pd

from gradient_free_optimizers import (
    HillClimbingOptimizer as _HillClimbingOptimizer,
    StochasticHillClimbingOptimizer as _StochasticHillClimbingOptimizer,
    RepulsingHillClimbingOptimizer as _RepulsingHillClimbingOptimizer,
    RandomSearchOptimizer as _RandomSearchOptimizer,
    RandomRestartHillClimbingOptimizer as _RandomRestartHillClimbingOptimizer,
    RandomAnnealingOptimizer as _RandomAnnealingOptimizer,
    SimulatedAnnealingOptimizer as _SimulatedAnnealingOptimizer,
    ParallelTemperingOptimizer as _ParallelTemperingOptimizer,
    ParticleSwarmOptimizer as _ParticleSwarmOptimizer,
    EvolutionStrategyOptimizer as _EvolutionStrategyOptimizer,
    BayesianOptimizer as _BayesianOptimizer,
    TreeStructuredParzenEstimators as _TreeStructuredParzenEstimators,
    DecisionTreeOptimizer as _DecisionTreeOptimizer,
    EnsembleOptimizer as _EnsembleOptimizer,
)

from .hyper_gradient_trafo import HyperGradientTrafo


class DictClass:
    def __init__(self):
        self.para_dict = {}

    def __getitem__(self, key):
        return self.para_dict[key]

    def keys(self):
        return self.para_dict.keys()

    def values(self):
        return self.para_dict.values()


class TrafoClass:
    def __init__(self, *args, **kwargs):
        pass

    def _convert_args2gfo(self, memory_warm_start):
        memory_warm_start = self.trafo.trafo_memory_warm_start(memory_warm_start)

        return memory_warm_start

    def _positions2results(self, positions):
        results_dict = {}

        for para_name in self.conv.para_names:
            values_list = self.search_space[para_name]
            pos_ = positions[para_name].values
            values_ = [values_list[idx] for idx in pos_]
            results_dict[para_name] = values_

        results = pd.DataFrame.from_dict(results_dict)

        diff_list = np.setdiff1d(positions.columns, results.columns)
        results[diff_list] = positions[diff_list]

        return results

    def _convert_results2hyper(self):
        self.eval_time = np.array(self.optimizer.eval_times).sum()
        self.iter_time = np.array(self.optimizer.iter_times).sum()

        value = self.trafo.para2value(self.optimizer.best_para)
        position = self.trafo.position2value(value)
        best_para = self.trafo.value2para(position)

        self.best_para = best_para
        self.best_score = self.optimizer.best_score
        self.positions = self.optimizer.results

        self.results = self._positions2results(self.positions)

        self.memory_positions = self.trafo._memory2dataframe(self.optimizer.memory_dict)
        self.memory_values_df = self._positions2results(self.memory_positions)


class _BaseOptimizer_(DictClass, TrafoClass):
    def __init__(self, **opt_params):
        super().__init__()
        self.opt_params = opt_params

    def init(self, search_space, initialize={"grid": 8, "random": 4, "vertices": 8}):
        self.search_space = search_space

        self.trafo = HyperGradientTrafo(search_space)

        initialize = self.trafo.trafo_initialize(initialize)
        search_space_positions = self.trafo.search_space_positions

        self.optimizer = self._OptimizerClass(
            search_space_positions, initialize, **self.opt_params
        )

        self.conv = self.optimizer.conv

    def print_info(self, *args):
        self.optimizer.print_info(*args)

    def search(
        self,
        objective_function,
        n_iter,
        warm_start=None,
        max_time=None,
        max_score=None,
        memory=True,
        memory_warm_start=None,
        verbosity={
            "progress_bar": True,
            "print_results": True,
            "print_times": True,
        },
        random_state=None,
        nth_process=None,
    ):
        memory_warm_start = self._convert_args2gfo(memory_warm_start)

        self.optimizer.search(
            objective_function,
            n_iter,
            max_time,
            max_score,
            memory,
            memory_warm_start,
            verbosity,
            random_state,
            nth_process,
        )

        self._convert_results2hyper()


class HillClimbingOptimizer(_BaseOptimizer_):
    def __init__(self, **opt_params):
        super().__init__(**opt_params)
        self._OptimizerClass = _HillClimbingOptimizer


class StochasticHillClimbingOptimizer(_BaseOptimizer_):
    def __init__(self, **opt_params):
        super().__init__(**opt_params)
        self._OptimizerClass = _StochasticHillClimbingOptimizer


class RepulsingHillClimbingOptimizer(_BaseOptimizer_):
    def __init__(self, **opt_params):
        super().__init__(**opt_params)
        self._OptimizerClass = _RepulsingHillClimbingOptimizer


class RandomSearchOptimizer(_BaseOptimizer_):
    def __init__(self, **opt_params):
        super().__init__(**opt_params)
        self._OptimizerClass = _RandomSearchOptimizer


class RandomRestartHillClimbingOptimizer(_BaseOptimizer_):
    def __init__(self, **opt_params):
        super().__init__(**opt_params)
        self._OptimizerClass = _RandomRestartHillClimbingOptimizer


class RandomAnnealingOptimizer(_BaseOptimizer_):
    def __init__(self, **opt_params):
        super().__init__(**opt_params)
        self._OptimizerClass = _RandomAnnealingOptimizer


class SimulatedAnnealingOptimizer(_BaseOptimizer_):
    def __init__(self, **opt_params):
        super().__init__(**opt_params)
        self._OptimizerClass = _SimulatedAnnealingOptimizer


class ParallelTemperingOptimizer(_BaseOptimizer_):
    def __init__(self, **opt_params):
        super().__init__(**opt_params)
        self._OptimizerClass = _ParallelTemperingOptimizer


class ParticleSwarmOptimizer(_BaseOptimizer_):
    def __init__(self, **opt_params):
        super().__init__(**opt_params)
        self._OptimizerClass = _ParticleSwarmOptimizer


class EvolutionStrategyOptimizer(_BaseOptimizer_):
    def __init__(self, **opt_params):
        super().__init__(**opt_params)
        self._OptimizerClass = _EvolutionStrategyOptimizer


class BayesianOptimizer(_BaseOptimizer_):
    def __init__(self, **opt_params):
        super().__init__(**opt_params)
        self._OptimizerClass = _BayesianOptimizer


class TreeStructuredParzenEstimators(_BaseOptimizer_):
    def __init__(self, **opt_params):
        super().__init__(**opt_params)
        self._OptimizerClass = _TreeStructuredParzenEstimators


class DecisionTreeOptimizer(_BaseOptimizer_):
    def __init__(self, **opt_params):
        super().__init__(**opt_params)
        self._OptimizerClass = _DecisionTreeOptimizer


class EnsembleOptimizer(_BaseOptimizer_):
    def __init__(self, **opt_params):
        super().__init__(**opt_params)
        self._OptimizerClass = _EnsembleOptimizer


1			# Author: Simon Blanke
2			# Email: [email protected]
3			# License: MIT License
4
5			import numpy as np
6			import pandas as pd
7
8			from gradient_free_optimizers import (
9			HillClimbingOptimizer as _HillClimbingOptimizer,
10			StochasticHillClimbingOptimizer as _StochasticHillClimbingOptimizer,
11			RepulsingHillClimbingOptimizer as _RepulsingHillClimbingOptimizer,
12			RandomSearchOptimizer as _RandomSearchOptimizer,
13			RandomRestartHillClimbingOptimizer as _RandomRestartHillClimbingOptimizer,
14			RandomAnnealingOptimizer as _RandomAnnealingOptimizer,
15			SimulatedAnnealingOptimizer as _SimulatedAnnealingOptimizer,
16			ParallelTemperingOptimizer as _ParallelTemperingOptimizer,
17			ParticleSwarmOptimizer as _ParticleSwarmOptimizer,
18			EvolutionStrategyOptimizer as _EvolutionStrategyOptimizer,
19			BayesianOptimizer as _BayesianOptimizer,
20			TreeStructuredParzenEstimators as _TreeStructuredParzenEstimators,
21			DecisionTreeOptimizer as _DecisionTreeOptimizer,
22			EnsembleOptimizer as _EnsembleOptimizer,
23			)
24
25			from .hyper_gradient_trafo import HyperGradientTrafo
26
27
28			class DictClass:
29			def __init__(self):
30			self.para_dict = {}
31
32			def __getitem__(self, key):
33			return self.para_dict[key]
34
35			def keys(self):
36			return self.para_dict.keys()
37
38			def values(self):
39			return self.para_dict.values()
40
41
42			class TrafoClass:
43			def __init__(self, args, *kwargs):
44			pass
45
46			def _convert_args2gfo(self, memory_warm_start):
47			memory_warm_start = self.trafo.trafo_memory_warm_start(memory_warm_start)
48
49			return memory_warm_start
50
51			def _positions2results(self, positions):
52			results_dict = {}
53
54			for para_name in self.conv.para_names:
55			values_list = self.search_space[para_name]
56			pos_ = positions[para_name].values
57			values_ = [values_list[idx] for idx in pos_]
58			results_dict[para_name] = values_
59
60			results = pd.DataFrame.from_dict(results_dict)
61
62			diff_list = np.setdiff1d(positions.columns, results.columns)
63			results[diff_list] = positions[diff_list]
64
65			return results
66
67			def _convert_results2hyper(self):
68			self.eval_time = np.array(self.optimizer.eval_times).sum()
69			self.iter_time = np.array(self.optimizer.iter_times).sum()
70
71			value = self.trafo.para2value(self.optimizer.best_para)
72			position = self.trafo.position2value(value)
73			best_para = self.trafo.value2para(position)
74
75			self.best_para = best_para
76			self.best_score = self.optimizer.best_score
77			self.positions = self.optimizer.results
78
79			self.results = self._positions2results(self.positions)
80
81			self.memory_positions = self.trafo._memory2dataframe(self.optimizer.memory_dict)
82			self.memory_values_df = self._positions2results(self.memory_positions)
83
84
85			class _BaseOptimizer_(DictClass, TrafoClass):
86			def __init__(self, **opt_params):
87			super().__init__()
88			self.opt_params = opt_params
89
90			def init(self, search_space, initialize={"grid": 8, "random": 4, "vertices": 8}):
91			self.search_space = search_space
92
93			self.trafo = HyperGradientTrafo(search_space)
94
95			initialize = self.trafo.trafo_initialize(initialize)
96			search_space_positions = self.trafo.search_space_positions
97
98			self.optimizer = self._OptimizerClass(
99			search_space_positions, initialize, **self.opt_params
100			)
101
102			self.conv = self.optimizer.conv
103
104			def print_info(self, *args):
105			self.optimizer.print_info(*args)
106
107			def search(
108			self,
109			objective_function,
110			n_iter,
111			warm_start=None,
112			max_time=None,
113			max_score=None,
114			memory=True,
115			memory_warm_start=None,
116			verbosity={
117			"progress_bar": True,
118			"print_results": True,
119			"print_times": True,
120			},
121			random_state=None,
122			nth_process=None,
123			):
124			memory_warm_start = self._convert_args2gfo(memory_warm_start)
125
126			self.optimizer.search(
127			objective_function,
128			n_iter,
129			max_time,
130			max_score,
131			memory,
132			memory_warm_start,
133			verbosity,
134			random_state,
135			nth_process,
136			)
137
138			self._convert_results2hyper()
139
140
141			class HillClimbingOptimizer(_BaseOptimizer_):
142			def __init__(self, **opt_params):
143			super().__init__(**opt_params)
144			self._OptimizerClass = _HillClimbingOptimizer
145
146
147			class StochasticHillClimbingOptimizer(_BaseOptimizer_):
148			def __init__(self, **opt_params):
149			super().__init__(**opt_params)
150			self._OptimizerClass = _StochasticHillClimbingOptimizer
151
152
153			class RepulsingHillClimbingOptimizer(_BaseOptimizer_):
154			def __init__(self, **opt_params):
155			super().__init__(**opt_params)
156			self._OptimizerClass = _RepulsingHillClimbingOptimizer
157
158
159			class RandomSearchOptimizer(_BaseOptimizer_):
160			def __init__(self, **opt_params):
161			super().__init__(**opt_params)
162			self._OptimizerClass = _RandomSearchOptimizer
163
164
165			class RandomRestartHillClimbingOptimizer(_BaseOptimizer_):
166			def __init__(self, **opt_params):
167			super().__init__(**opt_params)
168			self._OptimizerClass = _RandomRestartHillClimbingOptimizer
169
170
171			class RandomAnnealingOptimizer(_BaseOptimizer_):
172			def __init__(self, **opt_params):
173			super().__init__(**opt_params)
174			self._OptimizerClass = _RandomAnnealingOptimizer
175
176
177			class SimulatedAnnealingOptimizer(_BaseOptimizer_):
178			def __init__(self, **opt_params):
179			super().__init__(**opt_params)
180			self._OptimizerClass = _SimulatedAnnealingOptimizer
181
182
183			class ParallelTemperingOptimizer(_BaseOptimizer_):
184			def __init__(self, **opt_params):
185			super().__init__(**opt_params)
186			self._OptimizerClass = _ParallelTemperingOptimizer
187
188
189			class ParticleSwarmOptimizer(_BaseOptimizer_):
190			def __init__(self, **opt_params):
191			super().__init__(**opt_params)
192			self._OptimizerClass = _ParticleSwarmOptimizer
193
194
195			class EvolutionStrategyOptimizer(_BaseOptimizer_):
196			def __init__(self, **opt_params):
197			super().__init__(**opt_params)
198			self._OptimizerClass = _EvolutionStrategyOptimizer
199
200
201			class BayesianOptimizer(_BaseOptimizer_):
202			def __init__(self, **opt_params):
203			super().__init__(**opt_params)
204			self._OptimizerClass = _BayesianOptimizer
205
206
207			class TreeStructuredParzenEstimators(_BaseOptimizer_):
208			def __init__(self, **opt_params):
209			super().__init__(**opt_params)
210			self._OptimizerClass = _TreeStructuredParzenEstimators
211
212
213			class DecisionTreeOptimizer(_BaseOptimizer_):
214			def __init__(self, **opt_params):
215			super().__init__(**opt_params)
216			self._OptimizerClass = _DecisionTreeOptimizer
217
218
219			class EnsembleOptimizer(_BaseOptimizer_):
220			def __init__(self, **opt_params):
221			super().__init__(**opt_params)
222			self._OptimizerClass = _EnsembleOptimizer
223

SimonBlanke / Hyperactive

Push — master ( b8f359...927840 )

hyperactive.optimizers.DictClass.__getitem__() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

hyperactive.optimizers.DictClass.getitem() A