moospread 0.1.0__py3-none-any.whl

moospread/utils/mobo_utils/mobo/transformation.py

@@ -0,0 +1,106 @@
+from abc import ABC, abstractmethod
+from sklearn.preprocessing import StandardScaler
+import numpy as np
+
+'''
+Data transformations (normalizations) for fitting surrogate model
+'''
+
+
+### 1-dim scaler
+
+class Scaler(ABC):
+    
+    def fit(self, X):
+        return self
+
+    @abstractmethod
+    def transform(self, X):
+        pass
+
+    @abstractmethod
+    def inverse_transform(self, X):
+        pass
+
+
+class BoundedScaler(Scaler):
+    '''
+    Scale data to [0, 1] according to bounds
+    '''
+    def __init__(self, bounds):
+        self.bounds = bounds
+
+    def transform(self, X):
+        #return np.clip((X - self.bounds[0]) / (self.bounds[1] - self.bounds[0]), 0, 1)
+        return (X - self.bounds[0]) / (self.bounds[1] - self.bounds[0])
+
+    def inverse_transform(self, X):
+        #return np.clip(X, 0, 1) * (self.bounds[1] - self.bounds[0]) + self.bounds[0]
+        return X * (self.bounds[1] - self.bounds[0]) + self.bounds[0]
+
+### 2-dim transformation
+
+class Transformation:
+
+    def __init__(self, x_scaler, y_scaler):
+        self.x_scaler = x_scaler
+        self.y_scaler = y_scaler
+
+    def fit(self, x, y):
+        self.x_scaler = self.x_scaler.fit(x)
+        self.y_scaler = self.y_scaler.fit(y)
+
+    def do(self, x=None, y=None):
+        assert x is not None or y is not None
+        if x is not None:
+            x_res = self.x_scaler.transform(np.atleast_2d(x))
+            if len(np.array(x).shape) < 2:
+                x_res = x_res.squeeze()
+
+        if y is not None:
+            y_res = self.y_scaler.transform(np.atleast_2d(y))
+            if len(np.array(y).shape) < 2:
+                y_res = y_res.squeeze()
+
+        if x is not None and y is not None:
+            return x_res, y_res
+        elif x is not None:
+            return x_res
+        elif y is not None:
+            return y_res
+
+    def undo(self, x=None, y=None):
+        assert x is not None or y is not None
+        if x is not None:
+            x_res = self.x_scaler.inverse_transform(np.atleast_2d(x))
+            if len(np.array(x).shape) < 2:
+                x_res = x_res.squeeze()
+
+        if y is not None:
+            y_res = self.y_scaler.inverse_transform(np.atleast_2d(y))
+            if len(np.array(y).shape) < 2:
+                y_res = y_res.squeeze()
+
+        if x is not None and y is not None:
+            return x_res, y_res
+        elif x is not None:
+            return x_res
+        elif y is not None:
+            return y_res
+    
+
+class StandardTransform(Transformation):
+
+    def __init__(self, x_bound):
+        super().__init__(
+            BoundedScaler(x_bound),
+            StandardScaler()
+        )
+
+class BoundTransform(Transformation):
+
+    def __init__(self, x_bound, y_bound):
+        super().__init__(
+            BoundedScaler(x_bound),
+            BoundedScaler(y_bound),
+        )

moospread/utils/mobo_utils/mobo/utils.py

@@ -0,0 +1,65 @@
+from time import time
+import numpy as np
+from pymoo.indicators.hv import HV
+
+
+class Timer:
+    '''
+    For time recording and message logging
+    '''
+    def __init__(self):
+        self.t = time()
+
+    def log(self, string=None, reset=True):
+        msg = '%.2fs' % (time() - self.t)
+
+        if string is not None:
+            msg = string + ': ' + msg
+        print(msg)
+        
+        if reset:
+            self.t = time()
+
+    def reset(self):
+        self.t = time()
+
+
+def find_pareto_front(Y, return_index=False):
+    '''
+    Find pareto front (undominated part) of the input performance data.
+    '''
+    if len(Y) == 0: return np.array([])
+    sorted_indices = np.argsort(Y.T[0])
+    pareto_indices = []
+    for idx in sorted_indices:
+        # check domination relationship
+        if not (np.logical_and((Y <= Y[idx]).all(axis=1), (Y < Y[idx]).any(axis=1))).any():
+            pareto_indices.append(idx)
+    pareto_front = Y[pareto_indices].copy()
+
+    if return_index:
+        return pareto_front, pareto_indices
+    else:
+        return pareto_front
+
+
+def calc_hypervolume(pfront, ref_point):
+    '''
+    Calculate hypervolume of pfront based on ref_point
+    '''
+    hv = HV(ref_point=ref_point)
+    return hv(pfront)
+
+
+def safe_divide(x1, x2):
+    '''
+    Divide x1 / x2, return 0 where x2 == 0
+    '''
+    return np.divide(x1, x2, out=np.zeros(np.broadcast(x1, x2).shape), where=(x2 != 0))
+
+
+def expand(x, axis=-1):
+    '''
+    Concise way of expand_dims
+    '''
+    return np.expand_dims(x, axis=axis)