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