def test_1(self):
storage = self.grid.getStorage()
coord = DataVector(storage.getDimension())
num_coeff = self.alpha.__len__()
values = [
self.functor.__call__(storage, i) for i in range(storage.getSize())
]
expect = []
opEval = createOperationEval(self.grid)
for i in range(num_coeff):
# print i
val = 0
single = DataVector(num_coeff)
single.__setitem__(i, self.alpha.__getitem__(i))
for j in range(self.trainData.getNrows()):
self.trainData.getRow(j, coord)
val += abs(
opEval.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)
def calc_indicator_value(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)
col = DataVector(numData)
alpha.__setitem__(seq, 1.0)
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 calc_indicator_value(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)
col = DataVector(numData)
alpha.__setitem__(seq, 1.0)
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 test_1(self):
storage = self.grid.getStorage()
coord = DataVector(storage.getDimension())
num_coeff = self.alpha.__len__()
#
# First part
#
values = [self.functor.__call__(storage,i) for i in range(storage.getSize())]
expect = []
opEval = createOperationEval(self.grid)
for j in range(num_coeff):
row = DataVector(DIM)
tmp_alpha = DataVector(self.alpha.__len__())
tmp_alpha.setAll(0.0)
tmp_alpha.__setitem__(j, 1.0)
current = 0
for i in range(self.trainData.getNrows()):
self.trainData.getRow(i, row)
current += (self.errors.__getitem__(i) * opEval.eval(tmp_alpha, row)) ** 2
self.accum.__setitem__(j, self.accum.__getitem__(j) * (1-BETA) + BETA * current * abs(self.alpha.__getitem__(j)))
expect.append(self.accum.__getitem__(j))
self.assertEqual(values, expect)
#
# Second part
#
values = [self.functor.__call__(storage,i) for i in range(storage.getSize())]
expect = []
opEval = createOperationEval(self.grid)
for j in range(num_coeff):
row = DataVector(DIM)
tmp_alpha = DataVector(self.alpha.__len__())
tmp_alpha.setAll(0.0)
tmp_alpha.__setitem__(j, 1.0)
current = 0
for i in range(self.trainData.getNrows()):
self.trainData.getRow(i, row)
current += (self.errors.__getitem__(i) * opEval.eval(tmp_alpha, row)) ** 2
self.accum.__setitem__(j, self.accum.__getitem__(j) * (1-BETA) + BETA * current * abs(self.alpha.__getitem__(j)))
expect.append(self.accum.__getitem__(j))
self.assertEqual(values, expect)
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)
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
class TestWeightedRefinementOperator(unittest.TestCase):
def setUp(self):
#
# Grid
#
DIM = 2
LEVEL = 2
self.grid = Grid.createLinearGrid(DIM)
self.grid_gen = self.grid.getGenerator()
self.grid_gen.regular(LEVEL)
#
# trainData, classes, errors
#
xs = []
DELTA = 0.05
DELTA_RECI = int(1 / DELTA)
for i in range(DELTA_RECI):
for j in range(DELTA_RECI):
xs.append([DELTA * i, DELTA * j])
random.seed(1208813)
ys = [random.randint(-10, 10) for i in range(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)
opEval = createOperationEval(self.grid)
for i in range(self.trainData.getNrows()):
self.trainData.getRow(i, coord)
self.errors.__setitem__(
i, self.classes[i] - opEval.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.getDimension())
num_coeff = self.alpha.__len__()
values = [
self.functor.__call__(storage, i) for i in range(storage.getSize())
]
expect = []
opEval = createOperationEval(self.grid)
for i in range(num_coeff):
# print i
val = 0
single = DataVector(num_coeff)
single.__setitem__(i, self.alpha.__getitem__(i))
for j in range(self.trainData.getNrows()):
self.trainData.getRow(j, coord)
val += abs(
opEval.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)
class TestPersistentRefinementOperator(unittest.TestCase):
def setUp(self):
#
# Grid
#
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))
#
# Functor
#
self.functor = PersistentErrorRefinementFunctor(self.alpha, self.grid)
self.functor.setTrainDataset(self.trainData)
self.functor.setClasses(self.classes)
self.functor.setErrors(self.errors)
self.accum = DataVector(self.alpha.__len__())
self.accum.setAll(0.0)
def test_1(self):
storage = self.grid.getStorage()
coord = DataVector(storage.dim())
num_coeff = self.alpha.__len__()
#
# First part
#
values = [
self.functor.__call__(storage, i) for i in xrange(storage.size())
]
expect = []
for j in xrange(num_coeff):
row = DataVector(DIM)
tmp_alpha = DataVector(self.alpha.__len__())
tmp_alpha.setAll(0.0)
tmp_alpha.__setitem__(j, 1.0)
current = 0
for i in xrange(self.trainData.getNrows()):
self.trainData.getRow(i, row)
current += (self.errors.__getitem__(i) *
self.grid.eval(tmp_alpha, row))**2
self.accum.__setitem__(
j,
self.accum.__getitem__(j) * (1 - BETA) +
BETA * current * abs(self.alpha.__getitem__(j)))
expect.append(self.accum.__getitem__(j))
self.assertEqual(values, expect)
#
# Second part
#
values = [
self.functor.__call__(storage, i) for i in xrange(storage.size())
]
expect = []
for j in xrange(num_coeff):
row = DataVector(DIM)
tmp_alpha = DataVector(self.alpha.__len__())
tmp_alpha.setAll(0.0)
tmp_alpha.__setitem__(j, 1.0)
current = 0
for i in xrange(self.trainData.getNrows()):
self.trainData.getRow(i, row)
current += (self.errors.__getitem__(i) *
self.grid.eval(tmp_alpha, row))**2
self.accum.__setitem__(
j,
self.accum.__getitem__(j) * (1 - BETA) +
BETA * current * abs(self.alpha.__getitem__(j)))
expect.append(self.accum.__getitem__(j))
self.assertEqual(values, expect)
class TestOnlinePredictiveRefinementDimension(unittest.TestCase):
def setUp(self):
#
# Grid
#
DIM = 2
LEVEL = 2
self.grid = Grid.createLinearGrid(DIM)
self.grid_gen = self.grid.getGenerator()
self.grid_gen.regular(LEVEL)
#
# trainData, classes, errors
#
xs = []
DELTA = 0.05
DELTA_RECI = int(1 / DELTA)
for i in range(DELTA_RECI):
for j in range(DELTA_RECI):
xs.append([DELTA * i, DELTA * j])
random.seed(1208813)
ys = [random.randint(-10, 10) for i in range(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)
opEval = createOperationEval(self.grid)
self.errors = DataVector(DELTA_RECI**2)
coord = DataVector(DIM)
for i in range(self.trainData.getNrows()):
self.trainData.getRow(i, coord)
self.errors.__setitem__(
i, abs(self.classes[i] - opEval.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.getDimension()
print("######")
print("Expected result:")
print("######")
expected = {}
for j in range(gridSize):
HashGridPoint = storage.getPoint(j)
HashGridPoint.setLeaf(False)
print("Point: ", j, " (", HashGridPoint.toString(), ")")
for d in range(numDim):
#
# Get left and right child
#
leftChild = HashGridPoint(HashGridPoint)
rightChild = HashGridPoint(HashGridPoint)
storage.left_child(leftChild, d)
storage.right_child(rightChild, d)
#
# Check if point is refinable
#
if storage.isContaining(leftChild) or storage.isContaining(
rightChild):
continue
#
# Insert children temporarily
#
storage.insert(leftChild)
storage.insert(rightChild)
val1 = self.calc_indicator_value(leftChild)
val2 = self.calc_indicator_value(rightChild)
storage.deleteLast()
storage.deleteLast()
print("Dimension: ", d)
print("Left Child: ", val1)
print("Right Child: ", val2)
print("")
expected[(j, d)] = val1 + val2
print("")
for k, v in list(expected.items()):
print((k, v))
print("######")
print("Actual result:")
print("######")
actual = refinement_map({})
self.strategy.collectRefinablePoints(storage, 10, actual)
for k, v in list(actual.items()):
print((k, v))
#
# Assertions
#
for k, v in list(expected.items()):
self.assertEqual(actual[k], v)
def calc_indicator_value(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)
col = DataVector(numData)
alpha.__setitem__(seq, 1.0)
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
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)
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)
storage.deleteLast()
storage.deleteLast()
print "Dimension: ", d
print "Left Child: ", val1
print "Right Child: ", val2
print ""
expected[(j, d)] = val1 + val2
print ""
for k, v in expected.iteritems():
print(k, v)
print "######"
print "Actual result:"
print "######"
actual = refinement_map({})
self.strategy.collectRefinablePoints(storage, 10, actual)
for k, v in actual.iteritems():
print(k, v)
#
# Assertions
#
for k, v in expected.iteritems():
self.assertEqual(actual[k], v)
def calc_indicator_value(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)
col = DataVector(numData)
alpha.__setitem__(seq, 1.0)
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
