Пример #1
0
 def __init__(self, *args, **kwargs):
     unittest.TestCase.__init__(self, *args, **kwargs)
 
     num_p = 20
     # The Kriging model starts by defining a sampling plan, we use an optimal Latin Hypercube here
     # sp = samplingplan(k=2)
     self.RMSE_mean = []
     self.RMSE_std = []
     self.X = sp.samplingplan().rlh(num_p)
     # self.X = sp.grid(num_p)
     # self.X = sp.MC(num_p)
     # self.X = sp.optimallhc(num_p)
     minx, maxx, miny, maxy = [-2, 2, -2, 2]
     self.X[:, 0] = minx + (maxx - minx) * self.X[:, 0]
     self.X[:, 1] = miny + (maxy - miny) * self.X[:, 1]
     self.testfun = pyKriging.testfunctions().branin
     
     # self.testfun = pyKriging.testfunctions().rosenbrock
     self.y = self.testfun(self.X)
Пример #2
0
#!/usr/bin/env python

import pyKriging  
from pyKriging.krige import kriging  
from pyKriging.samplingplan import samplingplan

# The Kriging model starts by defining a sampling plan, we use an optimal Latin Hypercube here
sp = samplingplan(2)  
X = sp.optimallhc(20)

# Next, we define the problem we would like to solve
testfun = pyKriging.testfunctions().branin  
y = testfun(X)

# Now that we have our initial data, we can create an instance of a Kriging model
k = kriging(X, y, testfunction=testfun, name='simple')  
k.train()

# Now, five infill points are added. Note that the model is re-trained after each point is added
numiter = 5  
for i in range(numiter):  
    print 'Infill iteration {0} of {1}....'.format(i + 1, numiter)
    newpoints = k.infill(1)
    for point in newpoints:
        k.addPoint(point, testfun(point)[0])
    k.train()

# And plot the results
k.plot()  
Пример #3
0
__author__ = 'cpaulson'
import pyKriging
from pyKriging.krige import kriging
from pyKriging.samplingplan import samplingplan
from pyKriging.CrossValidation import Cross_Validation
from pyKriging.utilities import saveModel

# The Kriging model starts by defining a sampling plan, we use an optimal Latin Hypercube here
sp = samplingplan(2)
X = sp.optimallhc(5)

# Next, we define the problem we would like to solve
testfun = pyKriging.testfunctions().branin

# We generate our observed values based on our sampling plan and the test function
y = testfun(X)

print 'Setting up the Kriging Model'
cvMSE = []
# Now that we have our initial data, we can create an instance of a kriging model
k = kriging(X, y, testfunction=testfun, name='simple', testPoints=300)
k.train(optimizer='ga')
k.snapshot()
# cv = Cross_Validation(k)
# cvMSE.append( cv.leave_n_out(q=5)[0] )

k.plot()
for i in range(15):
    print i
    newpoints = k.infill(1)
    for point in newpoints:
__author__ = 'cpaulson'
import pyKriging
from pyKriging.krige import kriging
from pyKriging.samplingplan import samplingplan

# The Kriging model starts by defining a sampling plan, we use an optimal Latin Hypercube here
sp = samplingplan(2)
X = sp.optimallhc(15)

# Next, we define the problem we would like to solve
testfun = pyKriging.testfunctions().paulson1
y = testfun(X)

# We can choose between a ga and a pso here
optimizer = 'ga'

# Now that we have our initial data, we can create an instance of a kriging model
print 'Setting up the Kriging Model'
k = kriging(X, y, testfunction=testfun, name='simple_ei', testPoints=300)
k.train(optimizer=optimizer)
k.snapshot()

# Add 10 points based on model error reduction
for i in range(5):
    newpoints = k.infill(1, method='error')
    for point in newpoints:
        print 'Adding point {}'.format(point)
        k.addPoint(point, testfun(point)[0])
    k.train(optimizer=optimizer)
    k.snapshot()
__author__ = 'cpaulson'
import pyKriging
from pyKriging.krige import kriging
from pyKriging.samplingplan import samplingplan

# The Kriging model starts by defining a sampling plan, we use an optimal Latin Hypercube here
sp = samplingplan(2)
X = sp.optimallhc(15)

# Next, we define the problem we would like to solve
testfun = pyKriging.testfunctions().paulson1
y = testfun(X)

# We can choose between a ga and a pso here
optimizer = 'ga'

# Now that we have our initial data, we can create an instance of a kriging model
print 'Setting up the Kriging Model'
k = kriging(X, y, testfunction=testfun, name='simple_ei', testPoints=300)
k.train(optimizer=optimizer)
k.snapshot()


# Add 10 points based on model error reduction
for i in range(5):
    newpoints = k.infill(1, method='error')
    for point in newpoints:
        print 'Adding point {}'.format(point)
        k.addPoint(point, testfun(point)[0])
    k.train(optimizer=optimizer)
    k.snapshot()
Пример #6
-1
    def interpGrid(self):
        ptx = np.array(self.x)
        pty = np.array(self.y)
        z = np.array(self.z)
        print(len(ptx), 'length x')
        # remove duplicate x values
        dups = self.checkdups(self.x)
        ptx = np.delete(ptx, dups)
        pty = np.delete(pty, dups)
        z = np.delete(z, dups)
        print(len(ptx), 'length x')

        pts = zip(self.x, self.y)
        # gridx, gridy = np.mgrid[uprLeft[0]:lwrRight[0]:50j,uprLeft[1]:lwrRight[1]:50j]
        gridx, gridy = np.mgrid[self.ext[0]:self.ext[1]:self.ncol*1j,
                            self.ext[2]:self.ext[3]:self.nrow*1j]
        ##### using griddata #####
        if self.interptype == 'griddata':
            from scipy.interpolate import griddata
            self.grid = griddata(pts,self.z,(gridx,gridy), method='cubic',fill_value=-3e30)
        #### examples from 
        ##### http://stackoverflow.com/questions/24978052/interpolation-over-regular-grid-in-python
        ##### using radial basis function ####
        if self.interptype == 'rbf':
            import scipy.interpolate as interpolate
            f = interpolate.Rbf(pty, ptx, z, function='linear')
            self.grid = f(gridy, gridx)

        ##### using kriging ####
        if self.interptype == 'gauss':
            from sklearn.gaussian_process import GaussianProcess
            # print math.sqrt(np.var(z))
            # gp = GaussianProcess(theta0=0.1, thetaL=1.1, thetaU=10.1, nugget=0.000001)
            if np.min(z) <= 0:
                thetaL = 0.1
            else:
                thetaL = np.min(z)

            print(np.min(z), thetaL, np.max(z))
            # gp = GaussianProcess(regr='quadratic',corr='cubic',theta0=np.min(z),thetaL=thetaL,thetaU=np.max(z),nugget=0.05)
            gp = GaussianProcess(theta0=500,thetaL=100,thetaU=2000)
            gp.fit(X=np.column_stack([pty,ptx]),y=z)
            rr_cc_as_cols = np.column_stack([gridy.flatten(), gridx.flatten()])
            self.grid = gp.predict(rr_cc_as_cols).reshape((self.ncol,self.nrow))

        if self.interptype == 'krig':
            import pyKriging  
            from pyKriging.krige import kriging  
            from pyKriging.samplingplan import samplingplan
            
            # The Kriging model starts by defining a sampling plan, we use an optimal Latin Hypercube here
            # sp = samplingplan(2)  
            # X = sp.optimallhc(20)
            # print(X)
            X = np.array(zip(self.x, self.y))
            print(X.shape)
            
            # Next, we define the problem we would like to solve
            testfun = pyKriging.testfunctions().squared  
            # y = testfun(X)
            # print(y)
            y = self.z
            
            # Now that we have our initial data, we can create an instance of a Kriging model
            k = kriging(X, y)#, testfunction=testfun, name='simple')  
            # k.train()
            
            # Now, five infill points are added. Note that the model is re-trained after each point is added
            # numiter = 5  
            # for i in range(numiter):  
                # print 'Infill iteration {0} of {1}....'.format(i + 1, numiter)
                # newpoints = k.infill(1)
                # for point in newpoints:
                    # k.addPoint(point, testfun(point)[0])
                # k.train()
            
            # And plot the results
            k.plot() 
            sys.exit()

        self.grid[self.grid < self.minval] = -2.99999989403e+030 #self.minval
        self.grid = np.flipud(self.grid.T)