mosaictools 0.1.0__tar.gz

mosaictools-0.1.0/PKG-INFO

@@ -0,0 +1,17 @@
+Metadata-Version: 2.1
+Name: mosaictools
+Version: 0.1.0
+Summary: Surrogate modelling of modal properties using MOSAIC method
+Home-page: https://github.com/blazkurent/mosaictools/
+Author: Blaž Kurent
+Author-email: blaz.kurent@fgg.uni-lj.si
+License: UNKNOWN
+Description: # mosaictools
+        Python library for surrogate modelling of modal properties according to the Mode-Shape-Adapted Input parameter domain Curring (MOSAIC) method.
+        
+Platform: UNKNOWN
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Development Status :: 3 - Alpha
+Description-Content-Type: text/markdown

mosaictools-0.1.0/README.md

@@ -0,0 +1,2 @@
+# mosaictools
+Python library for surrogate modelling of modal properties according to the Mode-Shape-Adapted Input parameter domain Curring (MOSAIC) method.

mosaictools-0.1.0/mosaictools/__init__.py

@@ -0,0 +1,2 @@
+__version__ = '0.1.0'
+from .main import *

mosaictools-0.1.0/mosaictools/distributions.py

@@ -0,0 +1,115 @@
+# from polysys import LegendrePolynomials
+import numpy as np
+from scipy.stats.qmc import Halton as ghalton
+
+# class Distributin():
+#     def sample(self, n):
+#         xi = np.random.rand(n)
+#         return self.invcdf(xi)
+
+
+class UniformDistribution():
+    def __init__(self, a=0, b=1):
+        self.a = a
+        self.b = b
+
+    def __repr__(self):
+        return 'U({}, {})'.format(self.a, self.b)
+
+    def pdf(self, x):
+        a = self.a
+        b = self.b
+        y = 1 / (b - a) * np.ones(x.shape)
+        y[x < a] = 0
+        y[x > b] = 0
+        return y
+
+    def cdf(self, x):
+        a = self.a
+        b = self.b
+        y = (x - a) / (b - a)
+        y[x < a] = 0
+        y[x > b] = 1
+        return y
+
+    def invcdf(self, y):
+        a = self.a
+        b = self.b
+        x = np.full(y.shape, np.nan)
+        ind = (y >= 0) & (y <= 1)
+
+        x[ind] = a + (b - a) * y[ind]
+        return x
+
+    def sample(self, n, method='MC'):
+        if method == 'MC':
+            xi = np.random.rand(n)
+        elif method == 'QMC':
+            gen = ghalton.Halton(1)
+            xi = np.array(gen.get(n))  # dummy generation to avoid sample point q = 0
+        return self.invcdf(xi)
+
+    def moments(self):
+        return self.mean(), self.var(), self.skew(), self.kurt()
+
+    def mean(self):
+        return 0.5 * (self.a + self.b)
+
+    def var(self):
+        return (self.b - self.a) ** 2 / 12
+
+    def skew(self):
+        return 0
+
+    def kurt(self):
+        return -6 / 5
+
+    def translate(self, shift, scale):
+        m = (self.a + self.b) / 2
+        v = scale * (self.b - self.a) / 2
+
+        self.a = m + shift - v
+        self.b = m + shift + v
+
+    def get_base_dist(self):
+        dist_germ = UniformDistribution(-1, 1)
+        return dist_germ
+
+    def base2dist(self, y):
+        return self.mean() + y * (self.b - self.a) / 2
+
+    def dist2base(self, x):
+        return (x - self.mean()) * 2 / (self.b - self.a)
+
+    # def orth_polysys(self, normalized):
+    #     if self.a == -1 & self.b == 1:
+    #         if normalized:
+    #             polysys = LegendrePolynomials()
+    #         else:
+    #             polysys = LegendrePolynomials().normalized()
+    #     else:
+    #         polysys = []
+    #     return polysys
+
+    def orth_polysys_syschar(self, normalized):
+        if self.a == -1 and self.b == 1:
+            if normalized:
+                polysys_char = 'p'
+            else:
+                polysys_char = 'P'
+        else:
+            polysys_char = []
+        return polysys_char
+
+
+if __name__ == "__main__":
+    dist = UniformDistribution(-2,2)
+    print(dist.moments())
+    print(dist.pdf(np.array([-3,-2,-1,0,1,2,3])))
+    print(dist.cdf(np.array([-3, -2, -1, 0, 1, 2, 3])))
+    print(dist.get_base_dist().a, dist.get_base_dist().b)
+    print(dist.dist2base(np.array([-3, -2, -1, 0, 1, 2, 3])))
+    print(dist.base2dist(np.array([-2, -1, -0.5, 0, 0.5, 1, 2])))
+
+
+

mosaictools-0.1.0/mosaictools/gpc_functions.py

@@ -0,0 +1,15 @@
+from polysys import *
+
+def syschar_to_polysys(syschar):
+    poly_dict = {'H': HermitePolynomials,
+                 'h': HermitePolynomials.normalized(),
+                 'P': LegendrePolynomials,
+                 'p': LegendrePolynomials.normalized(),
+                 'T': ChebyshevTPolynomials,
+                 't': ChebyshevTPolynomials.normalized(),
+                 'U': ChebyshevUPolynomials,
+                 'u': ChebyshevUPolynomials.normalized(),
+                 'L': LaguerrePolynomials,
+                 'l': LaguerrePolynomials.normalized(),
+                 'M': Monomials}
+    return poly_dict[syschar]

mosaictools-0.1.0/mosaictools/gpc_surrogate.py

@@ -0,0 +1,150 @@
+import numpy as np
+from multiindex import *
+from gpc_functions import syschar_to_polysys
+
+# ##########################################################################################
+#                           GPC SURROGATE MODEL
+# ##########################################################################################
+class GpcSurrogateModel:
+    def __init__(self, Q, p=0, I="default", full_tensor=False, **kwargs):
+        self.basis = GpcBasis(Q, p=p, I="default", full_tensor=False)
+        self.Q = Q
+        self.u_i_alpha = []
+
+    def __repr__(self):
+        attrs = vars(self)
+        return ', '.join("%s: %s" % item for item in attrs.items())
+
+    def compute_coeffs_by_regression(self, q_j_k, u_i_k):
+        xi_j_k = self.Q.params2germ(q_j_k)
+        phi_alpha_k = self.basis.evaluate(xi_j_k)
+        u_i_alpha = np.matmul(u_i_k, np.linalg.pinv(phi_alpha_k))
+        self.u_i_alpha = u_i_alpha
+
+    def compute_coeffs_by_projection(self, q_j_k, u_i_k, w_k):
+        xi_j_k = self.Q.params2germ(q_j_k)
+        phi_alpha_k = self.basis.evaluate(xi_j_k)
+        u_i_alpha = np.matmul(u_i_k, np.diag(w_k), phi_alpha_k.transpose())
+        self.u_i_alpha = u_i_alpha
+
+    def predict_response(self, q_j_k):
+        xi_j_k = self.Q.params2germ(q_j_k)
+        phi_alpha_k = self.basis.evaluate(xi_j_k)
+        u_i_j = np.matmul(self.u_i_alpha, phi_alpha_k)
+        return u_i_j
+
+
+
+# ##########################################################################################
+#                           GPC BASIS
+# ##########################################################################################
+class GpcBasis:
+    # ---------------------Initialization---------------------------------------------------
+    def __init__(self, Q, p=0, I="default", full_tensor=False, **kwargs):
+        m = Q.num_params()
+        self.m = m
+
+        self.syschars = Q.get_gpc_syschars()
+        self.p = p
+
+        if I == "default":
+            self.I = multiindex(self.m, p, full_tensor=full_tensor)
+        else:
+            self.I = I
+
+    # ---------------------set how gpc looks when printed ---------------------------------------------------
+    def __repr__(self):
+        attrs = vars(self)
+        return ', '.join("%s: %s" % item for item in attrs.items())
+
+    # ----------------------------------------- size --------------------------------------------------
+    def size(self):
+        return [self.I.shape]
+
+    # ----------------------------Evaluate basis functions ---------------------------------------------------
+    def evaluate(self, xi, dual=False):
+        syschars = self.syschars
+        I = self.I
+        m = self.m
+        M = self.I.shape[0]
+        if xi.ndim == 1:
+            xi = xi.reshape(-1, 1)
+        k = xi.shape[1]
+        deg = max(self.I.flatten())
+
+        p = np.zeros([m, k, deg + 2])
+        p[:, :, 0] = np.zeros(xi.shape)
+        p[:, :, 1] = np.ones(xi.shape)
+
+        if len(syschars) == 1:
+            polysys = syschar_to_polysys(syschars)
+            r = polysys.recur_coeff(syschars, deg)
+            for d in range(deg):
+                p[:, :, d + 2] = (r[d, 0] + xi * r[d, 1]) * p[:, :, d + 1] - r[d, 2] * p[:, :, d]
+        else:
+            for j, syschar in enumerate(syschars):
+                polysys = syschar_to_polysys(syschar)
+                r = polysys.recur_coeff(deg)
+                for d in range(deg):
+                    p[j, :, d + 2] = (r[d, 0] + xi[j, :] * r[d, 1]) * p[j, :, d + 1] - r[d, 2] * p[j, :, d]
+
+        y_alpha_j = np.ones([M, k])
+        for j in range(m):
+            y_alpha_j = y_alpha_j * p[j, :, I[:, j] + 1]
+
+        if dual:
+            nrm2 = self.norm(do_sqrt=False)
+            y_alpha_j = (y_alpha_j / nrm2.reshape(-1, 1)).transpose()
+        return y_alpha_j
+
+    # ------------------------Compute the norm of the basis functions-----------------------
+    def norm(self, do_sqrt=True):
+        syschars = self.syschars
+        I = self.I
+        m = self.m
+        M = self.I.shape[0]
+
+        if syschars == syschars.lower():
+            norm_I = np.ones([M, 1])
+            return norm_I
+
+        if len(syschars) == 1:
+            # max degree of univariate polynomials
+            deg = max(self.I.flatten())
+            polysys = syschar_to_polysys(syschars)
+            nrm = polysys.sqnorm(range(deg + 1))
+            norm2_I = np.prod(nrm[I].reshape(I.shape), axis=1)
+
+        else:
+            norm2_I = np.ones([M])
+            for j in range(m):
+                deg = max(I[:, j])
+                polysys = syschar_to_polysys(syschars[j])
+                nrm2 = polysys.sqnorm(np.arange(deg + 1))
+                norm2_I = norm2_I * nrm2[I[:, j]]
+        if do_sqrt:
+            norm_I = np.sqrt(norm2_I)
+        else:
+            norm_I = norm2_I
+
+        return norm_I
+
+
+# ##########################################################################################
+#                           UTILS
+# ##########################################################################################
+
+#
+# ##########################################################################################
+#                           TEST
+# ##########################################################################################
+def main():
+    print(multiindex(3, 4))
+    gPCE = GpcSurrogateModel('PP', p=3)
+    gPCE.basis.norm()
+    print(gPCE.basis.evaluate(np.array([np.arange(-1, 1, 0.1)] * 2)))
+    print(gPCE)
+
+
+if __name__ == "__main__":
+    main()