romtools.workflows.parameters

  1import abc
  2import numpy as np
  3from scipy.stats import qmc
  4from scipy.stats import norm
  5from scipy.stats import triang
  6from scipy.stats import rv_continuous
  7
  8class Parameter(abc.ABC):
  9    '''Abstract implementation'''
 10
 11    @abc.abstractmethod
 12    def get_name(self) -> str:
 13        '''
 14        Returns parameter name
 15        '''
 16
 17    @abc.abstractmethod
 18    def get_dimensionality(self) -> int:
 19        '''
 20        Returns dimensionality of parameter for vector quantities.
 21        Returns 1 for scalar parameters
 22        '''
 23
 24    @abc.abstractmethod
 25    def scale_samples(self, uniform_dist_samples) -> np.array:
 26        '''
 27        Generates samples from the desired distribution given a set of samples
 28        from a uniform distribution on (0,1)
 29
 30        uniform_dist_samples should be of shape
 31        (number_of_samples, self.get_dimensionality())
 32
 33        Returns np.array of the same shape
 34        '''
 35
 36##########################################
 37# Concrete Parameter Classes
 38##########################################
 39
 40
 41class UniformParameter(Parameter):
 42    '''
 43    Uniformly distributed floating point
 44    '''
 45    def __init__(self, parameter_name: str,
 46                 lower_bound: float = 0,
 47                 upper_bound: float = 1):
 48        self._parameter_name = parameter_name
 49
 50        try:
 51            assert len(lower_bound) == len(upper_bound)
 52            self._dimension = len(lower_bound)
 53        except TypeError:
 54            self._dimension = 1
 55        self._lower_bound = lower_bound
 56        self._upper_bound = upper_bound
 57
 58    def get_name(self) -> str:
 59        return self._parameter_name
 60
 61    def get_dimensionality(self) -> int:
 62        return self._dimension
 63
 64    def scale_samples(self, uniform_dist_samples: np.array) -> np.array:
 65        assert uniform_dist_samples.shape[1] == self.get_dimensionality()
 66        return qmc.scale(uniform_dist_samples,
 67                         self._lower_bound,
 68                         self._upper_bound)
 69
 70
 71class StringParameter(Parameter):
 72    '''
 73    Constant string-valued parameter
 74    '''
 75    def __init__(self, parameter_name: str, value):
 76        self._parameter_name = parameter_name
 77        self._parameter_value = value
 78
 79    def get_name(self) -> str:
 80        return self._parameter_name
 81
 82    def get_dimensionality(self) -> int:
 83        return 1
 84
 85    def scale_samples(self, uniform_dist_samples: np.array) -> np.array:
 86        assert uniform_dist_samples.shape[1] == self.get_dimensionality()
 87        number_of_samples = uniform_dist_samples.shape[0]
 88        return np.array([[self._parameter_value]] * number_of_samples)
 89
 90
 91class GaussianParameter(Parameter):
 92    '''
 93    Normally distributed parameter
 94    '''
 95    def __init__(self, parameter_name: str,
 96                 mean: float = 0,
 97                 std: float = 1):
 98        self._parameter_name = parameter_name
 99        try:
100            assert len(mean) == len(std)
101            self._dimension = len(mean)
102        except TypeError:
103            self._dimension = 1
104        self._mean = mean
105        self._std = std
106
107    def get_name(self) -> str:
108        return self._parameter_name
109
110    def get_dimensionality(self) -> int:
111        return self._dimension
112
113    def scale_samples(self, uniform_dist_samples: np.array) -> np.array:
114        assert uniform_dist_samples.shape[1] == self.get_dimensionality()
115        return norm.ppf(uniform_dist_samples, loc=self._mean, scale=self._std)
116
117
118class TriangularParameter(Parameter):
119    '''
120    Random parameter with a triangular distribution
121    '''
122    def __init__(self, parameter_name: str,
123                 lower_bound: float = -1,
124                 peak: float = 0,
125                 upper_bound: float = 1):
126        self._parameter_name = parameter_name
127        try:
128            assert len(lower_bound) == len(peak)
129            assert len(lower_bound) == len(upper_bound)
130            self._dimension = len(lower_bound)
131        except TypeError:
132            self._dimension = 1
133        self._loc = lower_bound
134        self._scale = np.array(upper_bound) - np.array(lower_bound)
135        self._c = (np.array(peak) - np.array(lower_bound))/(self._scale)
136
137    def get_name(self) -> str:
138        return self._parameter_name
139
140    def get_dimensionality(self) -> int:
141        return self._dimension
142
143    def scale_samples(self, uniform_dist_samples: np.array) -> np.array:
144        assert uniform_dist_samples.shape[1] == self.get_dimensionality()
145        return triang.ppf(uniform_dist_samples, loc=self._loc, scale=self._scale, c=self._c)
146
147
148class ScipyDistributionParameter(Parameter):
149    '''
150    Random parameter with distribution described by a scipy.stats.rv_continuous object
151    '''
152
153    def __init__(self, parameter_name: str, distribution: rv_continuous, **kwargs):
154        self._parameter_name = parameter_name
155        self._dist_obj = distribution
156        self._kwargs = kwargs
157
158        try:
159            self._dimension = len(kwargs['loc'])
160        except TypeError:
161            self._dimension = 1
162
163    def get_name(self) -> str:
164        return self._parameter_name
165
166    def get_dimensionality(self) -> int:
167        return self._dimension
168
169    def scale_samples(self, uniform_dist_samples: np.array) -> np.array:
170        assert uniform_dist_samples.shape[1] == self.get_dimensionality()
171        return self._dist_obj.ppf(uniform_dist_samples, **self._kwargs)