def sparse_grid(n_agents, iDepth, sIdx):
grid = TasmanianSG.TasmanianSparseGrid()
k_range = np.array([k_bar, k_up])
ranges = np.empty((n_agents, 2))
for i in range(n_agents):
ranges[i] = k_range
iDim = n_agents
# TODO: parameterize this
refinement_level = 1
fTol = 1.E-5
grid.makeLocalPolynomialGrid(iDim, iOut, iDepth, which_basis, "localp")
grid.setDomainTransform(ranges)
aPoints = grid.getPoints()
iNumP1 = aPoints.shape[0]
aVals = np.empty([iNumP1, 1])
for iI in range(iNumP1):
aValTemp = 0
for sIdx in range(5):
aValTemp += (1. / 5) * solver.initial(aPoints[iI], n_agents,
sIdx)[0]
aVals[iI] = aValTemp
grid.loadNeededPoints(aVals)
for ik in range(refinement_level):
grid.setSurplusRefinement(fTol, 1,
"fds") #also use fds, or other rules
aPoints = grid.getNeededPoints()
iNumP1 = aPoints.shape[0]
aVals = np.empty([iNumP1, 1])
print(ik)
file = open("comparison1.txt", 'w')
for iI in range(iNumP1):
aValTemp = 0
for sIdx in range(5):
aValTemp += (1. / 5) * solver.initial(aPoints[iI], n_agents,
sIdx)[0]
aVals[iI] = aValTemp
v = aVals[iI] * np.ones((1, 1))
to_print = np.hstack((aPoints[iI].reshape(1, n_agents), v))
np.savetxt(file, to_print, fmt='%2.16f')
print(aVals)
file.close()
grid.loadNeededPoints(aVals)
f = open("grid.txt", 'w')
np.savetxt(f, aPoints, fmt='% 2.16f')
f.close()
return grid
def sparse_grid(n_agents, iDepth):
grid = TasmanianSG.TasmanianSparseGrid()
k_range = np.array([k_bar, k_up])
ranges = np.empty((n_agents, 2))
for i in range(n_agents):
ranges[i] = k_range
iDim = n_agents
grid.makeLocalPolynomialGrid(iDim, iOut, iDepth, which_basis, "localp")
grid.setDomainTransform(ranges) # Change domain to K low and upper bar
aPoints = grid.getPoints()
iNumP1 = aPoints.shape[0]
aVals = np.empty([iNumP1, 1])
file = open("comparison0.txt", 'w')
for iI in range(iNumP1):
aVals[iI] = solver.initial(aPoints[iI], n_agents)[
0] # Solve the value function problem for all grid points
v = aVals[iI] * np.ones((1, 1))
to_print = np.hstack((aPoints[iI].reshape(1, n_agents), v))
np.savetxt(file, to_print, fmt='%2.16f')
file.close()
grid.loadNeededPoints(aVals) # evaluate interpolant at grid points
#refinement level
for iK in range(refinement_level):
grid.setSurplusRefinement(fTol, 1,
"fds") #also use fds, or other rules
aPoints = grid.getNeededPoints()
aVals = np.empty([aPoints.shape[0], 1])
for iI in range(aPoints.shape[0]):
aVals[iI] = solver.initial(aPoints[iI], n_agents)[
0] # Solve the value function problem for all grid points
# Update interpolant
grid.loadNeededPoints(aVals)
#print(" {0:9d} {1:9d} {2:1.2e}".format(iK+1, grid.getNumPoints()))
#grid2 = TasmanianSG.TasmanianSparseGrid()
#grid2.makeLocalPolynomialGrid(iDim, iOut, refinement_level+iDepth, which_basis, "localp")
#a = grid2.getNumPoints()
#f=open("grid.txt", 'w')
#np.savetxt(f, aPoints, fmt='% 2.16f')
#f.close()
return grid
#======================================================================
def sparse_grid(n_agents, iDepth, refinement_level, fTol, theta):
grid = TasmanianSG.TasmanianSparseGrid()
k_range=np.array([k_bar, k_up])
ranges=np.empty((n_agents, 2))
for i in range(n_agents):
ranges[i]=k_range
iDim=n_agents
# level of grid before refinement
grid.makeLocalPolynomialGrid(iDim, iOut, iDepth, which_basis, "localp")
grid.setDomainTransform(ranges)
aPoints=grid.getPoints()
iNumP1=aPoints.shape[0]
aVals=np.empty([iNumP1, 1])
file=open("comparison0.txt", 'w')
for iI in range(iNumP1):
aVals[iI]=solver.initial(aPoints[iI], n_agents, theta)[0]
v=aVals[iI]*np.ones((1,1))
to_print=np.hstack((aPoints[iI].reshape(1,n_agents), v))
np.savetxt(file, to_print, fmt='%2.16f')
#file.close()
grid.loadNeededPoints(aVals)
#refinement level
for iK in range(refinement_level):
grid.setSurplusRefinement(fTol, 1, "fds") #also use fds, or other rules
aPoints = grid.getNeededPoints()
aVals = np.empty([aPoints.shape[0], 1])
for iI in range(aPoints.shape[0]):
aVals[iI]=solver.initial(aPoints[iI], n_agents, theta)[0]
v = aVals[iI]*np.ones((1, 1))
to_print=np.hstack((aPoints[iI].reshape(1,n_agents), v))
np.savetxt(file, to_print, fmt='%2.16f')
grid.loadNeededPoints(aVals)
#aRes = grid.evaluateBatch(aPnts)
#fError1 = max(np.fabs(aRes[:,0] - aTres))
file.close()
f=open("grid.txt", 'w')
np.savetxt(f, aPoints, fmt='% 2.16f')
f.close()
return grid
def sparse_grid(n_agents, iDepth, adaptive=False):
grid = TasmanianSG.TasmanianSparseGrid()
# range of k grid
k_range=np.array([k_bar, k_up])
ranges=np.empty((n_agents, 2)) # lower and upper bound for each agent (dimension)
for i in range(n_agents):
ranges[i]=k_range
iDim=n_agents
grid.makeLocalPolynomialGrid(iDim, iOut, iDepth, which_basis, "localp")
grid.setDomainTransform(ranges) ### Sets the lower and upper bound for each dimension
aPoints=grid.getPoints()
### returns the points needed to form the interpolant or the next
### level of refinement following a set***Refinement() call
iNumP1=aPoints.shape[0]
aVals=np.empty([iNumP1, 1]) # space to store value for value function at that interpolation evaluated point
if adaptive:
file=open("comparison0.txt", 'w')
for i in range(refinement_level):
grid.setSurplusRefinement(fTol, -1, "fds") #also use fds, or other rules
aPoints = grid.getNeededPoints()
aVals = np.empty([aPoints.shape[0], 1])
for iI in range(iNumP1):
aVals[iI] = solver.initial(aPoints[iI], n_agents)[0]
v=aVals[iI]*np.ones((1,1))
to_print=np.hstack((aPoints[iI].reshape(1,n_agents), v))
np.savetxt(file, to_print, fmt='%2.16f')
else:
file=open("comparison0.txt", 'w')
for iI in range(iNumP1):
aVals[iI]=solver.initial(aPoints[iI], n_agents)[0]
v=aVals[iI]*np.ones((1,1))
to_print=np.hstack((aPoints[iI].reshape(1,n_agents), v))
np.savetxt(file, to_print, fmt='%2.16f')
file.close()
grid.loadNeededPoints(aVals)
f=open("grid.txt", 'w')
np.savetxt(f, aPoints, fmt='% 2.16f')
f.close()
return grid
def adaptive_sparse_grid(n_agents, iDepth, refinement_level, fTol):
k_range = np.array([k_bar, k_up])
ranges = np.empty((n_agents, 2))
for i in range(n_agents):
ranges[i] = k_range
iDim = n_agents
grid = TasmanianSG.TasmanianSparseGrid()
grid.makeLocalPolynomialGrid(iDim, iOut, iDepth, which_basis, "localp")
grid.setDomainTransform(ranges)
aPoints = grid.getPoints()
iNumP1 = aPoints.shape[0]
aVals = np.empty([iNumP1, 1])
for iI in range(iNumP1):
aVals[iI] = solver.initial(aPoints[iI], n_agents)[0]
grid.loadNeededPoints(aVals)
for iK in range(refinement_level):
grid.setSurplusRefinement(fTol, 1,
"fds") #also use fds, or other rules
aPoints = grid.getNeededPoints()
aVals = np.empty([aPoints.shape[0], 1])
for iI in range(aPoints.shape[0]):
aVals[iI] = solver.initial(aPoints[iI], n_agents)[0]
grid.loadNeededPoints(aVals)
file = open("comparison0_1.txt", 'w')
for iI in range(aPoints.shape[0]):
v = aVals[iI] * np.ones((1, 1))
to_print = np.hstack((aPoints[iI].reshape(1, n_agents), v))
np.savetxt(file, to_print, fmt='%2.16f')
file.close()
#grid.plotPoints2D()
f = open("grid_1.txt", 'w')
np.savetxt(f, aPoints, fmt='% 2.16f')
f.close()
return grid
#======================================================================
def sparse_grid(n_agents, iDepth):
grid = TasmanianSG.TasmanianSparseGrid(
) #grid. calls all the tasmanian stuff!
k_range = np.array([k_bar, k_up])
ranges = np.empty((n_agents, 2))
for i in range(n_agents):
ranges[i] = k_range
iDim = n_agents
grid.makeLocalPolynomialGrid(iDim, iOut, iDepth, which_basis, "localp")
grid.setDomainTransform(ranges)
aPoints = grid.getPoints()
iNumP1 = aPoints.shape[0]
aVals = np.empty([iNumP1, 1])
file = open("comparison0.txt", 'w')
for iI in range(iNumP1):
aVals[iI] = solver.initial(aPoints[iI], n_agents)[0]
v = aVals[iI] * np.ones((1, 1))
to_print = np.hstack((aPoints[iI].reshape(1, n_agents), v))
np.savetxt(file, to_print, fmt='%2.16f')
file.close()
grid.loadNeededPoints(aVals)
f = open("grid.txt", 'w')
np.savetxt(f, aPoints, fmt='% 2.16f')
f.close()
return grid
def sparse_grid(n_agents, iDepth, theta):
grid1 = TasmanianSG.TasmanianSparseGrid()
k_range=np.array([k_bar, k_up])
ranges=np.empty((n_agents, 2))
for i in range(n_agents):
ranges[i]=k_range
iDim=n_agents
grid1.makeLocalPolynomialGrid(iDim, iOut, iDepth, which_basis, "localp")
grid1.setDomainTransform(ranges)
aPoints=grid1.getPoints()
iNumP1=aPoints.shape[0]
aVals=np.empty([iNumP1, 1])
for iI in range(iNumP1):
aVals[iI]=solver.initial(aPoints[iI], n_agents, theta)[0]
v=aVals[iI]*np.ones((1,1))
grid1.loadNeededPoints(aVals)
for iK in range(refinement_level):
grid1.setSurplusRefinement(fTol, 1, "fds") #also use fds, or other rules
aPoints = grid1.getNeededPoints()
aVals = np.empty([aPoints.shape[0], 1])
for iI in range(iNumP1):
aVals[iI]=solver.initial(aPoints[iI], n_agents, theta)[0]
v=aVals[iI]*np.ones((1,1))
grid1.loadNeededPoints(aVals)
return grid1
def test_sg(n_agents, iDepth, num_points=[]):
grid=interpol.sparse_grid(n_agents, iDepth)
k_sample=grid.getPoints()
v_interpol=grid.evaluateBatch(k_sample)
v_func=np.empty((len(k_sample),1))
for i in range(len(k_sample)):
v_func[i][0]=solver.initial(k_sample[i], n_agents)[0]
res=np.fabs(v_interpol-v_func)
return res
def test_sg(n_agents, iDepth, num_points=[]):
#unif=np.random.rand(num_points, n_agents)
#k_sample=k_bar+(unif)*(k_up-k_bar)
grid = interpol.sparse_grid(n_agents, iDepth)
k_sample = grid.getPoints()
v_interpol = grid.evaluateBatch(k_sample)
v_func = np.empty((len(k_sample), 1))
for i in range(len(k_sample)):
v_func[i][0] = solver.initial(k_sample[i], n_agents, method)[0]
res = np.fabs(v_interpol - v_func)
return res
def GPR_init(iteration):
print "hello from step ", iteration
#fix seed
np.random.seed(666)
#generate sample aPoints
dim = n_agents
Xtraining = np.random.uniform(k_bar, k_up, (No_samples, dim))
y = np.zeros(No_samples, float) # training targets
# solve bellman equations at training points
for iI in range(len(Xtraining)):
y[iI] = solver.initial(Xtraining[iI], n_agents)[0]
#for iI in range(len(Xtraining)):
#print Xtraining[iI], y[iI]
# Instantiate a Gaussian Process model
kernel = RBF()
#kernel = 1.0 * RBF(length_scale=1.0, length_scale_bounds=(1e-1, 10.0))
#kernel = 1.0 * Matern(length_scale=1.0, length_scale_bounds=(1e-1, 10.0),nu=1.5)
#kernel = 1.0 * RBF(length_scale=100.0, length_scale_bounds=(1e-1, 2e2)) \
#+ WhiteKernel(noise_level=1, noise_level_bounds=(1e-3, 1e+0))
gp = GaussianProcessRegressor(kernel=kernel, n_restarts_optimizer=9)
# Fit to data using Maximum Likelihood Estimation of the parameters
gp.fit(Xtraining, y)
#save the model to a file
output_file = filename + str(iteration) + ".pcl"
print output_file
with open(output_file, 'wb') as fd:
pickle.dump(gp, fd, protocol=pickle.HIGHEST_PROTOCOL)
print "data of step ", iteration, " written to disk"
print " -------------------------------------------"
fd.close()
def sparse_grid(n_agents, iDepth):
k_range = np.array([k_bar, k_up])
ranges = np.empty((n_agents, 2))
for i in range(n_agents):
ranges[i] = k_range
iDim = n_agents
iOut = 1
grid_list = []
points_list = []
num_points = []
for i in range(ntheta):
grid_list.append(TasmanianSG.TasmanianSparseGrid())
grid_list[i].makeLocalPolynomialGrid(iDim, iOut, iDepth, which_basis,
"localp")
grid_list[i].setDomainTransform(ranges)
points_list.append(grid_list[i].getPoints())
num_points.append(points_list[i].shape[0])
for itheta in range(ntheta):
theta_init = theta_range[itheta]
aPoints = points_list[itheta]
iNumP1 = num_points[itheta]
aVals = np.empty([iNumP1, 1])
file = open("comparison0_" + str(theta_range[itheta]) + "_.txt", 'w')
for iI in range(iNumP1):
aVals[iI] = solver.initial(aPoints[iI], theta_init, n_agents)[0]
v = aVals[iI] * np.ones((1, 1))
to_print = np.hstack((aPoints[iI].reshape(1, n_agents), v))
np.savetxt(file, to_print, fmt='%2.16f')
file.close()
grid_list[itheta].loadNeededPoints(aVals)
return grid_list
def sparse_grid(paramL): ###n_agents, iDepth
grid = TasmanianSG.TasmanianSparseGrid()
k_range = np.array([paramL['k_bar'], paramL['k_up']])
ranges = np.empty((paramL['n_agents'], 2))
for i in range(paramL['n_agents']):
ranges[i] = k_range
iDim = paramL['n_agents']
grid.makeLocalPolynomialGrid(iDim, paramL['iOut'], paramL['iDepth'],
paramL['which_basis'], "localp")
grid.setDomainTransform(ranges)
aPoints = grid.getPoints()
iNumP1 = aPoints.shape[0]
aVals = np.empty([iNumP1, 1])
file = open("comparison0.txt", 'w')
for iI in range(iNumP1):
aVals[iI] = solver.initial(aPoints[iI], paramL)[0]
v = aVals[iI] * np.ones((1, 1))
to_print = np.hstack((aPoints[iI].reshape(1, paramL['n_agents']), v))
np.savetxt(file, to_print, fmt='%2.16f')
file.close()
grid.loadNeededPoints(aVals)
f = open("grid.txt", 'w')
np.savetxt(f, aPoints, fmt='% 2.16f')
f.close()
return grid
def sparse_grid(n_agents):
comm = MPI.COMM_WORLD
rank = comm.Get_rank()
size = comm.Get_size()
grid = TasmanianSG.TasmanianSparseGrid()
aPoints = 0
iNumP1_buf = np.zeros(1, int)
iNumP1 = iNumP1_buf[0]
aVals_gathered = 0
if rank == 0:
k_range = np.array([k_bar, k_up])
ranges = np.empty((n_agents, 2))
for i in range(n_agents):
ranges[i] = k_range
iDim = n_agents
grid.makeLocalPolynomialGrid(iDim, iOut, iDepth, which_basis, "localp")
grid.setDomainTransform(ranges)
aPoints = grid.getPoints()
f = open("grid.txt", 'w')
np.savetxt(f, aPoints, fmt='% 2.5f')
f.close()
iNumP1 = aPoints.shape[0]
iNumP1_buf[0] = iNumP1
aVals_gathered = np.empty((iNumP1, 1))
comm.Barrier()
comm.Bcast(iNumP1_buf, root=0)
iNumP1 = iNumP1_buf[0]
nump = iNumP1 // size
r = iNumP1 % size
if rank < r:
nump += 1
displs_scat = np.empty(size)
sendcounts_scat = np.empty(size)
displs_gath = np.empty(size)
sendcounts_gath = np.empty(size)
for i in range(r):
displs_scat[i] = i * (1 + iNumP1 // size) * n_agents
sendcounts_scat[i] = (1 + iNumP1 // size) * n_agents
displs_gath[i] = i * (1 + iNumP1 // size)
sendcounts_gath[i] = (1 + iNumP1 // size)
for i in range(r, size):
displs_scat[i] = (r + i * (iNumP1 // size)) * n_agents
sendcounts_scat[i] = (iNumP1 // size) * n_agents
displs_gath[i] = (r + i * (iNumP1 // size))
sendcounts_gath[i] = (iNumP1 // size)
local_aPoints = np.zeros((nump, n_agents))
gridp = open("grid" + str(rank) + ".txt", 'w')
comm.Scatterv([aPoints, sendcounts_scat, displs_scat, MPI.DOUBLE],
local_aPoints)
np.savetxt(gridp, local_aPoints)
gridp.close()
local_aVals = np.empty([nump, 1])
file = open("comparison0.txt", 'w')
for iI in range(nump):
local_aVals[iI] = solver.initial(local_aPoints[iI], n_agents)[0]
v_and_rank = np.array([[local_aVals[iI], rank]])
to_print = np.hstack((local_aPoints[iI].reshape(1,
n_agents), v_and_rank))
np.savetxt(file, to_print, fmt='%2.16f')
file.close()
comm.Gatherv(local_aVals,
[aVals_gathered, sendcounts_gath, displs_gath, MPI.DOUBLE])
if rank == 0:
grid.loadNeededPoints(aVals_gathered)
return grid
