def makePositive(grid, alpha): """ insert full grid points if they are negative and the father node is part of the sparse grid @param grid: @param alpha: """ # copy old sg function jgrid = copyGrid(grid) # evaluate the sparse grid function at all full grid points level = grid.getStorage().getMaxLevel() fg = Grid.createLinearGrid(grid.getDimension()) fg.getGenerator().full(level) # copy the old grid and use it as reference jgs = jgrid.getStorage() fgs = fg.getStorage() # run over all results and check where the function value # is lower than zero cnt = 1 while True: print("run %i: full grid size = %i" % (cnt, fgs.size())) gps = [] # insert those fg points, which are not yet positive values = computeNodalValues(fg, grid, alpha) for i in range(len(values)): gp = fgs.getPoint(i) if values[i] < 0 and not jgs.isContaining(gp): gps += insertPoint(jgrid, gp) gps += insertHierarchicalAncestors(jgrid, gp) jgrid.getStorage().recalcLeafProperty() # 1. compute nodal values for new grid points jnodalValues = computeNodalValues(jgrid, grid, alpha) # 2. set the new ones to zero jgs = jgrid.getStorage() for gp in gps: jnodalValues[jgs.getSequenceNumber(gp)] = 0. # 3. hierarchize jalpha = hierarchize(jgrid, jnodalValues) # stop loop if no points have been added if len(gps) == 0: break # 4. reset values for next loop grid = copyGrid(jgrid) alpha = DataVector(jalpha) cnt += 1 return jgrid, jalpha
def update(self, grid, alpha, qoi, t, dtype, iteration): """ Update the knowledge @param grid: Grid @param alpha: DataVector surplus vector @param qoi: string quantity of interest @param t: float time step @param dtype: KnowledgeType @param iteration: int iteration number """ # build dictionary if iteration not in self.__alphas: self.__alphas[iteration] = {} self.__grids[iteration] = {} if qoi not in self.__alphas[iteration]: self.__alphas[iteration][qoi] = {} self.__grids[iteration][qoi] = {} if dtype not in self.__alphas[iteration][qoi]: self.__alphas[iteration][qoi][dtype] = {} if t not in self.__alphas[iteration][qoi][dtype]: self.__alphas[iteration][qoi][dtype][t] = {} # store knowledge self.__iteration = iteration self.__grids[iteration][qoi] = copyGrid(grid) self.__alphas[iteration][qoi][dtype][t] = DataVector(alpha)
def learnDataWithTest(self, dataset=None, *args, **kws): if self.verbose: print("learning with test (i=%i, gs=%i)" % (self.sampler.getCurrentIterationNumber(), self.sampler.getGrid().getSize())) # learn data self.learner.grid = self.sampler.getGrid() for dtype, values in list(self.dataContainer.items()): knowledge = {} # do the learning for t in np.sort(list(values.keys())): dataContainer = values[t] if self.verbose: print(("t = %g, " % t, )) sys.stdout.flush() if dataContainer is not None: # learn data, if there is any available self.learner.dataContainer = dataContainer self.learner.learnDataWithTest(dtype=dtype) # update the knowledge self.knowledge.update( copyGrid(self.learner.grid), self.learner.alpha, self._qoi, t, dtype, self.sampler.getCurrentIterationNumber() - 1) # update results self.stats.updateResults(dtype, t, self.learner) if self.verbose: print()
def learnDataWithoutTest(self, *args, **kws): # learn data if self.verbose: print("learning (i=%i, gs=%i, type=%s)" % (self.sampler.getCurrentIterationNumber(), self.sampler.getGrid().getSize(), self.sampler.getGrid().getTypeAsString())) self.learner.grid = self.sampler.getGrid() for dtype, values in list(self.dataContainer.items()): knowledge = {} if self.verbose: print(KnowledgeTypes.toString(dtype)) # do the learning for t, dataContainer in list(values.items()): if self.verbose: print(("t = %g, " % t, )) sys.stdout.flush() if dataContainer is not None: # learn data, if there is any available self.learner.dataContainer = dataContainer self.learner.learnData() # update the knowledge self.knowledge.update( copyGrid(self.learner.grid), self.learner.alpha, self._qoi, t, dtype, self.sampler.getCurrentIterationNumber() - 1) # update results self.stats.updateResults(dtype, t, self.learner) if self.verbose: print()
def join(grid1, grid2, *args, **kws): """ Join two grids, which are not of the same dimensionality. The grid of lower dimensionality is extended to the larger one by adding a full grid resolution in the new directions. @param grid1: Grid, sparse grid @param grid2: Grid, sparse grid @return: Grid, joined sparse grid of dimensionality max(dim1, dim2) with basis of grid2 """ dim1 = grid1.getDimension() dim2 = grid2.getDimension() if dim1 < dim2: grid1 = extend_grid(grid1, dim2 - dim1, *args, **kws) elif dim2 < dim1: grid2 = extend_grid(grid2, dim1 - dim2, *args, **kws) else: grid1 = copyGrid(grid1, *args, **kws) grid2 = copyGrid(grid2, *args, **kws) gs1 = grid1.getStorage() gs2 = grid2.getStorage() # join grid points: copy all the grid points from grid 1 to grid 2 for i in range(gs1.size()): gp = gs1.getPoint(i) # insert grid point if not gs2.isContaining(gp): gs2.insert(gp) gs2.recalcLeafProperty() # return the joined grid return grid2
def learnDataWithFolding(self, *args, **kws): # learn data for dtype, values in list(self.dataContainer.items()): knowledge = {} # do the learning for t, dataContainer in list(values.items()): if dataContainer is not None: learner = self._learners[t] # learn data, if there is any available learner.grid = self.getGrid() learner.dataContainer = dataContainer alpha = learner.learnDataWithFolding(dtype=dtype) # prepare the answer knowledge[t] = copyGrid(learner.grid), DataVector(alpha) # update results if len(knowledge) > 0: self.updateResults(knowledge, dtype)
def learnDataWithFolding(self, *args, **kws): # learn data for dtype, values in self.dataContainer.items(): knowledge = {} # do the learning for t, dataContainer in values.items(): if dataContainer is not None: learner = self._learners[t] # learn data, if there is any available learner.grid = self.getGrid() learner.dataContainer = dataContainer alpha = learner.learnDataWithFolding(dtype=dtype) # prepare the answer knowledge[t] = copyGrid(learner.grid), DataVector(alpha) # update results if len(knowledge) > 0: self.updateResults(knowledge, dtype)
def learnData(self, *args, **kws): # learn data for dtype, values in self.dataContainer.items(): knowledge = {} print KnowledgeTypes.toString(dtype) # do the learning for t, dataContainer in values.items(): print "t = %g, " % t, if dataContainer is not None: learner = self._learners[t] # learn data, if there is any available learner.grid = self.getGrid() learner.dataContainer = dataContainer alpha = learner.learnData() # prepare the answer knowledge[t] = copyGrid(learner.grid), DataVector(alpha) print # update results if len(knowledge) > 0: self.updateResults(knowledge, dtype)
def discretize(grid, alpha, f, epsilon=0., refnums=0, pointsNum=10, level=0, deg=1, useDiscreteL2Error=True): """ discretize f with a sparse grid @param grid: Grid @param alpha: surplus vector @param f: function @param epsilon: float, error tolerance @param refnums: int, number of refinment steps @param pointsNum: int, number of points to be refined per step @param level: int, initial grid level @param deg: int, degree of lagrange basis """ # copy grid jgrid = copyGrid(grid, level=level, deg=deg) jgs = jgrid.getStorage() jgn = jgrid.getGenerator() basis_alpha = DataVector(alpha) # compute joined sg function jalpha = computeCoefficients(jgrid, grid, alpha, f) # compute errors maxdrift = None accMiseL2 = None l2error_grid = DataVector(alpha).l2Norm() if useDiscreteL2Error: maxdrift, accMiseL2 = computeErrors(jgrid, jalpha, grid, alpha, f) else: accMiseL2 = l2error_grid # print( "iteration 0/%i (%i, %i, %g): %g, %g, %s" % \ ) # (refnums, jgs.getSize(), len(jalpha), # epsilon, accMiseL2, l2error_grid, maxdrift) ref = 0 errs = [jgs.getSize(), accMiseL2, l2error_grid, maxdrift] bestGrid, bestAlpha, bestL2Error = copyGrid(jgrid), DataVector( jalpha), accMiseL2 # repeat refinement as long as there are iterations and the # minimum error epsilon is reached jalpha = DataVector(jalpha) while ref < refnums and bestL2Error > epsilon: oldgrid = copyGrid(jgrid) rp = jgn.getNumberOfRefinablePoints( ) # max(1, min(pointsNum, jgn.getNumberOfRefinablePoints())) jgn.refine(SurplusRefinementFunctor(jalpha, rp, epsilon)) # if grid point has been added in the last iteration step if len(basis_alpha) == jgs.getSize(): break # extend alpha vector... basis_alpha.resizeZero(jgs.getSize()) # ------------------------------ # compute joined sg function jalpha = computeCoefficients(jgrid, grid, basis_alpha, f) # compute useDiscreteL2Error l2error_grid = estimateL2error(oldgrid, jgrid, jalpha) # do Monte Carlo integration for obtaining the accMiseL2 if useDiscreteL2Error: maxdrift, accMiseL2 = computeErrors(jgrid, jalpha, grid, alpha, f) # ------------------------------ print( "iteration %i/%i (%i, %i, %i, %i, %g): %g, %g, %s -> current best %g" % \ (ref + 1, refnums, jgs.getSize(), len(jalpha), bestGrid.getSize(), len(bestAlpha), epsilon, accMiseL2, l2error_grid, maxdrift, bestL2Error)) # check whether the new grid is better than the current best one # using the discrete l2 error. If no MC integration is done, # use the l2 error approximation via the sparse grid surpluses if (not useDiscreteL2Error and l2error_grid < bestL2Error) or \ (useDiscreteL2Error and accMiseL2 < bestL2Error): bestGrid = copyGrid(jgrid) bestAlpha = DataVector(jalpha) if useDiscreteL2Error: bestL2Error = accMiseL2 else: bestL2Error = l2error_grid errs = [jgs.getSize(), accMiseL2, l2error_grid, maxdrift] ref += 1 return bestGrid, bestAlpha, errs
def __refine(self, learner, B, simulate=False): # get sparse grid grid = learner.getGrid() if simulate: oldGrid = grid grid = copyGrid(grid) learner.grid = grid # find how many points should be refined pointsNum = learner.getNumOfPointsToRefine(len(B)) # refine now step by step newGridPoints = [] refinedPoints = [] gs = grid.getStorage() iteration = learner.iteration # size of grid before refinement n1 = gs.size() # as long as the end of learning has not been reached, continue... while pointsNum > 0 and len(B) > 0 and \ (not learner.stopPolicy or not learner.stopPolicy.hasLimitReached(learner)): # note: the highest rated grid point is at the end of B vi, gp = B.pop() # some printing if not simulate: print "refine %i/%i (%i, %i) = %g" % \ (pointsNum, len(B), len(newGridPoints), len(refinedPoints), vi) # refine the grid nps = self._localRefinementStrategy.refine(grid, gp) # ## set surplus vector such that just the desired point # ## is going to be refined and nothing else # oldgs = HashGridStorage(gs) # alpha = DataVector(gs.size()) # alpha.setAll(0.0) # alpha[gs.seq(gp)] = 2.0 # refFunc = SurplusRefinementFunctor(alpha, 1, 1) # ## TODO: try refineMaxLevel(refFunc, maxLevel) # grid.createGridGenerator().refine(refFunc) # nps = [] # for i in xrange(gs.size()): # if not oldgs.has_key(gs.get(i)): # nps.append(i) # check there have been added some new points if not learner.stopPolicy or \ learner.stopPolicy.hasGridSizeChanged(learner): # if something has been refined then reduce the number # of points which should still be refined pointsNum -= 1 # store which point has been refined refinedPoints.append(HashGridIndex(gp)) newGridPoints += nps # increase iteration of the learner learner.iteration += 1 # balance the grid if self._balancing: newGridPoints += balance(grid) # update admissible set if not simulate: self._admissibleSet.update(grid, newGridPoints) # make sure that I have collected all the new grid points assert len(newGridPoints) == gs.size() - n1 # reset the iteration variable @TODO: the iteration variable # is ambiguous. It represents in the TrainingStopPolicy the # number of refinement steps, in the context of ASGC it # represents the number of refinements. So here we neglect the # first part and use it just internally so that the # hasLimitReached works. learner.iteration = iteration # if not simulate: # gs = grid.getStorage() # p = DataVector(gs.dim()) # # for gp in refinedPoints: # gp.getCoords(p) # plt.plot(p[0], p[1], marker='o', markersize=20, # linestyle='', color='green') # # for i in xrange(gs.size()): # gs.get(i).getCoords(p) # plt.plot(p[0], p[1], marker='o', markersize=10, # linestyle='', color='blue') # # for gp in newGridPoints: # gp.getCoords(p) # plt.plot(p[0], p[1], marker='o', markersize=10, # linestyle='', color='red') # # plt.title("size = %i" % gs.size()) # plt.xlim(0, 1) # plt.ylim(0, 1) # plt.savefig('%i.png' % learner.iteration) # reset the learner if the refinement is just simulated if simulate: learner.grid = oldGrid return newGridPoints
def __refine(self, grid, B, simulate=False): # get sparse grid if simulate: grid = copyGrid(grid) # find how many points should be refined pointsNum = self.getNumOfPointsToRefine(len(B)) # refine now step by step newGridPoints = [] refinedPoints = [] gs = grid.getStorage() # size of grid before refinement n1 = gs.getSize() # as long as the end of learning has not been reached, continue... while pointsNum > 0 and len(B) > 0: # note: the highest rated grid point is at the end of B vi, gp = B.pop() # some printing if not simulate and self.verbose: print( "refine %i/%i (%i, %i) = %g" % \ (pointsNum, len(B) + 1, len(newGridPoints), len(refinedPoints), vi)) # refine the grid oldSize = grid.getSize() nps = self._localRefinementStrategy.refine(grid, gp) assert grid.getSize() == oldSize + len(nps) # ## set surplus vector such that just the desired point # ## is going to be refined and nothing else # oldgs = HashGridStorage(gs) # alpha = DataVector(gs.getSize()) # alpha.setAll(0.0) # alpha[gs.getSequenceNumber(gp)] = 2.0 # refFunc = SurplusRefinementFunctor(alpha, 1, 1) # ## TODO: try refineMaxLevel(refFunc, maxLevel) # grid.getGenerator().refine(refFunc) # nps = [] # for i in xrange(gs.getSize()): # if not oldgs.isContaining(gs.getPoint(i)): # nps.append(i) # check there have been added some new points if len(nps) > 0: # if something has been refined then reduce the number # of points which should still be refined pointsNum -= 1 # store which point has been refined refinedPoints.append(HashGridPoint(gp)) newGridPoints += nps # balance the grid if self._balancing: newGridPoints += balance(grid) # if not simulate: # import matplotlib.pyplot as plt # gs = grid.getStorage() # p = DataVector(gs.getDimension()) # # fig = plt.figure() # for gp in refinedPoints: # gs.getCoordinates(gp, p) # plt.plot(p[0], p[1], marker='o', markersize=20, # linestyle='', color='green') # # for i in xrange(gs.getSize()): # gpi = gs.getPoint(i) # gs.getCoordinates(gpi, p) # if gpi in self._admissibleSet: # plt.plot(p[0], p[1], marker='o', markersize=10, # linestyle='', color='orange') # else: # plt.plot(p[0], p[1], marker='o', markersize=10, # linestyle='', color='blue') # # for gp in newGridPoints: # gs.getCoordinates(gp, p) # plt.plot(p[0], p[1], marker='o', markersize=10, # linestyle='', color='red') # # plt.title("size = %i" % gs.getSize()) # plt.xlim(0, 1) # plt.ylim(0, 1) # # plt.show() # plt.savefig('/home/franzefn/Desktop/tmp/var_atan_i%i.png' % gs.getSize()) # plt.close(fig) # update admissible set if not simulate: self._admissibleSet.update(grid, newGridPoints) # make sure that I have collected all the new grid points assert len(newGridPoints) == gs.getSize() - n1 return newGridPoints