Python DataMatrix.getNrows方法代码示例

# 需要导入模块: from pysgpp import DataMatrix [as 别名]
# 或者: from pysgpp.DataMatrix import getNrows [as 别名]
def estimateDiscreteL2Error(grid, alpha, f, n=1000):
    gs = grid.getStorage()
    # create control samples
    samples = DataMatrix(np.random.rand(n, gs.dim()))

    nodalValues = evalSGFunctionMulti(grid, alpha, samples)
    fvalues = DataVector(samples.getNrows())
    for i, sample in enumerate(samples.array()):
        fvalues[i] = f(sample)

    # compute the difference
    nodalValues.sub(fvalues)
    return nodalValues.l2Norm()

# 需要导入模块: from pysgpp import DataMatrix [as 别名]
# 或者: from pysgpp.DataMatrix import getNrows [as 别名]
    def var(self, grid, alpha, U, T, mean):
        r"""
        Extraction of the expectation the given sparse grid function
        interpolating the product of function value and pdf.

        \int\limits_{[0, 1]^d} (f(x) - E(f))^2 * pdf(x) dx
        """
        # extract correct pdf for moment estimation
        vol, W = self._extractPDFforMomentEstimation(U, T)
        D = T.getTransformations()

        # copy the grid, and add a trapezoidal boundary
#         ngrid = GridDescriptor().fromGrid(grid)\
#                                 .withBorder(BorderTypes.TRAPEZOIDBOUNDARY)\
#                                 .createGrid()
        # compute nodalValues
#         ngs = ngrid.getStorage()
#         nodalValues = DataVector(ngs.size())
#         p = DataVector(ngs.dim())
#         for i in xrange(ngs.size()):
#             ngs.get(i).getCoords(p)
#             nodalValues[i] = evalSGFunction(grid, alpha, p) - mean
#
#         # hierarchize the new function
#         nalpha = hierarchize(ngrid, nodalValues)

        ngs = grid.getStorage()
        ngrid, nalpha = grid, alpha

        # compute the integral of the product times the pdf
        acc = DataMatrix(ngs.size(), ngs.size())
        acc.setAll(1.)
        err = 0
        for i, dims in enumerate(W.getTupleIndices()):
            dist = W[i]
            trans = D[i]
            # get the objects needed for integrating
            # the current dimensions
            gpsi, basisi = project(ngrid, dims)

            if isinstance(dist, SGDEdist):
                # project distribution on desired dimensions
                # get the objects needed for integrating
                # the current dimensions
                gpsk, basisk = project(dist.grid, range(len(dims)))
                # compute the bilinear form
                tf = TrilinearGaussQuadratureStrategy([dist], trans)
                A, erri = tf.computeTrilinearFormByList(gpsk, basisk, dist.alpha,
                                                        gpsi, basisi,
                                                        gpsi, basisi)
            else:
                # we compute the bilinear form of the grids
                # compute the bilinear form
                if len(dims) == 1:
                    dist = [dist]
                    trans = [trans]

                bf = BilinearGaussQuadratureStrategy(dist, trans)
                A, erri = bf.computeBilinearFormByList(gpsi, basisi,
                                                       gpsi, basisi)
            # accumulate the results
            acc.componentwise_mult(A)

            # accumulate the error
            err += acc.sum() / (acc.getNrows() * acc.getNcols()) * erri

        # compute the variance
        tmp = DataVector(acc.getNrows())
        self.mult(acc, nalpha, tmp)
        moment = vol * nalpha.dotProduct(tmp)

        moment = moment - mean ** 2

        return moment, err

# 需要导入模块: from pysgpp import DataMatrix [as 别名]
# 或者: from pysgpp.DataMatrix import getNrows [as 别名]

#.........这里部分代码省略.........
                'samplesOutput' in s.options('denest'):
            samplesfile = s.get('denest', 'samplesOutput')

        testFile = None
        if 'inFileTest' in s.options('files'):
            testFile = s.get('files', 'inFileTest')

        testOutFile = None
        if 'outFileTest' in s.options('files') and \
                'inFileTest' in s.options('files'):
            testOutFile = s.get('files', 'outFileTest')

        bandwidthsfile = None
        if 'printBandwidthsFile' in s.options('denest'):
            bandwidthsfile = s.get('denest', 'printBandwidthsFile')

        surfacefile = None
        if 'printSurfaceFile' in s.options('denest'):
            surfacefile = s.get('denest', 'printSurfaceFile')

        return traindatafile, samplesfile, testFile, testOutFile, bandwidthsfile, surfacefile

    def pdf_libagf(self, x):
        if isNumerical(x):
            x = [x]
        x = tuple(x)

        if x in self.testData:
            return self.testData[x]
        else:
            raise AttributeError("No pdf value for '%s' available" % (x,))

    def pdf(self, x):
        n = self.trainData.getNrows()
        sigma = self.bandwidths.array()
        # normalization coefficient
        norm = 1. / (sigma * np.sqrt(2. * np.pi))

        trainData = self.trainData.array()

        # normalize it
        trainData = (x - trainData) / sigma
        trainData = norm * np.exp(-trainData ** 2 / 2.)

        # scale the result by the number of samples
        return np.sum(np.prod(trainData, axis=1)) / n

    def cdf(self, x):
        # convert the parameter to the right format
        if isList(x):
            x = DataVector(x)
        elif isNumerical(x):
            x = DataVector([x])

        if isinstance(x, DataMatrix):
            A = x
            B = DataMatrix(A.getNrows(), A.getNcols())
            B.setAll(0.0)
        elif isinstance(x, DataVector):
            A = DataMatrix(1, len(x))
            A.setRow(0, x)
            B = DataMatrix(1, len(x))
            B.setAll(0)

        # do the transformation
        op = createOperationRosenblattTransformationKDE(self.trainData)

# 需要导入模块: from pysgpp import DataMatrix [as 别名]
# 或者: from pysgpp.DataMatrix import getNrows [as 别名]
class TestWeightedRefinementOperator(unittest.TestCase):


    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 test_1(self):
        storage = self.grid.getStorage()
        coord = DataVector(storage.dim())
        num_coeff = self.alpha.__len__()

        values = [self.functor.__call__(storage,i) for i in xrange(storage.size())]
        expect = []
        for i in xrange(num_coeff):
            # print i
            val = 0
            single = DataVector(num_coeff)
            single.__setitem__(i, self.alpha.__getitem__(i))
            for j in xrange(self.trainData.getNrows()):
                self.trainData.getRow(j, coord)
                val += abs( self.grid.eval(single, coord) * (self.errors.__getitem__(j)**2) )
            expect.append(val)

        # print values
        # print expect

        # print [ values[i]/expect[i] for i in xrange(values.__len__())]
        
        self.assertEqual(values, expect)

# 需要导入模块: from pysgpp import DataMatrix [as 别名]
# 或者: from pysgpp.DataMatrix import getNrows [as 别名]

#.........这里部分代码省略.........

        for k,v in naive_result.iteritems():
            self.assertAlmostEqual(naive_result[k], result[k])


    def naive_calc(self):

        result = {}

        for j in xrange(self.gridSize):

            HashGridIndex = self.storage.get(j)
            HashGridIndex.setLeaf(False)

            print "Point: ", j, " (", HashGridIndex.toString(), ")"

            for d in xrange(self.dim):

                print "Dimension: ", d

                #
                # Get left and right child
                #

                leftChild = HashGridIndex(HashGridIndex)
                rightChild = HashGridIndex(HashGridIndex)

                self.storage.left_child(leftChild, d)
                self.storage.right_child(rightChild, d)

                #
                # Check if point is refinable
                #

                if self.storage.has_key(leftChild) or self.storage.has_key(rightChild):
                    continue

                #
                # Insert children temporarily
                #

                self.storage.insert(leftChild) 
                self.storage.insert(rightChild) 

                val1 = self.naive_calc_single(leftChild)
                print "Left Child: ", val1

                val2 = self.naive_calc_single(rightChild)
                print "Right Child: ", val2
                
                self.storage.deleteLast()
                self.storage.deleteLast()

                result[(j, d)] = val1 + val2

                print ""

        return result

    def naive_calc_single(self, index):

        numData = self.trainData.getNrows()
        numCoeff = self.grid.getSize()
        seq = self.grid.getStorage().seq(index)
        num = 0
        denom = 0

        tmp = DataVector(numCoeff)
        self.multEval.multTranspose(self.errors, tmp) 

        num = tmp.__getitem__(seq)
        num **= 2

        alpha = DataVector(numCoeff)
        alpha.setAll(0.0)
        alpha.__setitem__(seq, 1.0)

        col = DataVector(numData)
        self.multEval.mult(alpha, col)

        print col

        col.sqr()

        denom = col.sum()

        print num
        print denom

        if denom == 0:
            print "Denominator is zero"
            value = 0
        else:
            value = num/denom 

        return value

    def tearDown(self):

        del self.grid

# 需要导入模块: from pysgpp import DataMatrix [as 别名]
# 或者: from pysgpp.DataMatrix import getNrows [as 别名]
class TestOnlinePredictiveRefinementDimension(unittest.TestCase):

    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 test_1(self):

        storage = self.grid.getStorage()
        gridSize = self.grid.getSize()
        numDim = storage.dim()

        print "######"
        print "Expected result:"
        print "######"

        expected = {}

        for j in xrange(gridSize):

            HashGridIndex = storage.get(j)
            HashGridIndex.setLeaf(False)
                
            print "Point: ", j, " (", HashGridIndex.toString(), ")"

            for d in xrange(numDim):

                #
                # Get left and right child
                #

                leftChild = HashGridIndex(HashGridIndex)
                rightChild = HashGridIndex(HashGridIndex)

                storage.left_child(leftChild, d)
                storage.right_child(rightChild, d)

                #
                # Check if point is refinable
                #

                if storage.has_key(leftChild) or storage.has_key(rightChild):
                    continue

                #
                # Insert children temporarily
                #

                storage.insert(leftChild) 
                storage.insert(rightChild) 

                val1 = self.calc_indicator_value(leftChild)
                val2 = self.calc_indicator_value(rightChild)
#.........这里部分代码省略.........

# 需要导入模块: from pysgpp import DataMatrix [as 别名]
# 或者: from pysgpp.DataMatrix import getNrows [as 别名]

#.........这里部分代码省略.........

                # print "Dimension: ", d

                #
                # Get left and right child
                #

                leftChild = HashGridIndex(HashGridIndex)
                rightChild = HashGridIndex(HashGridIndex)

                self.storage.left_child(leftChild, d)
                self.storage.right_child(rightChild, d)

                #
                # Check if point is refinable
                #

                if self.storage.has_key(leftChild) or self.storage.has_key(rightChild):
                    continue

                #
                # Insert children temporarily
                #

                self.storage.insert(leftChild) 
                self.storage.insert(rightChild) 

                val1 = self.naive_calc_single(leftChild)
                # print "Left Child: ", val1

                val2 = self.naive_calc_single(rightChild)
                # print "Right Child: ", val2
                
                self.storage.deleteLast()
                self.storage.deleteLast()

                result[(j, d)] = val1 + val2

                # print ""

        return result

    def naive_calc_single(self, index):

        numData = self.trainData.getNrows()
        numCoeff = self.grid.getSize()
        seq = self.grid.getStorage().seq(index)
        num = 0
        denom = 0

        tmp = DataVector(numCoeff)
        self.multEval.multTranspose(self.errors, tmp) 

        num = tmp.__getitem__(seq)
        num **= 2

        alpha = DataVector(numCoeff)
        alpha.setAll(0.0)
        alpha.__setitem__(seq, 1.0)

        col = DataVector(numData)
        self.multEval.mult(alpha, col)

        col.sqr()

        denom = col.sum()

        if denom == 0:
            # print "Denominator is zero"
            value = 0
        else:
            value = num/denom 

        return value

    def get_random_x(self, d):
        DELTA = 0.10

        x = []
        for i in xrange(d):
            x.append(random.choice(numpy.arange(0, 1.01, DELTA)))

        return x

    def get_random_x_wo_boundary(self, d):
        DELTA = 0.10

        x = []
        for i in xrange(d):
            x.append(random.choice(numpy.arange(0.1, 0.91, DELTA)))

        return x

    def get_random_err(self):
        DELTA = 0.1
        return random.choice(numpy.arange(-3, 3.01, DELTA))

    def get_random_err_pos(self):
        DELTA = 0.1
        return random.choice(numpy.arange(0, 3.01, DELTA))