def test_unbounded_active_variable_domain(self):
        np.random.seed(42)
        df = np.random.normal(size=(10, 3))

        sub = ss.Subspaces()
        sub.compute(df=df)
        uavd = dom.UnboundedActiveVariableDomain(sub)
    def test_rs_0(self):
        np.random.seed(42)
        df0 = np.random.normal(size=(10, 2))

        sub = ss.Subspaces()
        sub.compute(df=df0)
        avd = dom.UnboundedActiveVariableDomain(sub)
        avm = dom.UnboundedActiveVariableMap(avd)
        asm.ActiveSubspaceResponseSurface(avm)
    def test_fun_ubnd_int(self):
        np.random.seed(42)
        X0 = np.random.normal(size=(50,3))
        f0 = np.random.normal(size=(50,1))
        df0 = np.random.normal(size=(50,3))

        sub = ss.Subspaces()
        sub.compute(df=df0)
        sub.partition(1)

        avd = dom.UnboundedActiveVariableDomain(sub)
        avm = dom.UnboundedActiveVariableMap(avd)

        mu, lb, ub = asi.integrate(self.quad_fun, avm, 10)
    def test_unbounded_active_variable_map_1(self):
        np.random.seed(42)
        df0 = np.random.normal(size=(10, 3))

        sub = ss.Subspaces()
        sub.compute(df=df0)
        m, n = sub.W1.shape

        uavd = dom.UnboundedActiveVariableDomain(sub)
        uavm = dom.UnboundedActiveVariableMap(uavd)

        X = np.random.normal(size=(100, m))
        Y, Z = uavm.forward(X)
        X0 = np.dot(Y, sub.W1.T) + np.dot(Z, sub.W2.T)
        np.testing.assert_almost_equal(X0, X)
    def test_sample_z(self):
        np.random.seed(42)
        df0 = np.random.normal(size=(10, 3))

        sub = ss.Subspaces()
        sub.compute(df=df0)
        W1, W2 = sub.W1, sub.W2
        m, n = W1.shape

        np.random.seed(43)
        x = np.random.uniform(-1.0, 1.0, size=(1, m))
        y = np.dot(x, W1).reshape((n, ))
        N = 10
        np.random.seed(42)
        Z = dom.sample_z(N, y, W1, W2)
    def test_rs_bnd_2d_int(self):
        np.random.seed(42)
        X0 = np.random.uniform(-1.0,1.0,size=(50,3))
        f0 = np.random.normal(size=(50,1))
        df0 = np.random.normal(size=(50,3))

        sub = ss.Subspaces()
        sub.compute(df=df0)
        sub.partition(2)

        avd = dom.BoundedActiveVariableDomain(sub)
        avm = dom.BoundedActiveVariableMap(avd)
        asrs = asm.ActiveSubspaceResponseSurface(avm)
        asrs.train_with_data(X0, f0)

        I = asi.av_integrate(asrs, avm, 10)
    def test_unbounded_active_variable_map_3(self):
        np.random.seed(42)
        df0 = np.random.normal(size=(10, 3))

        sub = ss.Subspaces()
        sub.compute(df=df0)
        m, n = sub.W1.shape

        uavd = dom.UnboundedActiveVariableDomain(sub)
        uavm = dom.UnboundedActiveVariableMap(uavd)

        X = np.random.normal(size=(100, m))
        Y, Z = uavm.forward(X)
        X0 = uavm.inverse(Y, N=10)[0]
        np.testing.assert_almost_equal(np.dot(X0, sub.W1),
                                       np.kron(Y, np.ones((10, 1))))
    def test_bounded_active_variable_map_3(self):
        np.random.seed(42)
        df0 = np.random.normal(size=(10, 3))

        sub = ss.Subspaces()
        sub.compute(df=df0)
        m, n = sub.W1.shape

        bavd = dom.BoundedActiveVariableDomain(sub)
        bavm = dom.BoundedActiveVariableMap(bavd)

        X = np.random.uniform(-1.0, 1.0, size=(10, m))
        Y, Z = bavm.forward(X)
        X0 = bavm.inverse(Y, N=10)[0]
        np.testing.assert_almost_equal(np.dot(X0, sub.W1),
                                       np.kron(Y, np.ones((10, 1))))
        np.testing.assert_equal(np.floor(np.abs(X0)), np.zeros(X0.shape))
    def test_rs_data_train_pr_bnd(self):
        np.random.seed(42)
        X0 = np.random.uniform(-1.0, 1.0, size=(50, 3))
        f0 = np.random.normal(size=(50, 1))
        df0 = np.random.normal(size=(50, 3))

        sub = ss.Subspaces()
        sub.compute(df=df0)

        avd = dom.BoundedActiveVariableDomain(sub)
        avm = dom.BoundedActiveVariableMap(avd)
        pr = rs.PolynomialApproximation()
        asrs = asm.ActiveSubspaceResponseSurface(avm, pr)
        asrs.train_with_data(X0, f0)

        XX = np.random.uniform(-1.0, 1.0, size=(10, 3))
        ff, dff = asrs.predict(XX, compgrad=True)
    def test_rs_data_train_gp_ubnd(self):
        np.random.seed(42)
        X0 = np.random.normal(size=(50, 3))
        f0 = np.random.normal(size=(50, 1))
        df0 = np.random.normal(size=(50, 3))

        sub = ss.Subspaces()
        sub.compute(df=df0)

        avd = dom.UnboundedActiveVariableDomain(sub)
        avm = dom.UnboundedActiveVariableMap(avd)
        asrs = asm.ActiveSubspaceResponseSurface(avm)
        asrs.train_with_data(X0, f0)

        np.random.seed(43)
        XX = np.random.normal(size=(10, 3))
        ff, dff = asrs.predict(XX, compgrad=True)
    def test_rs_fun_train_gp_bnd(self):
        np.random.seed(42)
        X0 = np.random.uniform(-1.0, 1.0, size=(50, 3))
        f0 = np.random.normal(size=(50, 1))
        df0 = np.random.normal(size=(50, 3))

        sub = ss.Subspaces()
        sub.compute(df=df0)

        avd = dom.BoundedActiveVariableDomain(sub)
        avm = dom.BoundedActiveVariableMap(avd)
        asrs = asm.ActiveSubspaceResponseSurface(avm)

        asrs.train_with_interface(self.quad_fun, 10)

        XX = np.random.uniform(-1.0, 1.0, size=(10, 3))
        ff, dff = asrs.predict(XX, compgrad=True)
    def test_rs_fun_train_pr_ubnd_2d(self):
        np.random.seed(42)
        X0 = np.random.normal(size=(50, 3))
        f0 = np.random.normal(size=(50, 1))
        df0 = np.random.normal(size=(50, 3))

        sub = ss.Subspaces()
        sub.compute(df=df0)
        sub.partition(2)

        avd = dom.UnboundedActiveVariableDomain(sub)
        avm = dom.UnboundedActiveVariableMap(avd)
        pr = rs.PolynomialApproximation()
        asrs = asm.ActiveSubspaceResponseSurface(avm, pr)

        asrs.train_with_interface(self.quad_fun, 10)

        XX = np.random.normal(size=(10, 3))
        ff, dff = asrs.predict(XX, compgrad=True)
    def test_rs_bnd_2d_int(self):
        np.random.seed(42)
        X0 = np.random.uniform(-1.,1.,size=(50,3))
        f0 = np.zeros((50,1))
        df0 = np.zeros((50,3))
        for i in range(50):
            x = X0[i,:]
            f0[i,0] = self.quad_fun(x)
            df0[i,:] = self.quad_dfun(x).reshape((3, ))

        sub = ss.Subspaces()
        sub.compute(df=df0)
        sub.partition(2)

        avd = dom.BoundedActiveVariableDomain(sub)
        avm = dom.BoundedActiveVariableMap(avd)
        asrs = asm.ActiveSubspaceResponseSurface(avm)
        asrs.train_with_data(X0, f0)

        xstar, fstar = aso.minimize(asrs, X0, f0)
示例#14
0
 def test_subspace_class(self):
     np.random.seed(42)
     X = np.random.normal(size=(50,3))
     f = np.random.normal(size=(50,1))
     df = np.random.normal(size=(50,3))
     weights = np.ones((50,1)) / 50
     
     sub = ss.Subspaces()
     sub.compute(X, f, df, weights)
     sub.compute(X, f, df, weights, sstype='AS')
     sub.compute(X, f, df, weights, sstype='OLS')
     sub.compute(X, f, df, weights, sstype='QPHD')
     sub.compute(X, f, df, weights, sstype='OPG')
     
     sub.compute(X, f, df, weights, sstype='AS', nboot=10)
     sub.compute(X, f, df, weights, sstype='OLS', nboot=10)
     sub.compute(X, f, df, weights, sstype='QPHD', nboot=10)
     sub.compute(X, f, df, weights, sstype='OPG', nboot=10)
     
     sub.compute(X, f, df, weights, sstype='AS', ptype='EVG', nboot=100)
     sub.compute(X, f, df, weights, sstype='AS', ptype='RS', nboot=100)
     sub.compute(X, f, df, weights, sstype='AS', ptype='LI', nboot=100)