def sparse_grid_iter(n_agents, iDepth, iG, Lvalold):
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)
aPoints = grid.getPoints()
iNumP1 = aPoints.shape[0]
aVals = np.empty([iNumP1, iOut])
file = open("comparison1.txt", 'w')
for iI in range(iNumP1):
aVals[iI] = solveriter.iterate(aPoints[iI], n_agents, Lvalold,
phi[iG])[0]
grid.loadNeededPoints(aVals) # Get interpolant at sparse grid
#refinement level
for iK in range(refinement_level):
grid.setSurplusRefinement(fTol, 1,
"fds") #also use fds, or other rules
aPoints = grid.getNeededPoints()
#grid.plotPoints2D()
print("Number of Points", grid.getNumPoints())
aVals = np.empty([aPoints.shape[0], iOut])
for iI in range(aPoints.shape[0]):
# Solve the value function problem for all grid points
aVals[iI] = solveriter.iterate(aPoints[iI], n_agents, Lvalold,
phi[iG])[0]
# 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")
print("Max Number of Points", grid2.getNumPoints())
#f=open("grid_iter.txt", 'w')
#np.savetxt(f, aPoints, fmt='% 2.16f')
#f.close()
return grid
#======================================================================
def sparse_grid_iter(grid, valold_list, adaptive=False):
# 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
# iOut=1
# grid.makeLocalPolynomialGrid(iDim, iOut, iDepth, which_basis, "localp")
# grid.setDomainTransform(ranges) ### Sets the lower and upper bound for each dimension
aPoints = grid.getPoints()
iNumP1 = aPoints.shape[0]
if adaptive:
# file=open("comparison1.txt", 'w')
for i in range(1):
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] = solveriter.iterate(aPoints[iI], n_agents,
valold_list)[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)
else:
aVals = np.empty([iNumP1, 1])
# file=open("comparison1.txt", 'w')
for iI in range(iNumP1):
aVals[iI] = solveriter.iterate(aPoints[iI], n_agents,
valold_list)[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_iter.txt", 'w')
np.savetxt(f, aPoints, fmt='% 2.16f')
f.close()
return grid
def adaptive_sparse_grid_iter(n_agents, iDepth, refinement_level, fTol,
valold):
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
iOut = 1
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] = solveriter.iterate(aPoints[iI], n_agents, valold)[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] = solveriter.iterate(aPoints[iI], n_agents, valold)[0]
grid.loadNeededPoints(aVals)
file = open("comparison1_1.txt", 'w')
for iI in range(iNumP1):
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()
f = open("grid_iter_1.txt", 'w')
np.savetxt(f, aPoints, fmt='% 2.16f')
f.close()
return grid
#======================================================================
def GPR_iter(iteration):
# Load the model from the previous iteration step
restart_data = filename + str(iteration-1) + ".pcl"
with open(restart_data, 'rb') as fd_old:
gp_old = pickle.load(fd_old)
print "data from iteration step ", iteration -1 , "loaded from disk"
fd_old.close()
##generate sample aPoints
np.random.seed(666) #fix seed
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.iterate(Xtraining[iI], n_agents,gp_old)[0]
#print data for debugging purposes
#for iI in range(len(Xtraining)):
#print Xtraining[iI], y[iI]
# Instantiate a Gaussian Process model
kernel = RBF()
# Instantiate a Gaussian Process model
#kernel = 1.0 * RBF(length_scale=1.0, length_scale_bounds=(1e-1, 10.0))
#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))
#kernel = 1.0 * RBF(length_scale=100.0, length_scale_bounds=(1e-1, 2e2))
#kernel = 1.0 * Matern(length_scale=1.0, length_scale_bounds=(1e-1, 10.0),nu=1.5)
gp = GaussianProcessRegressor(kernel=kernel, n_restarts_optimizer=10)
# 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_iter(n_agents, iDepth, valold, 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
iOut=1
# Level of grid before refinement
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]=solveriter.iterate(aPoints[iI], n_agents, valold, 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]=solveriter.iterate(aPoints[iI], n_agents, valold, theta)[0]
v=aVals[iI]*np.ones((1,1))
grid1.loadNeededPoints(aVals)
return grid1
def sparse_grid_iter(n_agents, iDepth, valold):
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
iOut = 1
grid.makeLocalPolynomialGrid(iDim, iOut, iDepth, which_basis, "localp")
grid.setDomainTransform(ranges)
aPoints = grid.getPoints()
iNumP1 = aPoints.shape[0]
aVals = np.empty([iNumP1, len(thetagrid)])
EV = np.empty([iNumP1, 1])
file = open("comparison1.txt", 'w')
for iI in range(iNumP1): #i think this loops through the kgrid
for tt, theta in enumerate(thetagrid):
aVals[iI, tt] = solveriter.iterate(aPoints[iI], n_agents, valold,
theta)[0]
#print(aVals[iI,tt],iI,tt)
v = aVals[iI, tt] * np.ones((1, 1))
to_print = np.hstack((aPoints[iI].reshape(1, n_agents), v))
#np.savetxt(file, to_print, fmt='%2.16f')
EV[iI] = 0.2 * aVals[iI, 0] + 0.2 * aVals[iI, 1] + 0.2 * aVals[
iI, 2] + 0.2 * aVals[iI, 3] + 0.2 * aVals[iI, 4]
#print(aVals)
#pdb.set_trace()
file.close()
grid.loadNeededPoints(EV)
f = open("grid_iter.txt", 'w')
np.savetxt(f, aPoints, fmt='% 2.16f')
f.close()
#$print(v) #UB
#print(aPoints)
return grid, aVals, aPoints
def sparse_grid_iter_adap(paramL, valold_list):
## Not working
n_agents = paramL['n_agents']
grid = TasmanianSG.TasmanianSparseGrid()
k_range=np.array([paramL['k_bar'], paramL['k_up']])
ranges=np.empty((n_agents, 2))
for i in range(n_agents):
ranges[i]=k_range
iDim=n_agents
iOut=1
fTol = 1.E-5
grid.makeLocalPolynomialGrid(iDim, iOut, paramL['iDepth'], paramL['which_basis'], "localp")
grid.setDomainTransform(ranges)
aPoints=grid.getPoints()
iNumP1=aPoints.shape[0]
aVals=np.empty([iNumP1, 1]) ## Change to 5d
for iK in range(3):
grid.setSurplusRefinement(fTol, -1, "fds") #also use fds, or other rules
aPoints = grid1.getNeededPoints()
aVals = np.empty([aPoints.shape[0], 1])
for iI in range(aPoints.shape[0]):
aVals[iI]= solveriter.iterate(aPoints[iI], paramL, valold_list)[0]
v=aVals[iI]*np.ones((1,1))
grid.loadNeededPoints(aVals)
f=open("grid_iter.txt", 'w')
np.savetxt(f, aPoints, fmt='% 2.16f')
f.close()
return grid
def sparse_grid_iter(n_agents, iDepth, valold):
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
iOut = 1
grid.makeLocalPolynomialGrid(iDim, iOut, iDepth, which_basis, "localp")
grid.setDomainTransform(ranges)
aPoints = grid.getPoints()
iNumP1 = aPoints.shape[0]
aVals = np.empty([iNumP1, 1])
print("Number of points in grid is", iNumP1)
file = open("comparison1.txt", 'w')
for iI in range(iNumP1):
print("Solving for point", iI)
aVals[iI] = solveriter.iterate(aPoints[iI], n_agents, valold)[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_iter.txt", 'w')
np.savetxt(f, aPoints, fmt='% 2.16f')
f.close()
return grid
def sparse_grid_iter(n_agents, iDepth, valold_list):
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("comparison1_" + str(theta_range[itheta]) + "_.txt", 'w')
for iI in range(iNumP1):
aVals[iI] = solveriter.iterate(aPoints[iI], theta_init, n_agents,
valold_list)[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_iter(paramL, valold_list):
n_agents = paramL['n_agents']
grid = TasmanianSG.TasmanianSparseGrid()
k_range=np.array([paramL['k_bar'], paramL['k_up']])
ranges=np.empty((n_agents, 2))
for i in range(n_agents):
ranges[i]=k_range
iDim=n_agents
iOut=1
grid.makeLocalPolynomialGrid(iDim, iOut, paramL['iDepth'], paramL['which_basis'], "localp")
grid.setDomainTransform(ranges)
aPoints=grid.getPoints()
iNumP1=aPoints.shape[0]
aVals=np.empty([iNumP1, 1]) ## Change to 5d
file=open("comparison1.txt", 'w')
for iI in range(iNumP1):
aVals[iI]= solveriter.iterate(aPoints[iI], paramL, valold_list)[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_iter.txt", 'w')
np.savetxt(f, aPoints, fmt='% 2.16f')
f.close()
return grid
def ad_grid_iter(n_agents, iDepth, valold):
# valold is a list
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
iOut = 1
# TODO: parameterize this
refinement_level = 1
fTol = 1.E-5
# 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])
aVals1 = np.empty([iNumP1, 1])
for iI in range(iNumP1):
aValTemp = 0
for sIdx in range(5):
aValTemp += (1. / 5) * solveriter.iterate(aPoints[iI], n_agents,
valold[sIdx], sIdx)[0]
aVals[iI] = aValTemp
#print(aVals)
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) * solveriter.iterate(
aPoints[iI], n_agents, valold[sIdx], 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_iter.txt", 'w')
np.savetxt(f, aPoints, fmt='% 2.16f')
f.close()
return grid
def sparse_grid_iter(n_agents, iDepth, valold, refinement_level, fTol,
theta_vec, theta_prob):
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
iOut = 1
#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("comparison1.txt", 'w')
for iI in range(iNumP1):
expectation = [
solveriter.iterate(aPoints[iI], n_agents, valold, theta)[0]
for theta in theta_vec
]
expectation = np.array(expectation)
expectation = np.dot(expectation, theta_prob.T)
#expectation = np.empty_like(aVals[iI])
#for iT, theta in enumerate(theta_vec):
# new_expect = solveriter.iterate(aPoints[iI], n_agents, valold, theta)[0]
# expectation += new_expect*theta_prob[iT]
aVals[
iI] = expectation # We need to do something on changing this Valold
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]):
expectation = [
solveriter.iterate(aPoints[iI], n_agents, valold, theta)[0]
for theta in theta_vec
]
expectation = np.array(expectation)
expectation = np.dot(expectation, theta_prob.T)
aVals[
iI] = expectation # We need to do something on changing this Valold
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)
file.close()
f = open("grid_iter.txt", 'w')
np.savetxt(f, aPoints, fmt='% 2.16f')
f.close()
return grid
def sparse_grid_iter(n_agents, valold):
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_iter.txt", 'a')
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.empty((nump, n_agents))
comm.Scatterv([aPoints, sendcounts_scat, displs_scat, MPI.DOUBLE], local_aPoints)
local_aVals=np.empty([nump, 1])
file=open("comparison1.txt", 'w')
for iI in range(nump):
local_aVals[iI]=solveriter.iterate(local_aPoints[iI], n_agents, valold)[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
def sparse_grid_iter(n_agents, iDepth, valold):
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
iOut = 1
grid.makeLocalPolynomialGrid(iDim, iOut, iDepth, which_basis, "localp")
grid.setDomainTransform(ranges)
# 1 : Make grid
aPoints = grid.getPoints()
# Nb points on your grid
iNumP1 = aPoints.shape[0]
print(iNumP1)
aVals = np.empty([iNumP1, 1])
file = open("comparison1.txt", 'w')
for iI in range(iNumP1):
# 2 : Evaluate the function at each point
aVals[iI] = solveriter.iterate(aPoints[iI], n_agents, valold)[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()
# 3 : estimate the interpolant \alpha_{j,i} (the parameters)
grid.loadNeededPoints(aVals)
#refinement level --> adaptative part
for iK in range(refinement_level):
# 1.B.1 Where to add grid points
grid.setSurplusRefinement(fTol, 1, "fds")
# 1.B.2 Create the new ADAPTIVE grid
aPoints = grid.getNeededPoints()
# Nb of points on this new grid
print(iNumP1)
iNumP1 = aPoints.shape[0]
aVals = np.empty([iNumP1, 1])
for iI in range(iNumP1):
# print("valold is", valold[0])
# 2.B Evaluate the value function at these new points
aVals[iI] = solveriter.iterate(aPoints[iI], n_agents, valold)[0]
print("Refinement level", iK)
# 3.B : estimate the interpolant for these new points
grid.loadNeededPoints(aVals)
f = open("grid_iter.txt", 'w')
np.savetxt(f, aPoints, fmt='% 2.16f')
f.close()
return grid
#======================================================================
