fyrizi commited on
Commit
feb59a2
·
verified ·
1 Parent(s): a3783fb

Delete main/src/params.py with huggingface_hub

Browse files
Files changed (1) hide show
  1. main/src/params.py +0 -394
main/src/params.py DELETED
@@ -1,394 +0,0 @@
1
- import collections
2
- import re
3
- from abc import ABC, abstractmethod
4
- from typing import List, Optional, Dict, Any
5
-
6
- import numpy as np
7
- import logging
8
-
9
-
10
- logger = logging.getLogger(__name__)
11
-
12
-
13
- class HyperParam(ABC):
14
- """
15
- Represent an hyper-parameter
16
- """
17
- def __init__(self, name: str, default_value: Any, current_value: Any = None):
18
- """
19
-
20
- Args:
21
- name: a unique name of an hyper-parameter
22
- default_value: the default value of an hyper-parameter
23
- current_value: the current value of an hyper-parameter
24
- """
25
- self.default_value = default_value
26
- self.name = name
27
-
28
- if current_value is None:
29
- self.current_value = default_value
30
- else:
31
- self.current_value = current_value
32
-
33
- def set_value(self, value: Any) -> None:
34
- """
35
- Set the current value of an hyper-parameter
36
-
37
- Args:
38
- value: the new current value
39
- """
40
- self.current_value = value
41
-
42
- def get_value(self) -> Any:
43
- """
44
- return the current value of an hyper-parameter
45
- """
46
- return self.current_value
47
-
48
- @abstractmethod
49
- def randomize(self) -> None:
50
- """
51
- Randomize the current value of an hyper-parameter
52
- """
53
- pass
54
-
55
-
56
- class DiscreteValue(HyperParam):
57
- """
58
- Discrete value. This can be useful to select one choice among many
59
- """
60
- def __init__(self, name: str, default_value: Any, values: List[Any]):
61
- assert isinstance(values, list)
62
- assert default_value in values, f'invalid default! name={name} default_value={default_value} ' \
63
- f'not in values. Choices={values}'
64
- self.values = values
65
- super().__init__(name, default_value=default_value)
66
-
67
- def set_value(self, value: Any) -> None:
68
- assert value in self.values
69
- super().set_value(value)
70
-
71
- def randomize(self):
72
- v = np.random.randint(low=0, high=len(self.values))
73
- self.set_value(self.values[v])
74
-
75
- def __repr__(self):
76
- return f'DiscreteValue value={self.current_value}'
77
-
78
-
79
- def create_discrete_value(name: str, default_value: Any, values: List[Any]) -> Any:
80
- p = DiscreteValue(name, default_value, values)
81
- v = register_hparam(p)
82
- logger.debug(f'param={name}, value={v}')
83
- return v
84
-
85
-
86
- class DiscreteMapping(HyperParam):
87
- """
88
- Map discrete value to another discrete value
89
-
90
- e.g., this can be useful to test activation function as hyper-parameter
91
- """
92
- def __init__(self, name: str, default_value: Any, mapping: Dict[Any, Any]):
93
- """
94
-
95
- Args:
96
- name: the name of the hyper-parameter. Must be unique
97
- default_value: a default value (`key` in kvp)
98
- mapping: a mapping of key to value
99
- """
100
- assert isinstance(mapping, dict)
101
- assert default_value in mapping, f'`default_value={default_value}` is not in kvp! ' \
102
- f'Must be one of {mapping.keys()}'
103
- self.mapping = mapping
104
- self.key_value_list = list(mapping.items())
105
- super().__init__(name=name, default_value=default_value)
106
-
107
- def set_value(self, value: Any):
108
- assert value in self.mapping, f'current_value must be in the dictionary! c={value}'
109
- self.current_value = value
110
-
111
- def get_value(self):
112
- return self.mapping[self.current_value]
113
-
114
- def randomize(self):
115
- index = np.random.randint(low=0, high=len(self.key_value_list))
116
- key, _ = self.key_value_list[index]
117
- self.set_value(key)
118
-
119
- def __repr__(self):
120
- return f'DiscreteMapping value={self.current_value}'
121
-
122
-
123
- def create_discrete_mapping(name: str, default_value: Any, mapping: Dict[Any, Any]) -> Any:
124
- p = DiscreteMapping(name, default_value, mapping)
125
- v = register_hparam(p)
126
- logger.debug(f'param={name}, value={v}')
127
- return v
128
-
129
-
130
- class DiscreteInteger(HyperParam):
131
- """
132
- Represent an integer hyper-parameter
133
- """
134
- def __init__(self, name: str, default_value: int, min_range: int, max_range: int):
135
- """
136
-
137
- Args:
138
- name: the name of the hyper-parameter. Must be unique
139
- default_value: the default value
140
- min_range: maximum integer (inclusive) to be generated
141
- max_range: minimum integer (inclusive) to be generated
142
- """
143
- assert max_range >= min_range
144
- self.max_range = max_range
145
- self.min_range = min_range
146
- super().__init__(name, default_value)
147
-
148
- def randomize(self) -> None:
149
- v = np.random.randint(low=self.min_range, high=self.max_range + 1)
150
- self.set_value(v)
151
-
152
- def __repr__(self):
153
- return f'DiscreteInteger value={self.current_value} min={self.min_range}, max={self.max_range}'
154
-
155
-
156
- def create_discrete_integer(name: str, default_value: Any, min_range: int, max_range: int) -> Any:
157
- p = DiscreteInteger(name, default_value, min_range, max_range)
158
- v = register_hparam(p)
159
- logger.debug(f'param={name}, value={v}')
160
- return v
161
-
162
-
163
- class DiscreteBoolean(HyperParam):
164
- """
165
- Represent a boolean hyper-parameter
166
- """
167
- def __init__(self, name, default_value):
168
- """
169
-
170
- Args:
171
- name: the name of the hyper-parameter. Must be unique
172
- default_value: the initial boolean value
173
- """
174
- assert isinstance(default_value, bool)
175
- super().__init__(name, default_value=default_value)
176
-
177
- def randomize(self) -> None:
178
- v = bool(np.random.randint(low=0, high=1 + 1))
179
- self.set_value(v)
180
-
181
- def __repr__(self):
182
- return f'DiscreteBoolean value={self.current_value}'
183
-
184
-
185
- def create_boolean(name: str, default_value: Any) -> bool:
186
- p = DiscreteBoolean(name, default_value)
187
- v = register_hparam(p)
188
- logger.debug(f'param={name}, value={v}')
189
- return v
190
-
191
-
192
- class ContinuousUniform(HyperParam):
193
- """
194
- Represent a continuous hyper-parameter
195
- """
196
- def __init__(self, name: str, default_value: float, min_range: float, max_range: float):
197
- """
198
-
199
- Args:
200
- name: the name of the hyper-parameter. Must be unique
201
- default_value:
202
- min_range: minimum (inclusive) to be generated
203
- max_range: maximum (inclusive) to be generated
204
- """
205
- assert max_range >= min_range
206
- self.max_range = max_range
207
- self.min_range = min_range
208
- super().__init__(name, default_value)
209
-
210
- def randomize(self) -> None:
211
- v = np.random.uniform(low=self.min_range, high=self.max_range)
212
- self.set_value(v)
213
-
214
- def __repr__(self):
215
- return f'ContinuousUniform value={self.current_value}, min={self.min_range}, max={self.max_range}'
216
-
217
-
218
- def create_continuous_uniform(name: str, default_value: float, min_range: float, max_range: float) -> float:
219
- p = ContinuousUniform(name, default_value, min_range, max_range)
220
- v = register_hparam(p)
221
- logger.debug(f'param={name}, value={v}')
222
- return v
223
-
224
-
225
- class ContinuousPower(HyperParam):
226
- """
227
- Represent a continuous power hyper-parameter
228
-
229
- This type of distribution can be useful to test e.g., learning rate hyper-parameter. Given a
230
- random number x generated from uniform interval (min_range, max_range), return 10 ** x
231
-
232
- Examples:
233
- >>> hp1 = ContinuousPower('hp1', default_value=0.1, exponent_min=-5, exponent_max=-1)
234
- ``hp1.get_value()`` would return a value in the range(1e-1, 1e-5)
235
- """
236
- def __init__(self, name: str, default_value: float, exponent_min: float, exponent_max: float):
237
- """
238
- Args:
239
- name: the name of the hyper-parameter. Must be unique
240
- default_value: the current value of the parameter (power will ``NOT`` be applied)
241
- exponent_min: minimum floating number (inclusive) of the power exponent to be generated
242
- exponent_max: max_range: max floating number (inclusive) of the power exponent to be generated
243
- """
244
- assert exponent_max >= exponent_min
245
- assert default_value >= 10 ** exponent_min, 'make sure the current value must have the power already ' \
246
- 'applied and be within the generated interval'
247
- assert default_value <= 10 ** exponent_max, 'make sure the current value must have the power already ' \
248
- 'applied and be within the generated interval'
249
- self.exponent_max = exponent_max
250
- self.exponent_min = exponent_min
251
- super(ContinuousPower, self).__init__(name, default_value)
252
-
253
- def randomize(self) -> None:
254
- uniform = np.random.uniform(low=self.exponent_min, high=self.exponent_max)
255
- v = 10 ** uniform
256
- self.set_value(v)
257
-
258
- def __repr__(self):
259
- return f'ContinuousPower value={self.current_value}, min={self.exponent_min}, max={self.exponent_max}'
260
-
261
-
262
- def create_continuous_power(name: str, default_value: float, exponent_min: float, exponent_max: float) -> float:
263
- p = ContinuousPower(name, default_value, exponent_min, exponent_max)
264
- v = register_hparam(p)
265
- logger.debug(f'param={name}, value={v}')
266
- return v
267
-
268
-
269
- class HyperParameters:
270
- """
271
- Holds a repository a set of hyper-parameters
272
- """
273
- def __init__(self,
274
- hparams: Optional[Dict[str, HyperParam]] = None,
275
- randomize_at_creation: bool = False,
276
- hparams_to_randomize: Optional[List[str]] = None):
277
- """
278
- Create the hyper-parameter repository
279
-
280
- Args:
281
- hparams: pre-existing hyper-parameters or None
282
- randomize_at_creation: if True, the hyper-parameter will not have
283
- take default value at creation but random
284
- hparams_to_randomize: this is the list og hyper-parameters to randomize. Other hyper-parameters
285
- will be kept constant during optimization. If `None`, all hyper-parameters will be
286
- randomized. This can be a regular expression (e.g., `optimizer.*` so that we can match hierarchy
287
- of hyper-parameters)
288
- """
289
- self.hparams_to_randomize = hparams_to_randomize
290
- self.randomize_at_creation = randomize_at_creation
291
- if hparams is not None:
292
- self.hparams = hparams
293
- else:
294
- self.hparams = collections.OrderedDict()
295
-
296
- def hparam_to_be_randomized(self, haparam_name: str) -> bool:
297
- if self.hparams_to_randomize is None:
298
- return True
299
- for pattern in self.hparams_to_randomize:
300
- if re.search(pattern, haparam_name) is not None:
301
- return True
302
- return False
303
-
304
- def create(self, hparam: HyperParam) -> Any:
305
- """
306
- Create an hyper parameter if it is not already present. If it is present,
307
- the given `hparam` is ignored
308
-
309
- Args:
310
- hparam: the hyper-parameter
311
-
312
- Returns:
313
- the hyper parameter value
314
- """
315
- assert isinstance(hparam, HyperParam), 'must be an instance of HyperParam'
316
-
317
- stored_hparam = self.hparams.get(hparam.name)
318
- if stored_hparam is None:
319
- if self.randomize_at_creation:
320
- if self.hparam_to_be_randomized(hparam.name):
321
- # parameters not to be optimized should be
322
- # created with their default value!
323
- hparam.randomize()
324
- self.hparams[hparam.name] = hparam
325
- stored_hparam = hparam
326
- else:
327
- assert type(stored_hparam) == type(hparam), f'type mismatch (got={type(stored_hparam)} vs ' \
328
- f'created={type(hparam)}. Hyper-parameter name collision?)! '
329
-
330
- assert stored_hparam is not None
331
- return stored_hparam.get_value()
332
-
333
- def randomize(self) -> None:
334
- """
335
- Set hyper-parameter to a random value
336
- """
337
- for name, hparam in self.hparams.items():
338
- if self.hparam_to_be_randomized(name):
339
- hparam.randomize()
340
-
341
- def __getitem__(self, name: str):
342
- hp = self.hparams.get(name)
343
- assert hp is not None, f'`{name}` is not defined in the hyper-parameters!'
344
- return hp
345
-
346
- def get_value(self, name: str) -> Any:
347
- """
348
- Return the current value of an hyper-parameter
349
- """
350
- hparam = self.hparams.get(name)
351
- assert hparam is not None, 'can\'t find hparam=%s' % hparam
352
- return hparam.get_value()
353
-
354
- def __str__(self):
355
- return str(self.hparams)
356
-
357
- def __repr__(self):
358
- return str(self.hparams)
359
-
360
- def __len__(self):
361
- return len(self.hparams)
362
-
363
-
364
- class HyperParameterRepository:
365
- """
366
- Holds the current hyper-parameters
367
- """
368
- current_hparams: HyperParameters = HyperParameters()
369
-
370
- @staticmethod
371
- def reset(new_hparams: Optional[HyperParameters] = None) -> None:
372
- """
373
- Replace the existing hyper parameters by a new one
374
-
375
- Args:
376
- new_hparams: the new hyper-parameters
377
- """
378
- if new_hparams is None:
379
- new_hparams = HyperParameters()
380
-
381
- HyperParameterRepository.current_hparams = new_hparams
382
-
383
-
384
- def register_hparam(hparam: HyperParam) -> Any:
385
- """
386
- Create a hyper-parameter and record it in the :class:`HyperParameterRepository` repository
387
-
388
- Args:
389
- hparam: the hyper-parameter to be created
390
-
391
- Returns:
392
- the value of the hyper-parameter
393
- """
394
- return HyperParameterRepository.current_hparams.create(hparam)