def testSerializationLinearBoundingBox(self): """Uses Linear grid for tests""" from pysgpp import Grid factory = Grid.createLinearGrid(2) self.failIfEqual(factory, None) gen = factory.createGridGenerator() gen.regular(3) boundingBox = factory.getBoundingBox() tempBound = boundingBox.getBoundary(0) tempBound.leftBoundary = 0.0 tempBound.rightBoundary = 100.0 tempBound.bDirichletLeft = False; tempBound.bDirichletRight = False; boundingBox.setBoundary(0, tempBound) str = factory.serialize() self.assert_(len(str) > 0) newfac = Grid.unserialize(str) self.failIfEqual(newfac, None) self.assertEqual(factory.getStorage().size(), newfac.getStorage().size()) boundingBox = newfac.getBoundingBox() tempBound = boundingBox.getBoundary(0) self.assertEqual(0.0, tempBound.leftBoundary) self.assertEqual(100.0, tempBound.rightBoundary) self.assertEqual(False, tempBound.bDirichletLeft) self.assertEqual(False, tempBound.bDirichletRight)
def createGrid(grid, dim, deg=1, addTruncatedBorder=False): # create new grid gridType = grid.getType() if gridType in [Poly, PolyBoundary]: deg = max(deg, grid.getDegree()) # print gridType, deg if deg > 1: if gridType in [LinearBoundary, PolyBoundary]: return Grid.createPolyBoundaryGrid(dim, deg) elif gridType == LinearL0Boundary: raise NotImplementedError("there is no full boundary polynomial grid") elif gridType in [Linear, Poly]: return Grid.createPolyGrid(dim, deg) else: raise Exception('unknown grid type %s' % gridType) else: if gridType == Linear: return Grid.createLinearGrid(dim) elif gridType == LinearBoundary: return Grid.createLinearBoundaryGrid(dim) elif gridType == LinearL0Boundary: return Grid.createLinearBoundaryGrid(dim, 0) else: raise Exception('unknown grid type %s' % gridType)
def testOperationB(self): from pysgpp import Grid, DataVector, DataMatrix factory = Grid.createLinearGrid(1) gen = factory.createGridGenerator() gen.regular(2) alpha = DataVector(factory.getStorage().size()) p = DataMatrix(1,1) beta = DataVector(1) alpha.setAll(0.0) p.set(0,0,0.25) beta[0] = 1.0 opb = factory.createOperationB() opb.mult(beta, p, alpha) self.failUnlessAlmostEqual(alpha[0], 0.5) self.failUnlessAlmostEqual(alpha[1], 1.0) self.failUnlessAlmostEqual(alpha[2], 0.0) alpha.setAll(0.0) alpha[0] = 1.0 p.set(0,0, 0.25) beta[0] = 0.0 opb.multTranspose(alpha, p, beta) self.failUnlessAlmostEqual(beta[0], 0.5)
def checkPositivity(grid, alpha): # define a full grid of maxlevel of the grid gs = grid.getStorage() fullGrid = Grid.createLinearGrid(gs.dim()) fullGrid.createGridGenerator().full(gs.getMaxLevel()) fullHashGridStorage = fullGrid.getStorage() A = DataMatrix(fullHashGridStorage.size(), fullHashGridStorage.dim()) p = DataVector(gs.dim()) for i in xrange(fullHashGridStorage.size()): fullHashGridStorage.get(i).getCoords(p) A.setRow(i, p) res = evalSGFunctionMulti(grid, alpha, A) ymin, ymax, cnt = 0, -1e10, 0 for i, yi in enumerate(res.array()): if yi < 0. and abs(yi) > 1e-13: cnt += 1 ymin = min(ymin, yi) ymax = max(ymax, yi) A.getRow(i, p) print " %s = %g" % (p, yi) if cnt > 0: print "warning: function is not positive" print "%i/%i: [%g, %g]" % (cnt, fullHashGridStorage.size(), ymin, ymax) return cnt == 0
def testHierarchisationD(self): from pysgpp import Grid dim = 3 level = 5 function = buildParable(dim) grid = Grid.createLinearGrid(dim) testHierarchisationDehierarchisation(self, grid, level, function)
def testCreation(self): """Uses Linear grid for tests""" from pysgpp import Grid factory = Grid.createLinearGrid(2) self.failIfEqual(factory, None) storage = factory.getStorage() self.failIfEqual(storage, None)
def setUp(self): self.grid = Grid.createLinearGrid(2) # a simple 2D grid self.grid.createGridGenerator().regular(3) # max level 3 => 17 points self.HashGridStorage = self.grid.getStorage() alpha = DataVector(self.grid.getSize()) alpha.setAll(1.0) for i in [9, 10, 11, 12]: alpha[i] = 0.0 coarseningFunctor = SurplusCoarseningFunctor(alpha, 4, 0.5) self.grid.createGridGenerator().coarsen(coarseningFunctor, alpha)
def testHatRegulardD(self): from pysgpp import Grid factory = Grid.createLinearGrid(3) m = generateLaplaceMatrix(factory, 3) m_ref = readReferenceMatrix(self, factory.getStorage(), 'data/C_laplace_phi_li_hut_dim_3_nopsgrid_31_float.dat.gz') # compare compareStiffnessMatrices(self, m, m_ref)
def general_test(self, d, l, bb, xs): test_desc = "dim=%d, level=%d, len(x)=%s" % (d, l, len(xs)) print test_desc self.grid = Grid.createLinearGrid(d) self.grid_gen = self.grid.createGridGenerator() self.grid_gen.regular(l) alpha = DataVector([self.get_random_alpha() for i in xrange(self.grid.getSize())]) bb_ = BoundingBox(d) for d_k in xrange(d): dimbb = DimensionBoundary() dimbb.leftBoundary = bb[d_k][0] dimbb.rightBoundary = bb[d_k][1] bb_.setBoundary(d_k, dimbb) # Calculate the expected value without the bounding box expected_normal = [self.calc_exp_value_normal(x, d, bb, alpha) for x in xs] #expected_transposed = [self.calc_exp_value_transposed(x, d, bb, alpha) for x in xs] # Now set the bounding box self.grid.getStorage().setBoundingBox(bb_) dm = DataMatrix(len(xs), d) for k, x in enumerate(xs): dv = DataVector(x) dm.setRow(k, dv) multEval = createOperationMultipleEval(self.grid, dm) actual_normal = DataVector(len(xs)) #actual_transposed = DataVector(len(xs)) multEval.mult(alpha, actual_normal) #multEval.mult(alpha, actual_transposed) actual_normal_list = [] for k in xrange(len(xs)): actual_normal_list.append(actual_normal.__getitem__(k)) #actual_transposed_list = [] #for k in xrange(len(xs)): # actual_transposed_list.append(actual_transposed.__getitem__(k)) self.assertAlmostEqual(actual_normal_list, expected_normal) #self.assertAlmostEqual(actual_tranposed_list, expected_tranposed) del self.grid
def setUp(self): # # Grid # DIM = 2 LEVEL = 2 self.grid = Grid.createLinearGrid(DIM) self.grid_gen = self.grid.createGridGenerator() self.grid_gen.regular(LEVEL) # # trainData, classes, errors # xs = [] DELTA = 0.05 DELTA_RECI = int(1/DELTA) for i in xrange(DELTA_RECI): for j in xrange(DELTA_RECI): xs.append([DELTA*i, DELTA*j]) random.seed(1208813) ys = [ random.randint(-10, 10) for i in xrange(DELTA_RECI**2)] # print xs # print ys self.trainData = DataMatrix(xs) self.classes = DataVector(ys) self.alpha = DataVector([3, 6, 7, 9, -1]) self.errors = DataVector(DELTA_RECI**2) coord = DataVector(DIM) for i in xrange(self.trainData.getNrows()): self.trainData.getRow(i, coord) self.errors.__setitem__ (i, self.classes[i] - self.grid.eval(self.alpha, coord)) #print "Errors:" #print self.errors # # Functor # self.functor = WeightedErrorRefinementFunctor(self.alpha, self.grid) self.functor.setTrainDataset(self.trainData) self.functor.setClasses(self.classes) self.functor.setErrors(self.errors)
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.getStorage().dim()) fg.createGridGenerator().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 xrange(len(values)): gp = fgs.get(i) if values[i] < 0 and not jgs.has_key(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.seq(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 setUp(self,): self.__gridFormatter = None self.filename = pathlocal + "/datasets/grid.gz" self.savefile = pathlocal + "/datasets/savetest.grid.gz" self.correct_str = "" self.grid = None self.__gridFormatter = GridFormatter() dim = 3 self.grid = Grid.createLinearGrid(dim) self.grid.createGridGenerator().regular(3) self.correct_str = self.grid.serialize()
def testHatRegulardD_two(self): from pysgpp import Grid factory = Grid.createLinearGrid(3) training = buildTrainingVector(readDataVector('data/data_dim_3_nops_512_float.arff.gz')) level = 4 gen = factory.createGridGenerator() gen.regular(level) m = generateBBTMatrix(factory, training) m_ref = readReferenceMatrix(self, factory.getStorage(), 'data/BBT_phi_li_hut_dim_3_nopsgrid_111_float.dat.gz') # compare compareBBTMatrices(self, m, m_ref)
def setUp(self): # # Grid # DIM = 2 LEVEL = 2 self.grid = Grid.createLinearGrid(DIM) self.grid_gen = self.grid.createGridGenerator() self.grid_gen.regular(LEVEL) # # trainData, classes, errors # xs = [] DELTA = 0.05 DELTA_RECI = int(1/DELTA) for i in xrange(DELTA_RECI): for j in xrange(DELTA_RECI): xs.append([DELTA*i, DELTA*j]) random.seed(1208813) ys = [ random.randint(-10, 10) for i in xrange(DELTA_RECI**2)] self.trainData = DataMatrix(xs) self.classes = DataVector(ys) self.alpha = DataVector([3, 6, 7, 9, -1]) self.multEval = createOperationMultipleEval(self.grid, self.trainData) self.errors = DataVector(DELTA_RECI**2) coord = DataVector(DIM) for i in xrange(self.trainData.getNrows()): self.trainData.getRow(i, coord) self.errors.__setitem__ (i, abs(self.classes[i] - self.grid.eval(self.alpha, coord))) # # OnlinePredictiveRefinementDimension # hash_refinement = HashRefinement(); self.strategy = OnlinePredictiveRefinementDimension(hash_refinement) self.strategy.setTrainDataset(self.trainData) self.strategy.setClasses(self.classes) self.strategy.setErrors(self.errors)
def testGeneration(self): from pysgpp import Grid, DataVector factory = Grid.createLinearGrid(2) storage = factory.getStorage() gen = factory.createGridGenerator() self.failIfEqual(gen, None) self.failUnlessEqual(storage.size(), 0) gen.regular(3) self.failUnlessEqual(storage.size(), 17) #This should fail self.failUnlessRaises(Exception, gen.regular, 3)
def general_test(self, d, l, bb, x): test_desc = "dim=%d, level=%d, bb=%s, x=%s" % (d, l, bb, x) print test_desc self.grid = Grid.createLinearGrid(d) self.grid_gen = self.grid.createGridGenerator() self.grid_gen.regular(l) alpha = DataVector([1] * self.grid.getSize()) bb_ = BoundingBox(d) for d_k in xrange(d): dimbb = DimensionBoundary() dimbb.leftBoundary = bb[d_k][0] dimbb.rightBoundary = bb[d_k][1] bb_.setBoundary(d_k, dimbb) # Calculate the expected value without the bounding box expected = 0.0 inside = True x_trans = DataVector(d) for d_k in xrange(d): if not (bb[d_k][0] <= x[d_k] and x[d_k] <= bb[d_k][1]): inside = False break else: x_trans[d_k] = (x[d_k] - bb[d_k][0]) / (bb[d_k][1] - bb[d_k][0]) if inside: p = DataVector(x_trans) expected = self.grid.eval(alpha, p) else: expected = 0.0 # Now set the bounding box self.grid.getStorage().setBoundingBox(bb_) p = DataVector(x) actual = self.grid.eval(alpha, p) self.assertAlmostEqual(actual, expected) del self.grid
def testRefinement(self): from pysgpp import Grid, DataVector, SurplusRefinementFunctor factory = Grid.createLinearGrid(2) storage = factory.getStorage() gen = factory.createGridGenerator() gen.regular(1) self.failUnlessEqual(storage.size(), 1) alpha = DataVector(1) alpha[0] = 1.0 func = SurplusRefinementFunctor(alpha) gen.refine(func) self.failUnlessEqual(storage.size(), 5)
def eval_fullGrid(level, dim, border=True): if border: grid = Grid.createLinearBoundaryGrid(dim) else: grid = Grid.createLinearGrid(dim) grid.createGridGenerator().full(level) gs = grid.getStorage() ans = DataMatrix(gs.size(), dim) p = DataVector(dim) for i in xrange(gs.size()): gs.get(i).getCoords(p) ans.setRow(i, p) return ans
def testLoadGrid(self): dim = 2 level = 2 grid = Grid.createLinearGrid(dim) generator = grid.createGridGenerator() generator.regular(level) controller = CheckpointController("sample", pathlocal) sampleGrid = controller.loadGrid(0) # check dimension and size self.assertEqual(dim, sampleGrid.getStorage().dim()) self.assertEqual(grid.getStorage().size(), sampleGrid.getStorage().size()) # if string representations are equal, then grids are equal self.assertEqual(grid.serialize(), sampleGrid.serialize())
def testOperationEval_eval(self): from pysgpp import Grid, DataVector factory = Grid.createLinearGrid(1) gen = factory.createGridGenerator() gen.regular(1) alpha = DataVector(factory.getStorage().size()) alpha.setAll(1.0) p = DataVector(1) p.setAll(0.25) eval = factory.createOperationEval() self.failUnlessAlmostEqual(eval.eval(alpha, p), 0.5)
def testSerializationLinear(self): """Uses Linear grid for tests""" from pysgpp import Grid factory = Grid.createLinearGrid(2) self.failIfEqual(factory, None) gen = factory.createGridGenerator() gen.regular(3) str = factory.serialize() self.assert_(len(str) > 0) newfac = Grid.unserialize(str) self.failIfEqual(newfac, None) self.assertEqual(factory.getStorage().size(), newfac.getStorage().size())
def testSaveGrid(self): dim = 2 level = 2 grid = Grid.createLinearGrid(dim) generator = grid.createGridGenerator() generator.regular(level) controller = CheckpointController("savegrid", pathlocal) controller.setGrid(grid) controller.saveGrid(0) f = gzip.open(pathlocal + "/savegrid.0.grid.gz", "r") try: sampleString = f.read() finally: f.close() self.assertEqual(grid.serialize(), sampleString)
def createGrid(dim, level, borderType, isFull=False): from pysgpp.extensions.datadriven.learner.Types import BorderTypes if borderType == BorderTypes.NONE: grid = Grid.createLinearGrid(dim) elif borderType == BorderTypes.TRAPEZOIDBOUNDARY: grid = Grid.createLinearTrapezoidBoundaryGrid(dim) elif borderType == BorderTypes.COMPLETEBOUNDARY: grid = Grid.createLinearBoundaryGrid(dim, 0) else: raise Exception('Unknown border type') # create regular grid of level accLevel gridGen = grid.createGridGenerator() if isFull: gridGen.full(level) else: gridGen.regular(level) return grid
def testHatRegular1D(self): from pysgpp import Grid, DataVector factory = Grid.createLinearGrid(1) storage = factory.getStorage() gen = factory.createGridGenerator() gen.regular(7) laplace = factory.createOperationLaplace() alpha = DataVector(storage.size()) result = DataVector(storage.size()) alpha.setAll(1.0) laplace.mult(alpha, result) for seq in xrange(storage.size()): index = storage.get(seq) level, _ = index.get(0) self.failUnlessAlmostEqual(result[seq], pow(2.0, level+1))
def testOperationTest_test(self): from pysgpp import Grid, DataVector, DataMatrix factory = Grid.createLinearGrid(1) gen = factory.createGridGenerator() gen.regular(1) alpha = DataVector(factory.getStorage().size()) data = DataMatrix(1,1) data.setAll(0.25) classes = DataVector(1) classes.setAll(1.0) testOP = factory.createOperationTest() alpha.setAll(1.0) c = testOP.test(alpha, data, classes) self.failUnless(c > 0.0) alpha.setAll(-1.0) c = testOP.test(alpha, data, classes) self.failUnless(c == 0.0)
def discretizeFunction(f, bounds, level=2, hasBorder=False, *args, **kws): # define linear transformation to the unit hyper cube T = JointTransformation() for xlim in bounds: T.add(LinearTransformation(xlim[0], xlim[1])) # create grid dim = len(bounds) # create adequate grid if hasBorder: grid = Grid.createLinearBoundaryGrid(dim) else: grid = Grid.createLinearGrid(dim) # init storage grid.createGridGenerator().regular(level) gs = grid.getStorage() # discretize on given level p = DataVector(dim) nodalValues = DataVector(gs.size()) for i in xrange(gs.size()): gs.get(i).getCoords(p) # transform to the right space q = T.unitToProbabilistic(p.array()) # apply the given function nodalValues[i] = float(f(q)) # hierarchize alpha = hierarchize(grid, nodalValues) # estimate the l2 error err = estimateDiscreteL2Error(grid, alpha, f) # TODO: adaptive refinement return grid, alpha, err
def testSerializationLinearWithLeaf(self): """Uses Linear grid for tests""" from pysgpp import Grid srcLeaf = [] factory = Grid.createLinearGrid(2) self.failIfEqual(factory, None) gen = factory.createGridGenerator() gen.regular(3) for i in xrange(factory.getStorage().size()): srcLeaf.append(factory.getStorage().get(i).isLeaf()) str = factory.serialize() self.assert_(len(str) > 0) newfac = Grid.unserialize(str) self.failIfEqual(newfac, None) self.assertEqual(factory.getStorage().size(), newfac.getStorage().size()) for i in xrange(factory.getStorage().size()): self.failUnlessEqual(newfac.getStorage().get(i).isLeaf(), srcLeaf[i])
return [[0, 1], [0, 1]] dist = myDist() # plot analytic density fig = plt.figure() plotDensity2d(dist) plt.title("analytic, KL = 0") plt.xlim(0, 1) plt.ylim(0, 1) fig.show() # get a sprse grid approximation level = 6 grid = Grid.createLinearGrid(2) grid.getGenerator().regular(level) gs = grid.getStorage() nodalValues = DataVector(grid.getSize()) p = DataVector(gs.getDimension()) for i in range(gs.getSize()): gs.getCoordinates(gs.getPoint(i), p) nodalValues[i] = dist.pdf(p.array()) alpha = hierarchize(grid, nodalValues) # plot the result fig = plt.figure() plotSG2d(grid, alpha) plt.title("plotSG: vol = %g" % (doQuadrature(grid, alpha)))
def setUp(self): self.grid = Grid.createLinearGrid(2) # a simple 2D grid self.grid.getGenerator().regular(3) # max level 3 => 17 points self.HashGridStorage = self.grid.getStorage()
def testBilinearForms(self): # define parameter set builder = ParameterBuilder().defineUncertainParameters() # builder.new().isCalled('x').withTNormalDistribution(0.5, 0.1, 0, 1) # builder.new().isCalled('y').withTNormalDistribution(0.5, 0.1, 0, 1) builder.new().isCalled('x').withUniformDistribution(0, 1) builder.new().isCalled('y').withUniformDistribution(0, 1) params = builder.andGetResult() U = params.getIndependentJointDistribution() T = params.getJointTransformation() def f(x): """ Function to be interpolated """ # return 2. # return float(np.sin(4 * x[0]) * np.cos(4 * x[1])) return np.prod([4 * xi * (1 - xi) for xi in x]) # define sparse grid function grid = Grid.createLinearGrid(params.getStochasticDim()) grid.getGenerator().regular(2) gs = grid.getStorage() nodalValues = DataVector(gs.getSize()) p = DataVector(gs.getDimension()) for i in range(gs.getSize()): gs.getCoordinates(gs.getPoint(i), p) nodalValues[i] = f(p.array()) v = hierarchize(grid, nodalValues) res = DataVector(gs.getSize()) # ------------------------------------------------------------------------------- # compute admissible set admissibleSet = RefinableNodesSet() admissibleSet.create(grid) # ------------------------------------------------------------------------------- # define the strategies s0 = UniformQuadratureStrategy() s1 = PiecewiseConstantQuadratureStrategy(params=params) s2 = BilinearGaussQuadratureStrategy(U=U.getDistributions(), T=T.getTransformations()) s3 = SparseGridQuadratureStrategy(U=U.getDistributions()) A = s0.computeBilinearForm(grid) C, _ = s2.computeBilinearForm(grid) D, _ = s3.computeBilinearForm(grid) # ------------------------------------------------------------------------------- # compute bilinear form for lists of grid points gpsi, basisi = project(grid, [0, 1]) gpsj, basisj = project(grid, [0, 1]) C_list, _ = s2.computeBilinearFormByList(gs, gpsi, basisi, gpsj, basisj) D_list, _ = s3.computeBilinearFormByList(gs, gpsi, basisi, gpsj, basisj) assert np.all(np.abs(C_list - A) < 1e-13) assert np.all(np.abs(C_list - C) < 1e-13) assert np.all(np.abs(D_list - D) < 1e-13)
plt.title("analytic") fig.show() elif numDims == 2: fig = plt.figure() plotFunction2d(fun) plt.title("analytic") fig.show() fig, ax, _ = plotFunction3d(fun) ax.set_title("analytic") ax.set_zlim(-2, 2) fig.show() plt.savefig("sin_analytic.pdf") # get a sparse grid approximation grid = Grid.createLinearGrid(numDims) grid.getGenerator().regular(level) gs = grid.getStorage() alpha = hierarchizeFun(fun) print("l=%i: (gs=%i)" % (level, grid.getSize())) print("-" * 80) # plot the result if plot and numDims < 3: fig = plt.figure() if numDims == 1: plotSG1d(grid, alpha) elif numDims == 2: plotSG2d(grid, alpha, show_negative=False, show_grid_points=True)
def general_test(self, d, l, num): # print "#"*20 # print xs = [self.get_random_x(d) for i in xrange(num)] dupl = True while dupl: dupl_tmp = False for x in xs: for y in xs: if x == y: dupl = True break if dupl: break dupl = dupl_tmp xs = [self.get_random_x(d) for i in xrange(num)] errs = [self.get_random_err() for i in xrange(num)] self.grid = Grid.createLinearGrid(d) self.grid_gen = self.grid.createGridGenerator() self.grid_gen.regular(l) self.trainData = DataMatrix(xs) self.errors = DataVector(errs) self.multEval = createOperationMultipleEval(self.grid, self.trainData) self.dim = d self.storage = self.grid.getStorage() self.gridSize = self.grid.getSize() # # OnlinePredictiveRefinementDimension # # print "OnlineRefinementDim" hash_refinement = HashRefinement(); online = OnlinePredictiveRefinementDimension(hash_refinement) online.setTrainDataset(self.trainData) online.setErrors(self.errors) online_result = refinement_map({}) online.collectRefinablePoints(self.storage, 5, online_result) # for k,v in online_result.iteritems(): # print k, v # # Naive # # print # print "Naive" naive_result = self.naive_calc() # for k,v in naive_result.iteritems(): # print k, v # # OnlinePredictiveRefinementDimensionOld # hash_refinement = HashRefinement(); online_old = OnlinePredictiveRefinementDimensionOld(hash_refinement) # # Assertions # for k,v in online_result.iteritems(): if abs(online_result[k] - naive_result[k]) >= 0.1: #print "Error in:", k #print online_result[k] #print naive_result[k] #print naive_result #print "Datapoints" #print xs #print "Errors" #print errs #print "All values:" #print "Key: Online result, naive result" #for k,v in online_result.iteritems(): # print("{} ({}): {}, {}".format(k, self.storage.get(k[0]).toString(), v, naive_result[k])) self.assertTrue(False) # self.assertAlmostEqual(online_result[k], naive_result[k]) del self.grid del self.grid_gen del self.trainData del self.errors del self.multEval del self.storage
def test_manual(self): result = {(1, 0): 0, (2, 0): 0} # # Grid # DIM = 1 LEVEL = 2 self.grid = Grid.createLinearGrid(DIM) self.grid_gen = self.grid.createGridGenerator() self.grid_gen.regular(LEVEL) # # trainData, classes, errors # xs = [[0.0], [1.0]] errs = [1, 2] self.trainData = DataMatrix(xs) self.errors = DataVector(errs) self.multEval = createOperationMultipleEval(self.grid, self.trainData) self.dim = DIM self.storage = self.grid.getStorage() self.gridSize = self.grid.getSize() # # OnlinePredictiveRefinementDimension # print "#"*20 print "OnlineRefinementDim" hash_refinement = HashRefinement(); online = OnlinePredictiveRefinementDimension(hash_refinement) online.setTrainDataset(self.trainData) online.setErrors(self.errors) online_result = refinement_map({}) online.collectRefinablePoints(self.grid.getStorage(), 10, online_result) for k,v in online_result.iteritems(): print k, v for k,v in online_result.iteritems(): self.assertAlmostEqual(online_result[k], result[k]) # # Naive # print "#"*20 print "Naive" naive_result = self.naive_calc() #for k,v in naive_result.iteritems(): #print k, v for k,v in naive_result.iteritems(): self.assertAlmostEqual(naive_result[k], result[k])
def setUp(self): self.grid = Grid.createLinearGrid(2) # a simple 2D grid self.grid.createGridGenerator().regular(3) # max level 3 => 17 points self.HashGridStorage = self.grid.getStorage()
# sgpp.sparsegrids.org # import modules from pysgpp import DataVector, Grid, createOperationHierarchisation, \ createOperationQuadrature, OperationQuadratureMC # the standard parabola (arbitrary-dimensional) def f(x): res = 1.0 for i in range(len(x)): res *= 4.0*x[i]*(1.0-x[i]) return res # create a two-dimensional piecewise bi-linear grid dim = 2 grid = Grid.createLinearGrid(dim) gridStorage = grid.getStorage() print "dimensionality: {}".format(dim) # create regular grid, level 3 level = 3 gridGen = grid.createGridGenerator() gridGen.regular(level) print "number of grid points: {}".format(gridStorage.size()) # create coefficient vector alpha = DataVector(gridStorage.size()) for i in xrange(gridStorage.size()): gp = gridStorage.get(i) alpha[i] = f((gp.getCoord(0), gp.getCoord(1))) createOperationHierarchisation(grid).doHierarchisation(alpha)
def test_manual(self): print "#"*20 result = {(1, 0): 5, (2, 0): 25} # # Grid # DIM = 1 LEVEL = 2 self.grid = Grid.createLinearGrid(DIM) self.grid_gen = self.grid.createGridGenerator() self.grid_gen.regular(LEVEL) # # trainData, classes, errors # xs = [[0.1], [0.4], [0.6], [0.8]] errs = [1, 2, 3, 4] self.trainData = DataMatrix(xs) self.errors = DataVector(errs) self.multEval = createOperationMultipleEval(self.grid, self.trainData) self.dim = DIM self.storage = self.grid.getStorage() self.gridSize = self.grid.getSize() # # OnlinePredictiveRefinementDimension # print "OnlineRefinementDim" hash_refinement = HashRefinement(); online = OnlinePredictiveRefinementDimension(hash_refinement) online.setTrainDataset(self.trainData) online.setErrors(self.errors) online_result = refinement_map({}) online.collectRefinablePoints(self.grid.getStorage(), 10, online_result) for k,v in online_result.iteritems(): print k, v for k,v in online_result.iteritems(): self.assertAlmostEqual(online_result[k], result[k]) # # Naive # print print "Naive" naive_result = self.naive_calc() for k,v in naive_result.iteritems(): print k, v for k,v in naive_result.iteritems(): self.assertAlmostEqual(naive_result[k], result[k])
def adaptiveGridToRegularGrid(numDims, level, refnums, f, numSamples=1000, plot=False, verbose=False): """ Converts a regular sparse grid function to a sparse grid in the combination technique and back. Arguments: numDims -- int number of dimensions level -- level of the sparse grid refnums -- int number of refinement steps f -- function to be interpolated numSamples -- int number of random samples on which we evaluate the different sparse grid functions to validate the grid conversion plot -- bool whether the sparse grid functions are plotted or not (just for numDims=1) verbose -- bool verbosity """ ## We generate a iid of uniform samples, which we are going to use to ## validate the grid conversion x = np.random.rand(numSamples, numDims) parameters = DataMatrix(x) ## We create a regular sparse grid as usual and... grid = Grid.createLinearGrid(numDims) grid.getGenerator().regular(level) alpha = interpolate(grid, f) ## ... refine it adaptively grid_adaptive = grid.clone() alpha_adaptive = DataVector(alpha) refineGrid(grid_adaptive, alpha_adaptive, f, refnums) ## We apply now both methods of the grid conversion on the ## adaptively refined grid. The first conversion considers all ## levels where at least one sparse grid point exists, while the ## second one considers just complete subspaces. treeStorage_all = convertHierarchicalSparseGridToCombigrid( grid_adaptive.getStorage(), GridConversionTypes_ALLSUBSPACES) treeStorage_complete = convertHierarchicalSparseGridToCombigrid( grid_adaptive.getStorage(), GridConversionTypes_COMPLETESUBSPACES) ## We initialize the CombigridOperation on a grid that spans the ## same function space as the original hierarchical sparse grid: ## hat basis on an equidistant grids without boundary points. func = multiFunc(f) opt_all = CombigridMultiOperation.createExpUniformLinearInterpolation( numDims, func) opt_complete = CombigridMultiOperation.createExpUniformLinearInterpolation( numDims, func) ## The CombigridOperation expects the points at which you want to ## evaluate the interpolant as DataMatrix with the shape (numDims ## x numSamples). We, therefore, need to transpose the samples and ## initialize the multi operation with them. To set the level ## structure we initialize the level manager of the operation with ## the storage we have obtained after the conversion. parameters.transpose() opt_all.setParameters(parameters) opt_all.getLevelManager().addLevelsFromStructure(treeStorage_all) opt_complete.setParameters(parameters) opt_complete.getLevelManager().addLevelsFromStructure(treeStorage_complete) parameters.transpose() ## If you want you can examine the levels of the combination ## technique... if verbose: print("-" * 80) print("just full levels:") print(opt_complete.getLevelManager().getSerializedLevelStructure()) print("-" * 80) print("all levels:") print(opt_all.getLevelManager().getSerializedLevelStructure()) print("-" * 80) ## We start to transform the grids from the combination technique ## back to their hierarchical formulation. We, again, create a ## grid with a piecewise d-linear basis and initialize the grid ## points in its storage by the ones available in the levels of ## the combination technique. We do it first for the combination ## grids that just contain just those levels where the original ## sparse grid had complete subpsaces... grid_complete = Grid.createLinearGrid(numDims) treeStorage_complete = opt_complete.getLevelManager().getLevelStructure() convertCombigridToHierarchicalSparseGrid(treeStorage_complete, grid_complete.getStorage()) ## ... and do the same for the version where we considered all ## subspaces where at least one grid point was located. grid_all = Grid.createLinearGrid(numDims) treeStorage_all = opt_all.getLevelManager().getLevelStructure() convertCombigridToHierarchicalSparseGrid(treeStorage_all, grid_all.getStorage()) ## we interpolate now f on the new grids and... alpha_complete = interpolate(grid_complete, f) alpha_all = interpolate(grid_all, f) ## ... evaluate all the surrogate functions we have so far y_sg_regular = DataVector(numSamples) createOperationMultipleEval(grid, parameters).eval(alpha, y_sg_regular) y_sg_adaptive = DataVector(numSamples) createOperationMultipleEval(grid_adaptive, parameters).eval(alpha_adaptive, y_sg_adaptive) y_sg_all = DataVector(numSamples) createOperationMultipleEval(grid_all, parameters).eval(alpha_all, y_sg_all) y_sg_complete = DataVector(numSamples) createOperationMultipleEval(grid_complete, parameters).eval(alpha_complete, y_sg_complete) y_ct_all = opt_all.getResult() y_ct_complete = opt_complete.getResult() ## For convenience we use flattened numpy arrays to test if the ## function values at each point are the same. y_sg_regular = y_sg_regular.array().flatten() y_sg_adaptive = y_sg_adaptive.array().flatten() y_ct_all = y_ct_all.array().flatten() y_ct_complete = y_ct_complete.array().flatten() y_sg_all = y_sg_all.array().flatten() y_sg_complete = y_sg_complete.array().flatten() ## If you want, you can plot the results if the problem is one dimensional if plot and numDims == 1: x = x.flatten() ixs = np.argsort(x) plt.figure() plt.plot(x[ixs], y_sg_regular[ixs], label="sg regular") plt.plot(x[ixs], y_sg_adaptive[ixs], label="sg adaptive") plt.plot(x[ixs], y_ct_complete[ixs], label="ct full") plt.plot(x[ixs], y_ct_all[ixs], label="ct all") plt.plot(x[ixs], y_sg_complete[ixs], label="sg full") plt.plot(x[ixs], y_sg_all[ixs], label="sg all") plt.legend() plt.show() ## All the function values should not be equivalent if... if grid_complete.getSize() < grid_all.getSize(): assert np.sum((y_ct_complete - y_ct_all)**2) > 1e-14 assert np.sum((y_sg_regular - y_sg_all)**2) > 1e-14 ## and should be equivalent if... if grid_complete.getSize() == grid.getSize(): assert np.sum((y_ct_complete - y_sg_regular)**2) < 1e-14 assert np.sum((y_sg_complete - y_sg_regular)**2) < 1e-14 ## For the grid sizes it must hold that assert grid_adaptive.getSize() > grid.getSize() assert grid_complete.getSize() <= grid_adaptive.getSize() assert grid_all.getSize() >= grid.getSize()
def f(x): """ Function to be interpolated """ # return float(x ** 3 + 2 * x ** 2 - x + 1) # return float(np.exp(2 * -x)) # return float(np.sin(8 * x)) return np.prod([4 * xi * (1 - xi) for xi in x]) # ------------------------------------------------------- # define sparse grid function - control # ------------------------------------------------------- grid_control = Grid.createLinearGrid(1) grid_control.getGenerator().regular(4) gsc = grid_control.getStorage() nodalValues = DataVector(gsc.getSize()) p = DataVector(gsc.getDimension()) for i in range(gsc.getSize()): gsc.getCoordinates(gsc.getPoint(i), p) nodalValues[i] = f(p.array()) w = hierarchize(grid_control, nodalValues) # ------------------------------------------------------- # define sparse grid function # -------------------------------------------------------
# import modules from pysgpp import DataVector, Grid, createOperationHierarchisation, \ createOperationQuadrature, OperationQuadratureMC # the standard parabola (arbitrary-dimensional) def f(x): res = 1.0 for i in range(len(x)): res *= 4.0 * x[i] * (1.0 - x[i]) return res # create a two-dimensional piecewise bi-linear grid dim = 2 grid = Grid.createLinearGrid(dim) gridStorage = grid.getStorage() print "dimensionality: {}".format(dim) # create regular grid, level 3 level = 3 gridGen = grid.createGridGenerator() gridGen.regular(level) print "number of grid points: {}".format(gridStorage.size()) # create coefficient vector alpha = DataVector(gridStorage.size()) for i in xrange(gridStorage.size()): gp = gridStorage.get(i) alpha[i] = f((gp.getCoord(0), gp.getCoord(1))) createOperationHierarchisation(grid).doHierarchisation(alpha)