|
from typing import List, Dict |
|
import numpy as np |
|
|
|
|
|
def parameter_range_low_high(parameter_range: List): |
|
""" |
|
:param parameter_range:List[Float]--midpoints of bins |
|
:return: List[Float]--lower and upper bounds of bins |
|
""" |
|
temp1 = np.array(parameter_range[1:]) |
|
temp2 = np.array(parameter_range[:len(temp1)]) |
|
temp1 = 0.5 * (temp1 + temp2) |
|
|
|
return np.hstack([parameter_range[0], temp1, parameter_range[len(parameter_range) - 1]]) |
|
|
|
|
|
class ParameterValue: |
|
"""Describes a one hot encoded parameter value.""" |
|
|
|
name: str |
|
value: float |
|
encoding: List[float] |
|
index: int |
|
|
|
def __init__(self, name, value, encoding, index): |
|
self.name = name |
|
self.value = value |
|
self.encoding = encoding |
|
self.index = index |
|
|
|
|
|
class ParameterDescription: |
|
"""A description for generating a parameter value.""" |
|
|
|
|
|
def __init__(self, name, values: List[float], discrete=True): |
|
self.name = name |
|
self.values = values |
|
self.discrete = discrete |
|
self.parameter_low_high = parameter_range_low_high(values) |
|
|
|
|
|
|
|
def parameter_value(self, index, value=None) -> ParameterValue: |
|
if value is None: |
|
value = self.values[index] |
|
encoding = np.zeros(len(self.values), dtype=float) |
|
encoding[index] = 1.0 |
|
return ParameterValue( |
|
name=self.name, |
|
value=value, |
|
encoding=encoding, |
|
index=index |
|
) |
|
|
|
|
|
def generate(self) -> ParameterValue: |
|
|
|
if self.discrete: |
|
index = np.random.randint(0, len(self.values)) |
|
return self.parameter_value(index) |
|
|
|
else: |
|
indexFinder = np.random.uniform(0, 1) |
|
l = np.linspace(0.0, 1, len(self.values)) |
|
index = np.argmin(np.abs(l - indexFinder)) |
|
value = (self.parameter_low_high[index+1] - self.parameter_low_high[index]) * np.random.uniform(0, 1) + self.parameter_low_high[index] |
|
|
|
return self.parameter_value(index, value) |
|
|
|
|
|
def get_bin_index(self, value): |
|
return np.argmin(np.abs(np.array(self.values) - value)) |
|
|
|
def decode(self, encoding: List[float]) -> ParameterValue: |
|
index = np.array(encoding).argmax() |
|
return self.parameter_value(index) |
|
|
|
|
|
class Sample: |
|
"""Describes the label of one training sample.""" |
|
|
|
parameters: List[ParameterValue] |
|
|
|
def __init__(self, parameters): |
|
self.parameters = parameters |
|
|
|
def get_values(self) -> Dict[str, dict]: |
|
return { |
|
"parameters": {p.name: p.value for p in self.parameters}, |
|
"encoding": list(np.hstack(p.encoding for p in self.parameters)) |
|
} |