Spaces:
Build error
Build error
| 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.""" | |
| # Discrete is used to generate samples that don't exactly fit into a bin for training. | |
| 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) | |
| # one-hot encoding as per paper | |
| # Value used for specifying a different value than values[index], useful for non-discrete params. todo: too adhoc? | |
| 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 | |
| ) | |
| # random even distribution as per paper | |
| def generate(self) -> ParameterValue: | |
| # choose a bin if parameter is discrete | |
| if self.discrete: | |
| index = np.random.randint(0, len(self.values)) | |
| return self.parameter_value(index) | |
| # otherwise generate a random value | |
| 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) | |
| # get the index of the best matching bin | |
| 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)) | |
| } |