def computeMean(self, grid, alpha, newGridPoints): gs = grid.getStorage() opEval = createOperationEval(grid) newGs = grid.getStorage() newNodalValues = dehierarchize(grid, alpha) p = DataVector(gs.dim()) for newGp in newGridPoints: # run over all grid points of current level newGp.getCoords(p) pp = DataVector(p) i = newGs.seq(newGp) newNodalValues[i] = 0. for d in xrange(gs.dim()): # get current index index = newGp.getIndex(d) level = newGp.getLevel(d) # bounds xlow, xhigh = getBoundsOfSupport(level, index) # compute function values at bounds pp[d] = xlow fxlow = opEval.eval(alpha, pp) pp[d] = xhigh fxhigh = opEval.eval(alpha, pp) # interpolate linearly a = (fxhigh - fxlow) / (xlow - xhigh) newNodalValues[i] += a * (p[d] - xlow) + fxhigh # reset pp and set sumWeights pp[d] = p[d] newNodalValues[i] /= gs.dim() return newNodalValues
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.getGenerator() self.grid_gen.regular(l) alpha = DataVector([1] * self.grid.getSize()) bb_ = BoundingBox(d) for d_k in range(d): dimbb = BoundingBox1D() 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) opEval = createOperationEval(self.grid) for d_k in range(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 = opEval.eval(alpha, p) else: expected = 0.0 # Now set the bounding box self.grid.getStorage().setBoundingBox(bb_) p = DataVector(x) actual = opEval.eval(alpha, p) self.assertAlmostEqual(actual, expected) del self.grid
def findCandidates(self, grid, alpha, addedGridPoints): fullGridStorage = self.fullGrid.getStorage() gs = grid.getStorage() if self.iteration == 0: self.costs += fullGridStorage.getSize() elif len(addedGridPoints) == 0: return opEval = createOperationEval(grid) for i in range(fullGridStorage.getSize()): gp = fullGridStorage.getPoint(i) if not gs.isContaining(gp): self.candidates.append(HashGridPoint(gp))
def lookupFullGridPoints(self, grid, alpha, candidates): acc = [] gs = grid.getStorage() p = DataVector(gs.dim()) opEval = createOperationEval(grid) # TODO: find local max level for adaptively refined grids maxLevel = gs.getMaxLevel() if grid.getType() in [LinearBoundary, PolyBoundary]: maxLevel += 1 for gp in candidates: for d in xrange(gs.dim()): if 0 < gp.getLevel(d) < maxLevel: self.lookupFullGridPointsRec1d(grid, alpha, gp, d, p, opEval, maxLevel, acc) return acc
def testFG(obj, grid, level, function): node_values = None node_values_back = None alpha = None points = None p = None l_user = 2 # generate a regular test grid generator = grid.createGridGenerator() generator.truncated(level, l_user) storage = grid.getStorage() dim = storage.dim() # generate the node_values vector fgs = FullGridSet(dim, level, l_user) node_values = DataVector(storage.size()) for i in xrange(fgs.getSize()): fg = fgs.at(i) m = fg.getSize() for j in xrange(m): points = fg.getCoordsString(j).split() d = evalFunction(function, points) fg.set(j, d) fgs.reCompose(storage, node_values) createOperationHierarchisation(grid).doHierarchisation(node_values) evalOp = createOperationEval(grid) p = DataVector(dim) # Extensions in C and C++ -- Extension modules and extension types can be written by hand. There are also tools that help with this, for example, SWIG, sip, Pyrex. perationEval() for m in range(10): points = [] for k in range(dim): p[k] = random.random() points.append(str(p[k])) for j in range(fgs.getSize()): fg = fgs.at(j) fg.eval(p) if (abs(evalOp.eval(node_values, p) - evalFunction(function, points)) > 0.01): print points print evalOp.eval(node_values, p) print evalFunction(function, points) obj.fail() obj.failUnlessAlmostEqual(evalOp.eval(node_values, p), fgs.combinedResult())
def testFG(obj, grid, level, function): node_values = None node_values_back = None alpha = None points = None p = None l_user=2; # generate a regular test grid generator = grid.createGridGenerator() generator.truncated(level,l_user) storage = grid.getStorage() dim = storage.dim() # generate the node_values vector fgs = FullGridSet(dim,level, l_user) node_values = DataVector(storage.size()) for i in xrange(fgs.getSize()): fg=fgs.at(i) m=fg.getSize() for j in xrange(m): points=fg.getCoordsString(j).split() d=evalFunction(function, points) fg.set(j,d) fgs.reCompose(storage,node_values) createOperationHierarchisation(grid).doHierarchisation(node_values); evalOp = createOperationEval(grid) p=DataVector(dim) # Extensions in C and C++ -- Extension modules and extension types can be written by hand. There are also tools that help with this, for example, SWIG, sip, Pyrex. perationEval() for m in range(10): points = [] for k in range(dim): p[k]=random.random() points.append(str(p[k])) for j in range(fgs.getSize()): fg=fgs.at(j) fg.eval(p) if (abs(evalOp.eval(node_values, p)-evalFunction(function,points))>0.01): print points print evalOp.eval(node_values,p) print evalFunction(function,points) obj.fail() obj.failUnlessAlmostEqual(evalOp.eval(node_values,p),fgs.combinedResult())
def evalSGFunction(grid, alpha, p): try: # raise Exception() return createOperationEval(grid).eval(alpha, p) except Exception: # import ipdb; ipdb.set_trace() # alternative basis = getBasis(grid) gs = grid.getStorage() res = 0.0 for i in xrange(gs.size()): gp = gs.get(i) val = 1.0 for d in xrange(gs.dim()): x = max(0.0, basis.eval(gp.getLevel(d), gp.getIndex(d), p[d])) val *= x res += alpha[i] * val return res
def evalSGFunction(grid, alpha, p, isConsistent=True): if grid.getSize() != len(alpha): raise AttributeError( "grid size differs from length of coefficient vector") if len(p.shape) == 1: if grid.getStorage().getDimension() != p.shape[0]: raise AttributeError( "grid dimension differs from dimension of sample") evalNaiveGridTypes = [ GridType_Bspline, GridType_BsplineClenshawCurtis, GridType_BsplineBoundary, GridType_ModBsplineClenshawCurtis, GridType_ModBspline, GridType_LinearClenshawCurtis, GridType_LinearClenshawCurtisBoundary, GridType_ModLinearClenshawCurtis, GridType_PolyClenshawCurtis, GridType_PolyClenshawCurtisBoundary, GridType_ModPolyClenshawCurtis ] p_vec = DataVector(p) alpha_vec = DataVector(alpha) if isConsistent: if grid.getType() in evalNaiveGridTypes: opEval = createOperationEvalNaive(grid) else: opEval = createOperationEval(grid) else: opEval = createOperationEvalNaive(grid) ans = opEval.eval(alpha_vec, p_vec) del opEval del alpha_vec del p_vec return ans else: if grid.getStorage().getDimension() != p.shape[1]: raise AttributeError( "grid dimension differs from dimension of samples") return evalSGFunctionMulti(grid, alpha, p, isConsistent)
def computeMin(self, i, grid, alpha, nodalValues): gs = grid.getStorage() numDims = gs.getDimension() opEval = createOperationEval(grid) alphaVec = DataVector(alpha) gp = gs.getPoint(i) p = DataVector(numDims) gp.getStandardCoordinates(p) value = float("inf") level, index = getLevelIndex(gp) for idim in range(numDims): left, right = getGridPointsOnBoundary(level[idim], index[idim]) if left is not None: llevel, lindex = left p[idim] = 2**-llevel * lindex leftValue = opEval.eval(alphaVec, p) else: leftValue = 0.0 if right is not None: rlevel, rindex = right p[idim] = 2**-rlevel * rindex rightValue = opEval.eval(alphaVec, p) else: rightValue = 0.0 interpolatedValue = abs(leftValue - rightValue) / 2 if interpolatedValue < value: value = interpolatedValue # reset p p[idim] = 2**-level[idim] * index[idim] return value
## function value at the grid point's coordinates which are obtained by ## \c getStandardCoordinate(dim). ## The current coefficient vector is then printed. for i in range(gridStorage.getSize()): gp = gridStorage.getPoint(i) alpha[i] = f(gp.getStandardCoordinate(0), gp.getStandardCoordinate(1)) print("alpha before hierarchization: {}".format(alpha)) ## An object of sgpp::base::OperationHierarchisation is created and used to ## hierarchize the coefficient vector, which we print. pysgpp.createOperationHierarchisation(grid).doHierarchisation(alpha) print("alpha after hierarchization: {}".format(alpha)) ## Finally, a second DataVector is created which is used as a point to ## evaluate the sparse grid function at. An object is obtained which ## provides an evaluation operation (of type sgpp::base::OperationEvaluation), ## and the sparse grid interpolant is evaluated at \f$\vec{p}\f$, ## which is close to (but not exactly at) a grid point. p = pysgpp.DataVector(dim) p[0] = 0.52 p[1] = 0.73 opEval = pysgpp.createOperationEval(grid) print("u(0.52, 0.73) = {}".format(opEval.eval(alpha, p))) ## The example results in the following output: ## \verbinclude tutorial.output.txt ## It can be clearly seen that the surpluses decay with a factor of 1/4: ## On the first level, we obtain 1, on the second 1/4, and on the third ## 1/16 as surpluses.
def predict_next_value(self, test_vector): opEval = pysgpp.createOperationEval(self._learner.grid) vector = DataVector(len(test_vector)) for i in xrange(len(test_vector)): vector[i] = test_vector[i] return opEval.eval(self._learner.alpha, vector)
print "dimensionality: {}".format(gridStorage.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()) alpha.setAll(0.0) print "length of alpha vector: {}".format(len(alpha)) # set function values in alpha f = lambda x0, x1: 16.0 * (x0-1.0)*x0 * (x1-1.0)*x1 for i in xrange(gridStorage.size()): gp = gridStorage.get(i) alpha[i] = f(gp.getCoord(0), gp.getCoord(1)) print "alpha before hierarchization: {}".format(alpha) # hierarchize createOperationHierarchisation(grid).doHierarchisation(alpha) print "alpha after hierarchization: {}".format(alpha) # evaluate p = DataVector(dim) p[0] = 0.52 p[1] = 0.73 opEval = createOperationEval(grid) print "u(0.52, 0.73) = {}".format(opEval.eval(alpha, p))
print "dimensionality: {}".format(gridStorage.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()) alpha.setAll(0.0) print "length of alpha vector: {}".format(len(alpha)) # set function values in alpha f = lambda x0, x1: 16.0 * (x0 - 1.0) * x0 * (x1 - 1.0) * x1 for i in xrange(gridStorage.size()): gp = gridStorage.get(i) alpha[i] = f(gp.getCoord(0), gp.getCoord(1)) print "alpha before hierarchization: {}".format(alpha) # hierarchize createOperationHierarchisation(grid).doHierarchisation(alpha) print "alpha after hierarchization: {}".format(alpha) # evaluate p = DataVector(dim) p[0] = 0.52 p[1] = 0.73 opEval = createOperationEval(grid) print "u(0.52, 0.73) = {}".format(opEval.eval(alpha, p))
def plotGrid(grid, alpha, admissibleSet, params, refined=None): gs = grid.getStorage() x = [0.0] * gs.size() y = [0.0] * gs.size() for i in xrange(gs.size()): x[i] = gs.get(i).getCoord(0) y[i] = gs.get(i).getCoord(1) xa = [0.0] * len(admissibleSet) ya = [0.0] * len(admissibleSet) for i, gp in enumerate(admissibleSet): xa[i] = gp.getCoord(0) ya[i] = gp.getCoord(1) xr = [] yr = [] if refined: xr = [0.0] * len(refined) yr = [0.0] * len(refined) for i, ix in enumerate(refined): xr[i] = gs.get(ix).getCoord(0) yr[i] = gs.get(ix).getCoord(1) n = 50 A = np.ones(n * n).reshape(n, n) B = np.ones(n * n).reshape(n, n) U = params.getIndependentJointDistribution() bounds = U.getBounds() opEval = createOperationEval(grid) for i, xi in enumerate(np.linspace(bounds[0][0], bounds[0][1], n)): for j, yj in enumerate(np.linspace(bounds[1][0], bounds[1][1], n)): A[i, j] = U.pdf([yj, 1 - xi]) B[i, j] = opEval.eval(alpha, DataVector([xi, yj])) fig = plt.figure() plt.imshow(A, interpolation='bicubic', extent=[0,1,0,1]) plt.jet() plt.colorbar() plt.plot(x, y, linestyle=' ', marker='o', color='g', markersize=20) # grid # plt.plot(xa, ya, linestyle=' ', marker='^', color = 'y', markersize=20) # admissible set plt.plot(xr, yr, linestyle=' ', marker='v', color = 'r', markersize=20) # refined points plt.title("size = %i" % gs.size()) # plt.xlim(0, 1) # plt.ylim(0, 1) # fig = plt.figure() # plt.imshow(B, interpolation='bicubic', extent=[0,1,0,1]) # plt.jet() # plt.colorbar() # fig.show() global myid # plt.savefig("out_%i.jpg" % (myid)) # plt.close() myid += 1 return fig
def plotGrid(grid, alpha, admissibleSet, params, refined=None): gs = grid.getStorage() x = [0.0] * gs.size() y = [0.0] * gs.size() for i in xrange(gs.size()): x[i] = gs.get(i).getCoord(0) y[i] = gs.get(i).getCoord(1) xa = [0.0] * len(admissibleSet) ya = [0.0] * len(admissibleSet) for i, gp in enumerate(admissibleSet): xa[i] = gp.getCoord(0) ya[i] = gp.getCoord(1) xr = [] yr = [] if refined: xr = [0.0] * len(refined) yr = [0.0] * len(refined) for i, ix in enumerate(refined): xr[i] = gs.get(ix).getCoord(0) yr[i] = gs.get(ix).getCoord(1) n = 50 A = np.ones(n * n).reshape(n, n) B = np.ones(n * n).reshape(n, n) U = params.getIndependentJointDistribution() bounds = U.getBounds() opEval = createOperationEval(grid) for i, xi in enumerate(np.linspace(bounds[0][0], bounds[0][1], n)): for j, yj in enumerate(np.linspace(bounds[1][0], bounds[1][1], n)): A[i, j] = U.pdf([yj, 1 - xi]) B[i, j] = opEval.eval(alpha, DataVector([xi, yj])) fig = plt.figure() plt.imshow(A, interpolation='bicubic', extent=[0, 1, 0, 1]) plt.jet() plt.colorbar() plt.plot(x, y, linestyle=' ', marker='o', color='g', markersize=20) # grid # plt.plot(xa, ya, linestyle=' ', marker='^', color = 'y', markersize=20) # admissible set plt.plot(xr, yr, linestyle=' ', marker='v', color='r', markersize=20) # refined points plt.title("size = %i" % gs.size()) # plt.xlim(0, 1) # plt.ylim(0, 1) # fig = plt.figure() # plt.imshow(B, interpolation='bicubic', extent=[0,1,0,1]) # plt.jet() # plt.colorbar() # fig.show() global myid # plt.savefig("out_%i.jpg" % (myid)) # plt.close() myid += 1 return fig