Esempio n. 1
0
 def test_polynomial_bases(self):
     data = helper.load_test_npz('test_points_10_2.npz')
     X = data['X']
     data = helper.load_test_npz('test_poly_bases_3.npz')
     B, I = rs.polynomial_bases(X, 3)
     np.testing.assert_equal(B, data['B'])
     np.testing.assert_equal(I, data['I'])
    def test_local_linear_gradients(self):
        data = helper.load_test_npz('train_points_200_2.npz')
        X = data['X'].copy()
        f = 2 - 5 * X[:, 0] + 4 * X[:, 1]

        df = gr.local_linear_gradients(X, f)
        M = df.shape[0]
        np.testing.assert_array_almost_equal(df,
                                             np.tile(np.array([-5.0, 4.0]),
                                                     (M, 1)),
                                             decimal=9)

        df = gr.local_linear_gradients(X, f, p=8)
        M = df.shape[0]
        np.testing.assert_array_almost_equal(df,
                                             np.tile(np.array([-5.0, 4.0]),
                                                     (M, 1)),
                                             decimal=9)

        f = 2 - np.sin(X[:, 0]) + np.cos(X[:, 1])
        np.random.seed(1234)
        df = gr.local_linear_gradients(X, f)
        #np.savez('data/test_llm_gradients',df=df)
        data = helper.load_test_npz('test_llm_gradients.npz')
        np.testing.assert_equal(df, data['df'])
Esempio n. 3
0
    def test_fun_rs_bnd_2d_int(self):
        data = helper.load_test_npz('test_rs_1.npz')
        X, f, df = data['X'], data['f'], data['df']
        
        np.random.seed(43)
        model = base.ActiveSubspaceReducedModel(bounded_inputs=True)
        model.build_from_interface(X.shape[1], self.quad_fun, avdim=2)
        
        avg = model.average(20)[0]
        prob, pl, pu = model.probability(0.0, 1.0)
        fstar, xstar = model.minimum()

        np.savez('data/test_base_1_3',avg=avg, prob=prob, pl=pl, pu=pu, xstar=xstar, fstar=fstar)
        data_test = helper.load_test_npz('test_base_1_3.npz')
        np.testing.assert_equal(avg, data_test['avg'])
        np.testing.assert_equal(prob, data_test['prob'])
        np.testing.assert_equal(pl, data_test['pl'])
        np.testing.assert_equal(pu, data_test['pu'])
        np.testing.assert_equal(xstar, data_test['xstar'])
        np.testing.assert_equal(fstar, data_test['fstar'])
                
        print '\n'
        print 'ubnd avg: {:6.4f}'.format(avg)
        print 'ubnd prob: {:6.4f}, {:6.4f}, {:6.4f}'.format(pl,prob,pu)
        print 'ubnd min: {:6.4f}'.format(fstar)
        print 'ubnd xmin: {:6.4f}, {:6.4f}, {:6.4f}'.format(xstar[0,0],xstar[0,1],xstar[0,2])
 def test_rs_fun_train_gp_bnd_2d(self):
     data = helper.load_test_npz('test_rs_1.npz')
     X, f, df = data['X'], data['f'], data['df']
     
     sub = ss.Subspaces()
     sub.compute(df)
     sub.partition(2)
     
     avd = dom.BoundedActiveVariableDomain(sub)
     avm = dom.BoundedActiveVariableMap(avd)
     asrs = asm.ActiveSubspaceResponseSurface(avm)
     
     np.random.seed(43)
     asrs.train_with_interface(self.quad_fun, 10)
     
     XX = np.random.uniform(-1.0,1.0,size=(10, 3))
     ff, dff, vff = asrs.predict(XX, compgrad=True, compvar=True)
     #np.savez('data/test_rs_7_0',ff=ff,dff=dff,vff=vff)
     data_test = helper.load_test_npz('test_rs_7_0.npz')
     np.testing.assert_equal(ff, data_test['ff'])
     np.testing.assert_equal(asrs(XX), data_test['ff'])
     np.testing.assert_equal(dff, data_test['dff'])
     np.testing.assert_equal(asrs.gradient(XX), data_test['dff'])
     np.testing.assert_equal(vff, data_test['vff'])
     
     sr = srun.SimulationRunner(self.quad_fun)
     f_true = sr.run(XX)
     dsr = srun.SimulationGradientRunner(self.quad_dfun)
     df_true = dsr.run(XX)
     
     print '\n'
     print 'fun gp bnd 2d'
     print 'f error: {:6.4e}'.format(np.linalg.norm(ff-f_true)/np.linalg.norm(f_true))
     print 'df error: {:6.4e}'.format(np.linalg.norm(dff-df_true)/np.linalg.norm(df_true))
 def test_rs_data_train_pr_ubnd(self):
     data = helper.load_test_npz('test_rs_0.npz')
     X, f, df = data['X'], data['f'], data['df']
     
     sub = ss.Subspaces()
     sub.compute(df)
     
     avd = dom.UnboundedActiveVariableDomain(sub)
     avm = dom.UnboundedActiveVariableMap(avd)
     pr = rs.PolynomialRegression()
     asrs = asm.ActiveSubspaceResponseSurface(avm, respsurf=pr)
     asrs.train_with_data(X, f)
     
     np.random.seed(43)
     XX = np.random.normal(size=(10, 3))
     ff, dff, vff = asrs.predict(XX, compgrad=True, compvar=True)
     #np.savez('data/test_rs_0_2',ff=ff,dff=dff,vff=vff)
     
     data_test = helper.load_test_npz('test_rs_0_2.npz')
     np.testing.assert_equal(ff, data_test['ff'])
     np.testing.assert_equal(asrs(XX), data_test['ff'])
     np.testing.assert_equal(dff, data_test['dff'])
     np.testing.assert_equal(asrs.gradient(XX), data_test['dff'])
     np.testing.assert_equal(vff, data_test['vff'])
     
     sr = srun.SimulationRunner(self.quad_fun)
     f_true = sr.run(XX)
     dsr = srun.SimulationGradientRunner(self.quad_dfun)
     df_true = dsr.run(XX)
     
     print '\n'
     print 'data pr ubnd'
     print 'f error: {:6.4e}'.format(np.linalg.norm(ff-f_true)/np.linalg.norm(f_true))
     print 'df error: {:6.4e}'.format(np.linalg.norm(dff-df_true)/np.linalg.norm(df_true))
Esempio n. 6
0
    def test_exact_polynomial_approximation_1d(self):
        data = helper.load_test_npz('train_points_10_2.npz')
        X = data['X']
        X_1d = X[:, 0].copy()
        f_1d = 2 + 5 * X_1d

        pr = rs.PolynomialRegression(N=1)
        pr.train(X_1d, f_1d)
        data = helper.load_test_npz('test_points_10_2.npz')
        X = data['X']
        X_1d_test = X[:, 0].copy()
        f, df, v = pr.predict(X_1d_test, compgrad=True, compvar=True)
        np.testing.assert_almost_equal(f,
                                       2 + 5 * X_1d_test.reshape((10, 1)),
                                       decimal=10)
        np.testing.assert_almost_equal(df, 5 * np.ones((10, 1)), decimal=10)

        f_1d = 2 - 3 * X_1d + 5 * X_1d * X_1d
        pr = rs.PolynomialRegression(N=2)
        pr.train(X_1d, f_1d)
        data = helper.load_test_npz('test_points_10_2.npz')
        X = data['X']
        X_1d_test = X[:, 0].copy()
        f, df, v = pr.predict(X_1d_test, compgrad=True, compvar=True)
        f_test = 2 - 3 * X_1d_test + 5 * X_1d_test * X_1d_test
        df_test = -3 + 10 * X_1d_test
        np.testing.assert_almost_equal(f, f_test.reshape((10, 1)), decimal=10)
        np.testing.assert_almost_equal(df,
                                       df_test.reshape((10, 1)),
                                       decimal=10)
    def test_exact_rbf_approximation_1d(self):
        data = helper.load_test_npz('train_points_10_2.npz')
        X = data['X']
        M = X.shape[0]
        X_1d = X[:,0].copy().reshape((M,1))
        f_1d = 2 + 5*X_1d

        gp = rs.RadialBasisApproximation(N=1)
        gp.train(X_1d, f_1d)
        print 'Rsqr: {:6.4f}'.format(gp.Rsqr)
        data = helper.load_test_npz('test_points_10_2.npz')
        X = data['X']
        M = X.shape[0]
        X_1d_test = X[:,0].copy().reshape((M,1))
        f, df = gp.predict(X_1d_test, compgrad=True)
        np.testing.assert_almost_equal(f, 2+5*X_1d_test.reshape((10,1)), decimal=10)
        np.testing.assert_almost_equal(df, 5*np.ones((10,1)), decimal=10)

        f_1d = 2 - 3*X_1d + 5*X_1d*X_1d
        gp = rs.RadialBasisApproximation(N=2)
        gp.train(X_1d, f_1d)
        print 'Rsqr: {:6.4f}'.format(gp.Rsqr)
        data = helper.load_test_npz('test_points_10_2.npz')
        X = data['X']
        M = X.shape[0]
        X_1d_test = X[:,0].copy().reshape((M,1))
        f, df = gp.predict(X_1d_test, compgrad=True)
        f_test = 2 - 3*X_1d_test + 5*X_1d_test*X_1d_test
        df_test = -3 + 10*X_1d_test
        np.testing.assert_almost_equal(f, f_test.reshape((10,1)), decimal=10)
        np.testing.assert_almost_equal(df, df_test.reshape((10,1)), decimal=10)
    def test_rs_fun_train_pr_bnd(self):
        data = helper.load_test_npz('test_rs_1.npz')
        X, f, df = data['X'], data['f'], data['df']

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

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

        np.random.seed(43)
        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)
        if self.writeData:
            np.savez('data/test_rs_5_1',ff=ff,dff=dff)
        data_test = helper.load_test_npz('test_rs_5_1.npz')
        np.testing.assert_almost_equal(ff, data_test['ff'])
        np.testing.assert_almost_equal(asrs(XX), data_test['ff'])
        np.testing.assert_almost_equal(dff, data_test['dff'])
        np.testing.assert_almost_equal(asrs.gradient(XX), data_test['dff'])


        sr = srun.SimulationRunner(self.quad_fun)
        f_true = sr.run(XX)
        dsr = srun.SimulationGradientRunner(self.quad_dfun)
        df_true = dsr.run(XX)

        print '\n'
        print 'fun pr bnd'
        print 'f error: {:6.4e}'.format(np.linalg.norm(ff-f_true)/np.linalg.norm(f_true))
        print 'df error: {:6.4e}'.format(np.linalg.norm(dff-df_true)/np.linalg.norm(df_true))
    def test_polynomial_grad_2d(self):
        data = helper.load_test_npz('train_points_200_2.npz')
        X = data['X']
        X_train = X.copy()
        ff0 = np.cos(X_train[:,0]).reshape((200,1))
        ff1 = np.sin(X_train[:,1]).reshape((200,1))
        f_2d = ff0*ff1

        pr = rs.PolynomialApproximation(N=5)
        pr.train(X_train, f_2d)
        data = helper.load_test_npz('test_points_10_2.npz')
        X = data['X']
        X_test = X.copy()
        f0, df0 = pr.predict(X_test, compgrad=True)

        e = 1e-6
        X_testp = X_test.copy()
        X_testp[:,0] += e
        f1 = pr.predict(X_testp)[0]
        df1_fd = (f1 - f0)/e
        np.testing.assert_almost_equal(df0[:,0].reshape((10,1)), df1_fd, decimal=5)
        X_testp = X_test.copy()
        X_testp[:,1] += e
        f1 = pr.predict(X_testp)[0]
        df2_fd = (f1 - f0)/e
        np.testing.assert_almost_equal(df0[:,1].reshape((10,1)), df2_fd, decimal=5)
    def test_rs_data_train_gp_ubnd_2d(self):
        data = helper.load_test_npz('test_rs_0.npz')
        X, f, df = data['X'], data['f'], data['df']

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

        avd = dom.UnboundedActiveVariableDomain(sub)
        avm = dom.UnboundedActiveVariableMap(avd)
        asrs = asm.ActiveSubspaceResponseSurface(avm)
        asrs.train_with_data(X, f)

        np.random.seed(43)
        XX = np.random.normal(size=(10, 3))
        ff, dff = asrs.predict(XX, compgrad=True)
        if self.writeData:
            np.savez('data/test_rs_2_0',ff=ff,dff=dff)

        data_test = helper.load_test_npz('test_rs_2_0.npz')
        np.testing.assert_almost_equal(ff, data_test['ff'])
        np.testing.assert_almost_equal(asrs(XX), data_test['ff'])
        np.testing.assert_almost_equal(dff, data_test['dff'])
        np.testing.assert_almost_equal(asrs.gradient(XX), data_test['dff'])


        sr = srun.SimulationRunner(self.quad_fun)
        f_true = sr.run(XX)
        dsr = srun.SimulationGradientRunner(self.quad_dfun)
        df_true = dsr.run(XX)

        print '\n'
        print 'data gp ubnd 2d'
        print 'f error: {:6.4e}'.format(np.linalg.norm(ff-f_true)/np.linalg.norm(f_true))
        print 'df error: {:6.4e}'.format(np.linalg.norm(dff-df_true)/np.linalg.norm(df_true))
Esempio n. 11
0
    def test_gp_grad_2d(self):
        data = helper.load_test_npz('train_points_200_2.npz')
        X = data['X']
        X_train = X.copy()
        ff0 = np.cos(X_train[:, 0]).reshape((200, 1))
        ff1 = np.sin(X_train[:, 1]).reshape((200, 1))
        f_2d = ff0 * ff1

        gp = rs.GaussianProcess(N=5)
        gp.train(X_train, f_2d)
        data = helper.load_test_npz('test_points_10_2.npz')
        X = data['X']
        X_test = X.copy()
        f0, df0, v0 = gp.predict(X_test, compgrad=True, compvar=True)

        e = 1e-6
        X_testp = X_test.copy()
        X_testp[:, 0] += e
        f1 = gp.predict(X_testp)[0]
        df1_fd = (f1 - f0) / e
        np.testing.assert_almost_equal(df0[:, 0].reshape((10, 1)),
                                       df1_fd,
                                       decimal=5)
        X_testp = X_test.copy()
        X_testp[:, 1] += e
        f1 = gp.predict(X_testp)[0]
        df2_fd = (f1 - f0) / e
        np.testing.assert_almost_equal(df0[:, 1].reshape((10, 1)),
                                       df2_fd,
                                       decimal=5)
    def test_exact_rbf_approximation_2d(self):
        data = helper.load_test_npz('train_points_10_2.npz')
        X = data['X']
        X_train = X.copy()
        f_2d = 2 + 5*X_train[:,0] - 4*X_train[:,1]

        gp = rs.RadialBasisApproximation(N=1)
        gp.train(X_train, f_2d.reshape((f_2d.size,1)))
        print 'Rsqr: {:6.4f}'.format(gp.Rsqr)
        data = helper.load_test_npz('test_points_10_2.npz')
        X = data['X']
        X_test = X.copy()
        f, df = gp.predict(X_test, compgrad=True)
        f_test = 2 + 5*X_test[:,0] - 4*X_test[:,1]
        np.testing.assert_almost_equal(f, f_test.reshape((10,1)), decimal=10)
        np.testing.assert_almost_equal(df[:,0].reshape((10,1)), 5*np.ones((10,1)), decimal=10)
        np.testing.assert_almost_equal(df[:,1].reshape((10,1)), -4*np.ones((10,1)), decimal=10)

        f_2d = 2 - 3*X_train[:,1] + 5*X_train[:,0]*X_train[:,1]
        gp = rs.RadialBasisApproximation(N=2)
        gp.train(X_train, f_2d.reshape((f_2d.size,1)))
        print 'Rsqr: {:6.4f}'.format(gp.Rsqr)
        data = helper.load_test_npz('test_points_10_2.npz')
        X = data['X']
        X_test = X.copy()
        f, df = gp.predict(X_test, compgrad=True)
        f_test = 2 - 3*X_test[:,1] + 5*X_test[:,0]*X_test[:,1]
        df1_test = 5*X_test[:,1]
        df2_test = -3 + 5*X_test[:,0]
        np.testing.assert_almost_equal(f, f_test.reshape((10,1)), decimal=10)
        np.testing.assert_almost_equal(df[:,0].reshape((10,1)), df1_test.reshape((10,1)), decimal=10)
        np.testing.assert_almost_equal(df[:,1].reshape((10,1)), df2_test.reshape((10,1)), decimal=10)
 def test_exact_gp_approximation_1d(self):
     data = helper.load_test_npz('train_points_10_2.npz')
     X = data['X']
     M = X.shape[0]
     X_1d = X[:,0].copy().reshape((M,1))
     f_1d = 2 + 5*X_1d
     
     gp = rs.GaussianProcess(N=1)
     gp.train(X_1d, f_1d)
     data = helper.load_test_npz('test_points_10_2.npz')
     X = data['X']
     M = X.shape[0]
     X_1d_test = X[:,0].copy().reshape((M,1))
     f, df, v = gp.predict(X_1d_test, compgrad=True, compvar=True)
     np.testing.assert_almost_equal(f, 2+5*X_1d_test.reshape((10,1)), decimal=10)
     np.testing.assert_almost_equal(df, 5*np.ones((10,1)), decimal=10)
     
     f_1d = 2 - 3*X_1d + 5*X_1d*X_1d
     gp = rs.GaussianProcess(N=2)
     gp.train(X_1d, f_1d)
     data = helper.load_test_npz('test_points_10_2.npz')
     X = data['X']
     M = X.shape[0]
     X_1d_test = X[:,0].copy().reshape((M,1))
     f, df, v = gp.predict(X_1d_test, compgrad=True, compvar=True)
     f_test = 2 - 3*X_1d_test + 5*X_1d_test*X_1d_test
     df_test = -3 + 10*X_1d_test
     np.testing.assert_almost_equal(f, f_test.reshape((10,1)), decimal=10)
     np.testing.assert_almost_equal(df, df_test.reshape((10,1)), decimal=10)
 def test_polynomial_bases(self):
     data = helper.load_test_npz('test_points_10_2.npz')
     X = data['X']
     data = helper.load_test_npz('test_poly_bases_3.npz')
     B, I = rs.polynomial_bases(X, 3)
     np.testing.assert_equal(B, data['B'])
     np.testing.assert_equal(I, data['I'])
Esempio n. 15
0
    def test_gp_as(self):
        data = helper.load_test_npz('test_points_uniform_50_2.npz')
        X_test = data['X'].copy()
        data = helper.load_test_npz('train_points_200_2.npz')
        X_train = data['X'].copy()
        f_train = 2 + 5 * X_train[:,
                                  0] - 4 * X_train[:,
                                                   1] + 2 * X_train[:,
                                                                    0] * X_train[:,
                                                                                 1]

        gp = rs.GaussianProcess(N=1)
        e = np.array([1.0, 0.5, 0.1, 0.05, 0.01])
        gp.train(X_train, f_train, e=e)
        f, df, vf = gp.predict(X_test, compgrad=True, compvar=True)
        data = helper.load_test_npz('test_gp_0.npz')
        np.testing.assert_equal(f, data['f'])
        np.testing.assert_equal(df, data['df'])
        np.testing.assert_equal(vf, data['vf'])

        v = 0.0001 * np.ones(f_train.shape)
        gp.train(X_train, f_train, e=e, v=v)
        f, df, vf = gp.predict(X_test, compgrad=True, compvar=True)
        data = helper.load_test_npz('test_gp_1.npz')
        np.testing.assert_equal(f, data['f'])
        np.testing.assert_equal(df, data['df'])
        np.testing.assert_equal(vf, data['vf'])
 def test_exact_gp_approximation_2d(self):
     data = helper.load_test_npz('train_points_10_2.npz')
     X = data['X']
     X_train = X.copy()
     f_2d = 2 + 5*X_train[:,0] - 4*X_train[:,1]
     
     gp = rs.GaussianProcess(N=1)
     gp.train(X_train, f_2d.reshape((f_2d.size,1)))
     data = helper.load_test_npz('test_points_10_2.npz')
     X = data['X']
     X_test = X.copy()
     f, df, v = gp.predict(X_test, compgrad=True, compvar=True)
     f_test = 2 + 5*X_test[:,0] - 4*X_test[:,1]
     np.testing.assert_almost_equal(f, f_test.reshape((10,1)), decimal=10)
     np.testing.assert_almost_equal(df[:,0].reshape((10,1)), 5*np.ones((10,1)), decimal=10)
     np.testing.assert_almost_equal(df[:,1].reshape((10,1)), -4*np.ones((10,1)), decimal=10)
     
     f_2d = 2 - 3*X_train[:,1] + 5*X_train[:,0]*X_train[:,1]
     gp = rs.GaussianProcess(N=2)
     gp.train(X_train, f_2d.reshape((f_2d.size,1)))
     data = helper.load_test_npz('test_points_10_2.npz')
     X = data['X']
     X_test = X.copy()
     f, df, v = gp.predict(X_test, compgrad=True, compvar=True)
     f_test = 2 - 3*X_test[:,1] + 5*X_test[:,0]*X_test[:,1]
     df1_test = 5*X_test[:,1]
     df2_test = -3 + 5*X_test[:,0]
     np.testing.assert_almost_equal(f, f_test.reshape((10,1)), decimal=10)
     np.testing.assert_almost_equal(df[:,0].reshape((10,1)), df1_test.reshape((10,1)), decimal=10)
     np.testing.assert_almost_equal(df[:,1].reshape((10,1)), df2_test.reshape((10,1)), decimal=10)
    def test_gp_grad_2d(self):
        data = helper.load_test_npz('train_points_200_2.npz')
        X = data['X']
        X_train = X.copy()
        ff0 = np.cos(X_train[:,0]).reshape((200,1))
        ff1 = np.sin(X_train[:,1]).reshape((200,1))
        f_2d = ff0*ff1
        
        gp = rs.GaussianProcess(N=5)
        gp.train(X_train, f_2d)
        data = helper.load_test_npz('test_points_10_2.npz')
        X = data['X']
        X_test = X.copy()
        f0, df0, v0 = gp.predict(X_test, compgrad=True, compvar=True)

        e = 1e-6
        X_testp = X_test.copy()
        X_testp[:,0] += e
        f1 = gp.predict(X_testp)[0]
        df1_fd = (f1 - f0)/e
        np.testing.assert_almost_equal(df0[:,0].reshape((10,1)), df1_fd, decimal=5)
        X_testp = X_test.copy()
        X_testp[:,1] += e
        f1 = gp.predict(X_testp)[0]
        df2_fd = (f1 - f0)/e
        np.testing.assert_almost_equal(df0[:,1].reshape((10,1)), df2_fd, decimal=5)
    def test_gp_as(self):
        data = helper.load_test_npz('test_points_uniform_50_2.npz')
        X_test = data['X'].copy()
        data = helper.load_test_npz('train_points_200_2.npz')
        X_train = data['X'].copy()
        f_train = 2 + 5*X_train[:,0] - 4*X_train[:,1] +2*X_train[:,0]*X_train[:,1]

        gp = rs.GaussianProcess(N=1)
        e = np.array([1.0, 0.5, 0.1, 0.05, 0.01])
        gp.train(X_train, f_train.reshape((f_train.size,1)), e=e)
        f, df, vf = gp.predict(X_test, compgrad=True, compvar=True)
        #np.savez('data/test_gp_0',f=f,df=df,vf=vf)
        
        data = helper.load_test_npz('test_gp_0.npz')
        np.testing.assert_equal(f, data['f'])
        np.testing.assert_equal(df, data['df'])
        np.testing.assert_equal(vf, data['vf'])
        
        v = 0.0001*np.ones(f_train.shape)
        gp.train(X_train, f_train.reshape((f_train.size,1)), e=e, v=v)
        f, df, vf = gp.predict(X_test, compgrad=True, compvar=True)
        #np.savez('data/test_gp_1',f=f,df=df,vf=vf)
        
        data = helper.load_test_npz('test_gp_1.npz')
        np.testing.assert_equal(f, data['f'])
        np.testing.assert_equal(df, data['df'])
        np.testing.assert_equal(vf, data['vf'])
    def test_rbf_as(self):
        data = helper.load_test_npz('test_points_uniform_50_2.npz')
        X_test = data['X'].copy()
        data = helper.load_test_npz('train_points_200_2.npz')
        X_train = data['X'].copy()
        f_train = 2 + 5*X_train[:,0] - 4*X_train[:,1] +2*X_train[:,0]*X_train[:,1]

        gp = rs.RadialBasisApproximation(N=1)
        e = np.array([1.0, 0.5, 0.1, 0.05, 0.01])
        gp.train(X_train, f_train.reshape((f_train.size,1)), e=e)
        f, df = gp.predict(X_test, compgrad=True)
        if self.writeData:
            np.savez('data/test_rbf_0.npz', f=f, df=df)

        data = helper.load_test_npz('test_rbf_0.npz')
        np.testing.assert_almost_equal(f, data['f'])
        np.testing.assert_almost_equal(df, data['df'])

        v = 0.0001*np.ones(f_train.shape)
        gp.train(X_train, f_train.reshape((f_train.size,1)), e=e, v=v)
        f, df = gp.predict(X_test, compgrad=True)
        if self.writeData:
            np.savez('data/test_rbf_1.npz', f=f, df=df)

        data = helper.load_test_npz('test_rbf_1.npz')
        np.testing.assert_almost_equal(f, data['f'])
        np.testing.assert_almost_equal(df, data['df'])
Esempio n. 20
0
    def test_rs_ubnd_2d_int(self):
        data = helper.load_test_npz('test_rs_0.npz')
        X, f, df = data['X'], data['f'], data['df']

        np.random.seed(43)
        model = base.ActiveSubspaceReducedModel(3, False)
        model.build_from_data(X, f, df=df, avdim=2)

        avg = model.average(20)[0]
        prob, pl, pu = model.probability(0.0, 1.0)
        fstar, xstar = model.minimum()

        if self.writeData:
            np.savez('data/test_base_0_2',avg=avg, prob=prob, pl=pl, pu=pu, xstar=xstar, fstar=fstar)
        data_test = helper.load_test_npz('test_base_0_2.npz')
        np.testing.assert_almost_equal(avg, data_test['avg'])
        np.testing.assert_almost_equal(prob, data_test['prob'])
        np.testing.assert_almost_equal(pl, data_test['pl'])
        np.testing.assert_almost_equal(pu, data_test['pu'])
        np.testing.assert_almost_equal(xstar, data_test['xstar'])
        np.testing.assert_almost_equal(fstar, data_test['fstar'])

        print '\n'
        print 'ubnd avg: {:6.4f}'.format(avg)
        print 'ubnd prob: {:6.4f}, {:6.4f}, {:6.4f}'.format(pl,prob,pu)
        print 'ubnd min: {:6.4f}'.format(fstar)
        print 'ubnd xmin: {:6.4f}, {:6.4f}, {:6.4f}'.format(xstar[0,0],xstar[0,1],xstar[0,2])
 def test_bootstrap_ranges(self):
     data = helper.load_test_npz('test_spec_decomp.npz')
     df, e, W = data['df'], data['e'], data['W']
     np.random.seed(1234)
     e_br, sub_br = ss.bootstrap_ranges(df, e, W, n_boot=100)
     data = helper.load_test_npz('test_spec_br.npz')
     np.testing.assert_equal(e_br, data['e_br'])
     np.testing.assert_equal(sub_br, data['sub_br'])
 def test_grad_polynomial_bases(self):
     data = helper.load_test_npz('test_points_10_2.npz')
     X = data['X']
     dB = rs.grad_polynomial_bases(X, 3)
     if self.writeData:
         np.savez('data/test_grad_poly_bases_3.npz', dB=dB)
     data = helper.load_test_npz('test_grad_poly_bases_3.npz')
     np.testing.assert_almost_equal(dB, data['dB'])
Esempio n. 23
0
 def test_bootstrap_ranges_1(self):
     data = helper.load_test_npz('test_spec_decomp_1.npz')
     df0, e0, W0 = data['df'], data['e'], data['W']
     np.random.seed(42)
     e_br, sub_br = ss.bootstrap_ranges(df0, e0, W0, n_boot=100)
     data_br = helper.load_test_npz('test_spec_br_1.npz')
     np.testing.assert_equal(e_br, data_br['e_br'])
     np.testing.assert_equal(sub_br, data_br['sub_br'])
 def test_grad_exponential_squared_covariance(self):
 
     data = helper.load_test_npz('test_points_10_2.npz')
     X1 = data['X']
     X2 = X1.copy()
     dC = rs.grad_exponential_squared_covariance(X1, X2, 1.0, np.array([1.0,1.0]))
     
     data = helper.load_test_npz('test_grad_exp_cov.npz')
     np.testing.assert_equal(dC, data['dC'])
Esempio n. 25
0
    def test_grad_exponential_squared_covariance(self):

        data = helper.load_test_npz('test_points_10_2.npz')
        X1 = data['X']
        X2 = X1.copy()
        dC = rs.grad_exponential_squared_covariance(X1, X2, 1.0,
                                                    np.array([1.0, 1.0]))

        data = helper.load_test_npz('test_grad_exp_cov.npz')
        np.testing.assert_equal(dC, data['dC'])
    def test_polynomial_bases(self):
        data = helper.load_test_npz('test_points_10_2.npz')
        X = data['X']

        B, I = rs.polynomial_bases(X, 3)
        if self.writeData:
            np.savez('data/test_poly_bases_3.npz', B=B, I=I)
        data = helper.load_test_npz('test_poly_bases_3.npz')
        np.testing.assert_almost_equal(B, data['B'])
        np.testing.assert_almost_equal(I, data['I'])
    def test_grad_exponential_squared(self):

        data = helper.load_test_npz('test_points_10_2.npz')
        X1 = data['X']
        X2 = X1.copy()
        dC = rs.grad_exponential_squared(X1, X2, 1.0, np.array([1.0,1.0]))
        if self.writeData:
            np.savez('data/test_grad_exp_cov.npz', dC=dC)
        data = helper.load_test_npz('test_grad_exp_cov.npz')
        np.testing.assert_almost_equal(dC, data['dC'])
Esempio n. 28
0
    def test_bootstrap_ranges_0(self):
        data = helper.load_test_npz('test_spec_decomp_0.npz')
        df0, e0, W0 = data['df'], data['e'], data['W']
        np.random.seed(42)
        e_br, sub_br = ss.bootstrap_ranges(df0, e0, W0, n_boot=100)

        if self.writeData:
            np.savez('data/test_spec_br_0', e_br=e_br, sub_br=sub_br)
        data_br = helper.load_test_npz('test_spec_br_0.npz')
        np.testing.assert_almost_equal(e_br, data_br['e_br'])
        np.testing.assert_almost_equal(sub_br, data_br['sub_br'])
Esempio n. 29
0
 def test_subspaces_1(self):
     data = helper.load_test_npz('test_spec_decomp_1.npz')
     data_br = helper.load_test_npz('test_spec_br_1.npz')
     df0, e0, W0 = data['df'], data['e'], data['W']
     
     sub = ss.Subspaces()
     np.random.seed(42)
     sub.compute(df0, n_boot=100)
     np.testing.assert_equal(sub.eigenvalues, e0)
     np.testing.assert_equal(sub.eigenvectors, W0)
     np.testing.assert_equal(sub.e_br, data_br['e_br'])
     np.testing.assert_equal(sub.sub_br, data_br['sub_br'])
Esempio n. 30
0
    def test_bounded_active_variable_domain_0(self):
        data = helper.load_test_npz('test_spec_decomp_0.npz')
        df0, e0, W0 = data['df'], data['e'], data['W']

        sub = ss.Subspaces()
        sub.compute(df0)
        
        data_bavd = helper.load_test_npz('bavd_0.npz')
        bavd = dom.BoundedActiveVariableDomain(sub)

        np.testing.assert_almost_equal(bavd.vertY, np.dot(bavd.vertX, sub.W1))
        np.testing.assert_equal(bavd.vertY, data_bavd['vertY'])
        np.testing.assert_equal(bavd.vertX, data_bavd['vertX'])
        np.testing.assert_equal(bavd.n, sub.W1.shape[1])
        np.testing.assert_equal(bavd.m, sub.W1.shape[0])
Esempio n. 31
0
    def test_poly_order_2d(self):
        data = helper.load_test_npz('test_points_uniform_50_2.npz')
        X = data['X']
        X_test = X.copy()

        xx = np.linspace(-1.0, 1.0, 21)
        X1, X2 = np.meshgrid(xx, xx)
        X_train = np.hstack((X1.reshape((441, 1)), X2.reshape((441, 1))))
        f_train = np.sin(np.pi * X1.reshape(
            (441, 1))) * np.cos(np.pi * X2.reshape((441, 1)))

        print '\nPOLY 2D ORDER CONVERGENCE\n'
        for N in range(3, 10):
            pr = rs.PolynomialRegression(N=N)
            pr.train(X_train, f_train)

            f, df, v = pr.predict(X_test, compgrad=True, compvar=True)
            f_true = np.sin(np.pi * X[:, 0].reshape(
                (50, 1))) * np.cos(np.pi * X[:, 1].reshape((50, 1)))
            df1_true = np.cos(np.pi * X[:, 1].reshape(
                (50, 1))) * np.pi * np.cos(np.pi * X[:, 0].reshape((50, 1)))
            df2_true = -np.sin(np.pi * X[:, 0].reshape(
                (50, 1))) * np.pi * np.sin(np.pi * X[:, 1].reshape((50, 1)))
            err_f = np.linalg.norm(f - f_true) / np.linalg.norm(f_true)
            err_df1 = np.linalg.norm(df[:, 0].reshape((50, 1)) -
                                     df1_true) / np.linalg.norm(df1_true)
            err_df2 = np.linalg.norm(df[:, 1].reshape((50, 1)) -
                                     df2_true) / np.linalg.norm(df2_true)
            print 'Order: %d, Error in f: %6.4e, Error in df1: %6.4e, Error in df2: %6.4e' % (
                N, err_f, err_df1, err_df2)
Esempio n. 32
0
    def test_gp_points_2d(self):
        data = helper.load_test_npz('test_points_uniform_50_2.npz')
        X = data['X']
        X_test = X.copy()

        print '\nGP 2D POINT CONVERGENCE\n'
        for N in range(1, 5):
            xx = np.linspace(-1.0, 1.0, 2**N + 1)
            X1, X2 = np.meshgrid(xx, xx)
            X_train = np.hstack((X1.reshape(
                ((2**N + 1)**2, 1)), X2.reshape(((2**N + 1)**2, 1))))
            f_train = np.sin(np.pi * X1.reshape(
                ((2**N + 1)**2, 1))) * np.cos(np.pi * X2.reshape(
                    ((2**N + 1)**2, 1)))

            gp = rs.GaussianProcess(N=2)
            gp.train(X_train, f_train)

            f, df, v = gp.predict(X_test, compgrad=True, compvar=True)
            f_true = np.sin(np.pi * X[:, 0].reshape(
                (50, 1))) * np.cos(np.pi * X[:, 1].reshape((50, 1)))
            df1_true = np.cos(np.pi * X[:, 1].reshape(
                (50, 1))) * np.pi * np.cos(np.pi * X[:, 0].reshape((50, 1)))
            df2_true = -np.sin(np.pi * X[:, 0].reshape(
                (50, 1))) * np.pi * np.sin(np.pi * X[:, 1].reshape((50, 1)))
            err_f = np.linalg.norm(f - f_true) / np.linalg.norm(f_true)
            err_df1 = np.linalg.norm(df[:, 0].reshape((50, 1)) -
                                     df1_true) / np.linalg.norm(df1_true)
            err_df2 = np.linalg.norm(df[:, 1].reshape((50, 1)) -
                                     df2_true) / np.linalg.norm(df2_true)
            print 'Points: %d, Error in f: %6.4e, Error in df1: %6.4e, Error in df2: %6.4e' % (
                (2**N + 1)**2, err_f, err_df1, err_df2)
Esempio n. 33
0
    def test_grad_exponential_squared_covariance_fd(self):

        data = helper.load_test_npz('test_points_10_2.npz')
        X1 = data['X']
        X2 = X1.copy()
        C0 = rs.exponential_squared_covariance(X1, X2, 1.0,
                                               np.array([1.0, 1.0]))

        dC = rs.grad_exponential_squared_covariance(X1, X2, 1.0,
                                                    np.array([1.0, 1.0]))
        e = 1e-6

        X2p1 = X2.copy()
        X2p1[:, 0] += e
        C1 = rs.exponential_squared_covariance(X1, X2p1, 1.0,
                                               np.array([1.0, 1.0]))
        dC1 = (C1 - C0) / e
        np.testing.assert_array_almost_equal(dC[:, :, 0], dC1, decimal=5)

        X2p2 = X2.copy()
        X2p2[:, 1] += e
        C2 = rs.exponential_squared_covariance(X1, X2p2, 1.0,
                                               np.array([1.0, 1.0]))
        dC2 = (C2 - C0) / e
        np.testing.assert_array_almost_equal(dC[:, :, 1], dC2, decimal=5)
 def test_jacobi_matrix_5(self):
     if self.writeData:
         J = gq.jacobi_matrix(gq.r_hermite(5))
         np.savez('data/test_jacobi_matrix_5.npz',J=J)
         
     data = helper.load_test_npz('test_jacobi_matrix_5.npz')
     J = data['J']
     np.testing.assert_almost_equal(gq.jacobi_matrix(gq.r_hermite(5)), J)
Esempio n. 35
0
    def test_rs_diag(self):
        data = helper.load_test_npz('test_rs_0.npz')
        X, f, df = data['X'], data['f'], data['df']

        np.random.seed(43)
        model = base.ActiveSubspaceReducedModel(3, False)
        model.build_from_data(X, f, df=df)

        model.diagnostics()
    def test_rs_0(self):
        data = helper.load_test_npz('test_spec_decomp_0.npz')
        df0, e0, W0 = data['df'], data['e'], data['W']

        sub = ss.Subspaces()
        sub.compute(df0)
        avd = dom.UnboundedActiveVariableDomain(sub)
        avm = dom.UnboundedActiveVariableMap(avd)
        asm.ActiveSubspaceResponseSurface(avm)
 def test_gauss_hermite_1d_int_arg(self):
     if self.writeData:
         p,w = gq.gauss_hermite(7)
         np.savez('data/test_gh1d_7pts.npz',p=p,w=w)
         
     data = helper.load_test_npz('test_gh1d_7pts.npz')
     p,w = gq.gauss_hermite(7)
     np.testing.assert_almost_equal(p, data['p'])
     np.testing.assert_almost_equal(w, data['w'])
 def test_gauss_hermite_3d(self):
     if self.writeData:
         p,w = gq.gauss_hermite([3,3,4])
         np.savez('data/test_gauss_hermite_3d.npz',p=p,w=w)
         
     data = helper.load_test_npz('test_gauss_hermite_3d.npz')
     p,w = gq.gauss_hermite([3,3,4])
     np.testing.assert_almost_equal(p, data['p'])
     np.testing.assert_almost_equal(w, data['w'])
Esempio n. 39
0
    def test_gp_grad_1d(self):
        data = helper.load_test_npz('train_points_10_2.npz')
        X = data['X']
        X_1d = X[:, 0].copy()
        f_1d = np.cos(X_1d)

        gp = rs.GaussianProcess(N=0)
        gp.train(X_1d, f_1d)
        data = helper.load_test_npz('test_points_10_2.npz')
        X = data['X']
        X_1d_test = X[:, 0].copy()
        f0, df0, v0 = gp.predict(X_1d_test, compgrad=True, compvar=True)

        e = 1e-6
        X_1d_testp = X_1d_test.copy() + e
        f1 = gp.predict(X_1d_testp)[0]
        df0_fd = (f1 - f0) / e
        np.testing.assert_almost_equal(df0, df0_fd, decimal=5)
Esempio n. 40
0
    def test_polynomial_grad_1d(self):
        data = helper.load_test_npz('train_points_10_2.npz')
        X = data['X']
        X_1d = X[:, 0].copy()
        f_1d = np.cos(X_1d)

        pr = rs.PolynomialRegression(N=7)
        pr.train(X_1d, f_1d)
        data = helper.load_test_npz('test_points_10_2.npz')
        X = data['X']
        X_1d_test = X[:, 0].copy()
        f0, df0, v0 = pr.predict(X_1d_test, compgrad=True, compvar=True)

        e = 1e-6
        X_1d_testp = X_1d_test.copy() + e
        f1 = pr.predict(X_1d_testp)[0]
        df0_fd = (f1 - f0) / e
        np.testing.assert_almost_equal(df0, df0_fd, decimal=5)
Esempio n. 41
0
    def test_sample_z(self):
        data = helper.load_test_npz('test_spec_decomp_1.npz')
        df0, e0, W0 = data['df'], data['e'], data['W']

        sub = ss.Subspaces()
        sub.compute(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)

        data_test = helper.load_test_npz('test_sampling_z_0_0.npz')
        np.testing.assert_almost_equal(Z, data_test['Z'])
Esempio n. 42
0
    def test_local_linear_gradients(self):
        data = helper.load_test_npz('train_points_200_2.npz')
        X = data['X'].copy()
        f = 2 - 5*X[:,0] + 4*X[:,1]
        
        df = gr.local_linear_gradients(X, f)
        M = df.shape[0]
        np.testing.assert_array_almost_equal(df, np.tile(np.array([-5.0, 4.0]), (M,1)), decimal=9)

        df = gr.local_linear_gradients(X, f, p=8)
        M = df.shape[0]
        np.testing.assert_array_almost_equal(df, np.tile(np.array([-5.0, 4.0]), (M,1)), decimal=9)
        
        f = 2 - np.sin(X[:,0]) + np.cos(X[:,1])        
        np.random.seed(1234)
        df = gr.local_linear_gradients(X, f)
        
        data = helper.load_test_npz('test_llm_gradients.npz')
        np.testing.assert_equal(df, data['df'])        
Esempio n. 43
0
    def test_grad_polynomial_bases_fd(self):
        data = helper.load_test_npz('test_points_10_2.npz')
        X0 = data['X']
        data = helper.load_test_npz('test_grad_poly_bases_3.npz')

        dB = rs.grad_polynomial_bases(X0, 3)
        e = 1e-6
        B0 = rs.polynomial_bases(X0, 3)[0]

        X1 = X0.copy()
        X1[:, 0] += e
        B1 = rs.polynomial_bases(X1, 3)[0]
        dB1 = (B1 - B0) / e
        np.testing.assert_array_almost_equal(dB[:, :, 0], dB1, decimal=5)

        X2 = X0.copy()
        X2[:, 1] += e
        B2 = rs.polynomial_bases(X2, 3)[0]
        dB2 = (B2 - B0) / e
        np.testing.assert_array_almost_equal(dB[:, :, 1], dB2, decimal=5)
Esempio n. 44
0
    def test_exact_gp_approximation_2d(self):
        data = helper.load_test_npz('train_points_10_2.npz')
        X = data['X']
        X_train = X.copy()
        f_2d = 2 + 5 * X_train[:, 0] - 4 * X_train[:, 1]

        gp = rs.GaussianProcess(N=1)
        gp.train(X_train, f_2d)
        data = helper.load_test_npz('test_points_10_2.npz')
        X = data['X']
        X_test = X.copy()
        f, df, v = gp.predict(X_test, compgrad=True, compvar=True)
        f_test = 2 + 5 * X_test[:, 0] - 4 * X_test[:, 1]
        np.testing.assert_almost_equal(f, f_test.reshape((10, 1)), decimal=10)
        np.testing.assert_almost_equal(df[:, 0].reshape((10, 1)),
                                       5 * np.ones((10, 1)),
                                       decimal=10)
        np.testing.assert_almost_equal(df[:, 1].reshape((10, 1)),
                                       -4 * np.ones((10, 1)),
                                       decimal=10)

        f_2d = 2 - 3 * X_train[:, 1] + 5 * X_train[:, 0] * X_train[:, 1]
        gp = rs.GaussianProcess(N=2)
        gp.train(X_train, f_2d)
        data = helper.load_test_npz('test_points_10_2.npz')
        X = data['X']
        X_test = X.copy()
        f, df, v = gp.predict(X_test, compgrad=True, compvar=True)
        f_test = 2 - 3 * X_test[:, 1] + 5 * X_test[:, 0] * X_test[:, 1]
        df1_test = 5 * X_test[:, 1]
        df2_test = -3 + 5 * X_test[:, 0]
        np.testing.assert_almost_equal(f, f_test.reshape((10, 1)), decimal=10)
        np.testing.assert_almost_equal(df[:, 0].reshape((10, 1)),
                                       df1_test.reshape((10, 1)),
                                       decimal=10)
        np.testing.assert_almost_equal(df[:, 1].reshape((10, 1)),
                                       df2_test.reshape((10, 1)),
                                       decimal=10)
Esempio n. 45
0
    def test_poly_order_1d(self):
        data = helper.load_test_npz('test_points_uniform_50_2.npz')
        X = data['X']
        X_1d_test = X[:, 0].copy().reshape((50, 1))

        X_train = np.linspace(-1.0, 1.0, 201).reshape((201, 1))
        f_train = np.sin(np.pi * X_train)

        print '\nPOLY 1D ORDER CONVERGENCE\n'
        for N in range(3, 10):
            pr = rs.PolynomialRegression(N=N)
            pr.train(X_train, f_train)

            f, df, v = pr.predict(X_1d_test, compgrad=True, compvar=True)
            f_true = np.sin(np.pi * X_1d_test)
            err_f = np.linalg.norm(f - f_true) / np.linalg.norm(f_true)
            df_true = np.pi * np.cos(np.pi * X_1d_test)
            err_df = np.linalg.norm(df - df_true) / np.linalg.norm(df_true)
            print 'Order: %d, Error in f: %6.4e, Error in df: %6.4e' % (
                N, err_f, err_df)
Esempio n. 46
0
    def test_gp_points_1d(self):
        data = helper.load_test_npz('test_points_uniform_50_2.npz')
        X = data['X']
        X_1d_test = X[:, 0].copy().reshape((50, 1))

        print '\nGP 1D POINT CONVERGENCE\n'
        for N in range(1, 9):
            X_train = np.linspace(-1.0, 1.0, 2**N + 1).reshape((2**N + 1, 1))
            f_train = np.sin(np.pi * X_train)
            gp = rs.GaussianProcess(N=0)
            #pdb.set_trace()
            gp.train(X_train, f_train)

            f, df, v = gp.predict(X_1d_test, compgrad=True, compvar=True)

            f_true = np.sin(np.pi * X_1d_test)
            err_f = np.linalg.norm(f - f_true) / np.linalg.norm(f_true)
            df_true = np.pi * np.cos(np.pi * X_1d_test)
            err_df = np.linalg.norm(df - df_true) / np.linalg.norm(df_true)
            print 'Points: %d, Error in f: %6.4e, Error in df: %6.4e' % (
                2**N + 1, err_f, err_df)
Esempio n. 47
0
 def test_gh1d_7pts(self):
     data = helper.load_test_npz('test_gh1d_7pts.npz')
     p,w = gq.gh1d(7)
     np.testing.assert_equal(p, data['p'])
     np.testing.assert_equal(w, data['w'])
Esempio n. 48
0
 def test_gauss_hermite_3d(self):
     data = helper.load_test_npz('test_gauss_hermite_3d.npz')
     p,w = gq.gauss_hermite([3,3,4])
     np.testing.assert_equal(p, data['p'])
     np.testing.assert_equal(w, data['w'])
Esempio n. 49
0
 def test_jacobi_matrix_5(self):
     data = helper.load_test_npz('test_jacobi_matrix_5.npz')
     J = data['J']
     np.testing.assert_equal(gq.jacobi_matrix(gq.r_hermite(5)), J)
Esempio n. 50
0
 def test_grad_polynomial_bases(self):
     data = helper.load_test_npz('test_points_10_2.npz')
     X = data['X']
     data = helper.load_test_npz('test_grad_poly_bases_3.npz')
     dB = rs.grad_polynomial_bases(X, 3)
     np.testing.assert_equal(dB, data['dB'])
Esempio n. 51
0
 def test_full_index_set(self):
     I = rs.full_index_set(7, 3)
     data = helper.load_test_npz('test_full_index_set_7_3.npz')
     np.testing.assert_equal(I, data['I'])
 def test_spectral_decomposition(self):
     data = helper.load_test_npz('test_spec_decomp.npz')
     df = data['df']
     e, W = ss.spectral_decomposition(df)
     np.testing.assert_equal(e, data['e'])
     np.testing.assert_equal(W, data['W'])
Esempio n. 53
0
 def test_gauss_hermite_1d_int_arg(self):
     data = helper.load_test_npz('test_gh1d_7pts.npz')
     p,w = gq.gauss_hermite(7)
     np.testing.assert_equal(p, data['p'])
     np.testing.assert_equal(w, data['w'])